def bakeFrames(ob,myipo): #bakes an object in a scene, returning the IPO containing the curves
myipoName = myipo.getName()
debug(20,'Baking frames for scene %s object %s to ipo %s' % (scn.getName(),ob.getName(),myipoName))
ipos = getCurves(myipo)
#TODO: Gui setup idea: myOffset
# reset action to start at frame 1 or at location
myOffset=0 #=1-staframe
#loop through frames in the animation. Often, there is rollup and the mocap starts late
staframe,endframe,curframe = getRenderInfo()
for frame in range(staframe, endframe+1):
debug(80,'Baking Frame %i' % frame)
#tell Blender to advace to frame
Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
if not BATCH: Blender.Redraw() # no secrets, let user see what we are doing
#using the constrained Loc Rot of the object, set the location of the unconstrained clone. Yea! Clones are FreeMen
key = getLocRot(ob,usrCoord) #a key is a set of specifed exact channel values (LocRotScale) for a certain frame
key = [a+b for a,b in zip(key, usrDelta)] #offset to the new location
myframe= frame+myOffset
Blender.Set(CURFRAME,myframe)
time = Blender.Get('curtime') #for BezTriple
ipos = addPoint(time,key,ipos) #add this data at this time to the ipos
debug(100,'%s %i %.3f %.2f %.2f %.2f %.2f %.2f %.2f' % (myipoName, myframe, time, key[0], key[1], key[2], key[3], key[4], key[5]))
# eye-candy - smoothly rewind the animation, showing now how the clone match moves
if endframe-staframe <400 and not BATCH:
for frame in range (endframe,staframe,-1): #rewind
Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
Blender.Redraw()
Blender.Set(CURFRAME,staframe)
Blender.Redraw()
return ipos
def BUTTON(evt):
global PARAM
if (evt == 1):
Exit()
if (evt == 2):
copy()
Blender.Redraw()
if (evt == 3):
PARAM = renew()
Blender.Redraw()
def sc_to_blender(sc):
"""Export each shape in the scene as a new object
:Parameters:
- `sc` (Scene) - the scene to transform
:Returns Type: None
"""
bldsc = Scene.GetCurrent()
#fill with shapes
t = time.time()
d = Discretizer()
for ind, shp in enumerate(sc):
if ind % 10 == 0:
print ind,
sys.stdout.flush()
ob = shp_to_blender(shp, d)
bldsc.link(ob)
ob.sel = True
print
print 'Time :', time.time() - t
#return
print "created"
bldsc.update(1)
Blender.Redraw()
return ob
def load_sculptie(filename):
time1 = Blender.sys.time()
Blender.SaveUndoState("Import Sculptie")
#print "--------------------------------"
print 'Importing "%s"' % filename
scene = Blender.Scene.GetCurrent()
for ob in scene.objects.selected:
ob.sel = False
in_editmode = Blender.Window.EditMode()
# MUST leave edit mode before changing an active mesh:
if in_editmode:
Blender.Window.EditMode(0)
else:
try:
in_editmode = Blender.Get('add_editmode')
except:
pass
f, e = Blender.sys.splitext(filename)
e = e.lower()
if e == '.dae':
import_collada(filename)
elif e == '.obj':
import_obj(filename)
else:
try:
ob = sculpty.open(filename)
except:
Blender.Draw.PupBlock(
"Sculptie Import Error",
["Unsupported file type", "Use .dae or an image file"])
if in_editmode:
Blender.Window.EditMode(1)
Blender.Redraw()
print 'Loaded Sculptmap "%s" in %.4f sec.' % (filename,
(Blender.sys.time() - time1))
def import_billboard(path):
'''
Parse the billboard(.bb) file and construct the rectangular frame one by one
'''
# parse file and get the vertex array, texture array and texture's path
input = open(path, 'r')
verts, texs, tex_path = parse_file(input)
input.close()
# load the tiled texture
img = Image.Load(tex_path)
# add frames to current scene
scn = Scene.GetCurrent()
# 4 verts and 4 tex per frame
if False:
for i in xrange(len(verts) / 4):
name = 'frame_%d' % i
frame = construct_frame(name, verts[i * 4:i * 4 + 4],
texs[i * 4:i * 4 + 4], img)
ob = scn.objects.new(frame, name)
if True:
name = Blender.sys.makename(path, strip=1)
foilage = construct_foilage(name, verts, texs, img)
ob = scn.objects.new(foilage, name)
Blender.Redraw()
def importScene(colladaNode):
global currentScene
global library
# Build scene
# TODO: Add option for creating a new scene or import into current scene!
# Get <scene> element
sceneElements = colladaNode.getElementsByTagName('scene')
sceneElement = None
if not sceneElements is None:
sceneElement = sceneElements[0]
name = sceneElement.attributes.getNamedItem('name')
if not name is None:
currentScene.setName(name.value)
# Import nodes
nodeElements = getElements(sceneElement, 'node')
if not nodeElements is None:
for node in nodeElements:
type = node.attributes.getNamedItem('type')
if not type is None:
if type.value == 'JOINT':
pass
else:
importNode(None, node)
else:
importNode(None, node)
# Update scene
currentScene.update()
Blender.Redraw()
def main():
scene = Blender.Scene.GetCurrent()
ob = scene.objects.active
Blender.Window.EditMode(0)
scale_map_uv(ob, False)
Blender.Window.EditMode(1)
Blender.Redraw()
def import_all(self, scene):
root = self.getRoot()
reflist1 = []
# 1st pass - objects containing lights...
for ref in self.SceneObjects.vector:
o = root.findref(ref)
LightInfo = False
for r in o.data.data1.vector:
if r.Key.object_type in [0x55, 0x56, 0x57]:
LightInfo = True
if LightInfo:
o.data.import_all(scene)
else:
reflist1.append(ref)
# 2nd pass - other objects
for ref in reflist1:
o = root.findref(ref)
o.data.import_all(scene)
Blender.Redraw()
def new_from_children(parent, processed_objects, image_dict, offset):
report = ""
new_children = []
all_children = []
siblings = obChildren(parent)
for ob in siblings:
allready_processed_object = processed_objects.get(ob.getName())
if allready_processed_object == None:
processed_objects[ob.getName()] = ob
ac, children, creport = new_from_children(ob, processed_objects,
image_dict, offset)
if creport != "":
report = report + creport
if sculpty.check(ob):
#print "Copy from ", ob.getName()
new_object, log = new_from_object(ob, image_dict, offset)
if new_object != None:
if len(children) > 0:
Blender.Redraw()
new_object.makeParent(children)
all_children.extend(ac)
new_object.select(False)
new_children.append(new_object)
#else:
# print "Warn: copy of [", ob.getName(), "] failed."
else:
log = "Warn: Not a sculptie [" + ob.getName(
) + "] (Object not copied)|"
if log != "":
print log
report = report + log
return all_children, new_children, report
def bevent(evt):
global etape, soft_type, liste_phoneme, dico_phoneme_export
if (evt == 1):
Exit()
elif (evt == 2):
#c'est l'import du dictionnaire
#we create and import the dictionnary
lecture_chaine(mon_fichier_dico, dico_phoneme_export)
construction_dictionnaire_phoneme()
#we change the stage
etape = 1
elif (evt == 3):
#c'est l'import
#we import
lecture_chaine(mon_fichier_export, dico_phoneme_export)
construction_dico_correspondance()
construction_lipsynchro()
#on change d'etape
#we change the stage
etape = 2
elif (evt == 8):
#we choose the file
Blender.Window.FileSelector(selectionner_fichier, "Select File")
Blender.Redraw()
def fileselection_callback(filename):
log("Reading mesh file %s..." % filename)
# is this a mesh file instead of an xml file?
if (filename.lower().find('.xml') == -1):
# No. Use the xml converter to fix this
log("No mesh.xml file. Trying to convert it from binary mesh format.")
convert_meshfile(filename)
filename += '.xml'
dirname = Blender.sys.dirname(filename)
basename = Blender.sys.basename(filename)
log("dirname: %s" % dirname)
log("basename: %s" % basename)
# parse material files and make up a dictionary: {mat_name:material, ..}
materials = collect_materials(dirname)
# prepare the SAX parser and parse the file using our own content handler
parser = xml.sax.make_parser()
handler = OgreMeshSaxHandler()
parser.setContentHandler(handler)
parser.parse(open(filename))
# create the mesh from the parsed data and link it to a fresh object
scene = Blender.Scene.GetCurrent()
meshname = basename[0:basename.lower().find('.mesh.xml')]
object = CreateBlenderMesh(meshname, handler.mesh, materials)
scene.link(object)
object.select(True)
log("import completed.")
Blender.Redraw()
def UpdateMesh(): global ob, me, sc, dwidget # get input parameters to generate the cylinder h, angle, isegs, baserad, turn, tface, bface, closed = GetData(dwidget) toprad = baserad - (h * tan(radians(angle))) # NOTE: to avoid getting weird shapes, uncomment the line below toprad = fabs(toprad) ClearMeshGeometry(me) # generate the vertices of the top circle and base circle GenerateVertices(me, toprad, isegs, h, turn) GenerateVertices(me, baserad, isegs, 0.0, turn) # make a vertex at top-center and bottom-center GenerateVertex(me, 0.0, 0.0, h) GenerateVertex(me, 0.0, 0.0, 0.0) # Generate face list GenerateFaces(me, turn, tface, bface, closed) # update the mesh me.update() DeselectAllObjects() ob.select(1) Blender.Redraw()
def read(filename):
'''Read points in x, y, z format from file'''
#start = time.clock()
file = open(filename, "rb")
objname = Blender.sys.splitext(Blender.sys.basename(filename))[0]
me = NMesh.GetRaw()
# Collect data from RAW format
for line in file.readlines():
try:
try:
f1, f2, f3, f4 = map(float, line.split())
except: # raw triangle so take first three only
#f1, f2, f3, f4, f5, f6, f7, f8, f9 = map(float, line.split())
f1, f2, f3 = map(float, line.split())
v = NMesh.Vert(f1, f2, f3)
me.verts.append(v)
except:
continue
NMesh.PutRaw(me, objname)
Blender.Object.GetSelected()[0].name = objname
Blender.Redraw()
Blender.Window.DrawProgressBar(1.0, '') # clear progressbar
file.close()
#end = time.clock()
#seconds = " in %.2f %s" % (end-start, "seconds")
message = "Successfully imported " + Blender.sys.basename(filename)# + seconds
meshtools.print_boxed(message)
def BUTTON(evt):
global PARAM, alignment, O, stringlist, CVS
if (evt == 1):
Exit()
elif (evt == 2):
rename()
elif (evt == 3):
PARAM, stringlist = renew()
elif (evt in [5, 6, 7, 8]):
for k in alignment.iterkeys():
if alignment[k][1] != evt:
alignment[k][0].val = 0
elif (evt in stringlist[0]):
O[PARAM[stringlist[1][(evt - 9) / 2]][2]].setName(
PARAM[stringlist[1][(evt - 9) / 2]][4].val)
PARAM, stringlist = renew()
elif (evt in stringlist[2]):
try:
O[PARAM[stringlist[1][(evt - 9) / 2]][2]].select(
PARAM[stringlist[1][(evt - 9) / 2]][0].val)
except:
pass
Blender.Redraw()
def bevel():
""" The main function, which creates the bevel """
global me, NV, NV_ext, NE, NC, old_faces, old_dist
ob = act_mesh_ob()
if not ob: return
Window.WaitCursor(1) # Change the Cursor
t = Blender.sys.time()
is_editmode = Window.EditMode()
if is_editmode: Window.EditMode(0)
me = ob.data
NV = {}
#PY23 NO SETS# NV_ext = set()
NV_ext = {}
NE = {}
NC = {}
old_faces = []
make_faces()
make_edges()
make_corners()
clear_old()
old_dist = dist.val
print '\tbevel in %.6f sec' % (Blender.sys.time() - t)
me.update(1)
if is_editmode: Window.EditMode(1)
Window.WaitCursor(0)
Blender.Redraw()
def clearCameras():
""" Removes all cameras from the scene. """
cameras = [cam for cam in scene.objects if cam.type == 'Camera']
for cam in cameras:
scene.objects.unlink(cam)
Blender.Redraw()
def bevent(evt):
"""
Handles GUI events.
"""
global EVENT_NOEVENT, EVENT_TOGGLE_NORMALS, EVENT_EXPORT, EVENT_EXIT
if (evt == EVENT_EXIT):
Exit()
elif (evt == EVENT_TOGGLE_NORMALS):
Blender.Redraw()
elif (evt == EVENT_EXPORT):
conductExport()
Blender.Redraw()
Exit()
def Select_All_Cameras(evt=None, val=None):
""" Selects all cameras in the scene, deselects everything else. """
for ob in scene.objects:
if ob.type == 'Camera':
ob.select(True);
else:
ob.select(False);
Blender.Redraw()
def bevent(evt):
if evt == 1: #exit
Exit()
elif evt == 2: #button
makeCameraBoss(levels.val, degrees.val, size.val, capbuffer.val)
Blender.Redraw()
def deiconify(self):
Blender.Redraw()
Tkinter.Tk.deiconify(self)
if self.grab_status() is None:
if platform == "win32":
self.grab_set()
else:
self.grab_set_global()
def ButtonEvent(self, event):
if event >= self.EVENT_GEOSETCHANGESTART and event < self.EVENT_GEOSETCHANGEEND:
geoset = event - self.EVENT_GEOSETCHANGESTART
# print "Activate geoset:",geoset,self.geoset_buttons[geoset].val
self.geoset_active[geoset] = self.geoset_buttons[geoset].val
ShowGeoset(geoset, self.geoset_buttons[geoset].val)
Blender.Redraw()
elif event == self.EVENT_FREEZE:
RemoveHiddenGeosets()
def open_library(name):
Library.Open(name)
groups = Library.LinkableGroups()
for db in groups:
print db
for obname in Library.Datablocks(db):
print obname
Library.Load(obname, db, 0)
Library.Update()
Library.Close()
Blender.Redraw()
def Import(tmo_node, tmo_mat):
####################
## Import() sub functions
##
####################
ob = Scene.GetCurrent().objects.active
if ob == None: return
if ob.type != "Armature": return
arm = ob.getData(False, False)
pose = ob.getPose()
for f1_1, f1_2 in zip(tmo_node, tmo_mat):
bone_name = f1_1.rpartition("|")[2]
if bone_name in arm.bones.keys():
#Scale
Smat = f1_2.copy().scalePart()
Smat = Matrix([Smat.x, 0, 0], [0, Smat.z, 0],
[0, 0, Smat.y]).resize4x4()
#Rotation
Rmat2 = arm.bones[bone_name].matrix["ARMATURESPACE"].copy().toQuat(
).toMatrix() * RotationMatrix(90, 3, "x")
Rmat2.resize4x4()
Rmat = f1_2.copy().toEuler()
Rmat = Euler(Rmat.x, -Rmat.y, -Rmat.z).toMatrix().resize4x4()
Rmat = Rmat2 * Rmat * Rmat2.invert()
#Translation
path = f1_1.split("|")
Tmat = arm.bones[bone_name].head["ARMATURESPACE"].copy()
if len(path) > 2 and path[-2] in arm.bones.keys():
Tmat = arm.bones[bone_name].head["ARMATURESPACE"].copy(
) - arm.bones[path[-2]].head["ARMATURESPACE"].copy()
Tmat2 = f1_2.copy().translationPart()
Tmat2 = Vector(Tmat2.x, -Tmat2.z, Tmat2.y) * 0.5
Tmat = Tmat - Tmat2
if len(path) > 2 and path[-2] in arm.bones.keys():
Tmat = Tmat * arm.bones[bone_name].matrix[
"ARMATURESPACE"].copy().toQuat().inverse()
pose.bones[bone_name].localMatrix = Smat * Rmat
pose.bones[bone_name].loc = Tmat
pose.update()
for f1 in Object.Get():
if f1.type == "Armature":
f1.getPose().update()
if f1.type == "Mesh":
f1.getData(False, True).update()
Blender.Redraw()
def create_mesh(verts, faces, objname, facesuv=[], uvcoords=[], normals=[]): if normals: normal_flag = 0 else: normal_flag = 1 mesh = Blender.NMesh.GetRaw() append_verts(mesh, verts, normals) append_faces(mesh, faces, facesuv, uvcoords) if not overwrite_mesh_name: objname = versioned_name(objname) ob= Blender.NMesh.PutRaw(mesh, objname, normal_flag) # Name the Mesh ob.name= objname # Name the Object Blender.Redraw()
def selectLshDirname(fname):
print "selectLshDirname = " + fname
dirname = os.path.dirname(fname)
if not os.path.exists(dirname):
Blender.Draw.PupMenu("directory [ %s ] does not exist!\t|OK" % dirname)
else:
TextboxLshDirName.val = os.path.dirname(fname)
Blender.Redraw()
def bevent(evt):
global Tn, Tl, Trat, Tran, Trav, Trx, Try, Trz, MaxAN
if (evt == 1): Exit()
elif (evt == 3):
polyhedron(Tn.val, Tl.val, Trx.val, Try.val, Trz.val)
Blender.Redraw()
elif (evt == 4):
MaxAN = Axis[Trat.val][Tn.val - 1]
if (Tran.val > MaxAN):
Tran.val = MaxAN
Blender.Redraw()
def setupAnim(StartFrame, EndFrame, VideoFrameRate):
debug(100, 'VideoFrameRate is %i' %VideoFrameRate)
if VideoFrameRate<1: VideoFrameRate=1
if VideoFrameRate>120: VideoFrameRate=120
# set up anim panel for them
context=scn.getRenderingContext()
context.startFrame(StartFrame)
context.endFrame(EndFrame)
context.framesPerSec(int(VideoFrameRate))
Blender.Set("curframe",StartFrame)
Blender.Redraw()
return
def _import_geom3d(node, skelObj):
mesh = lbf.structures.Mesh(node)
me = bpy.data.meshes.new(mesh.name)
pos_off = mesh.vertex_format.index('POSITIONS')
me.verts.extend(map(lambda v: v[pos_off], mesh.verts))
if 'NORMALS' in mesh.vertex_format:
off = mesh.vertex_format.index('NORMALS')
for i, vert in enumerate(me.verts):
vert.no = Vector(mesh.verts[i][off])
if 'TEXCOORDS' in mesh.vertex_format:
me.addUVLayer('texcoords')
me.activeUVLayer = 'texcoords'
_import_faces(me, mesh.trimesh_indices, mesh, 3)
_import_faces(me, mesh.quadmesh_indices, mesh, 4)
scn = bpy.data.scenes.active
ob = scn.objects.new(me, mesh.name)
mat = Matrix(mesh.transform[0], mesh.transform[1], mesh.transform[2],
mesh.transform[3]).transpose()
ob.setMatrix(mat)
## TODO make sure this owrks with new format (specifically weights etc)
# weight assignment has to be after object linking
if skelObj and 'WEIGHTS' in mesh.vertex_format and 'SKINMATS' in mesh.vertex_format:
skelData = skelObj.getData()
bones = _get_export_ordered_bones(skelData.bones.values())
for bone in bones:
me.addVertGroup(bone.name)
weight_offset = mesh.vertex_format.index('WEIGHTS')
skin_offset = mesh.vertex_format.index('SKINMATS')
for i, vert in enumerate(me.verts):
weights = mesh.verts[i][weight_offset]
skins = mesh.verts[i][skin_offset]
skinnames = map(lambda idx: bones[idx].name, skins)
for skin, weight in zip(skinnames, weights):
me.assignVertsToGroup(skin, [i], weight,
Blender.Mesh.AssignModes.ADD)
mod = ob.modifiers.append(Blender.Modifier.Types.ARMATURE)
mod[Blender.Modifier.Settings.OBJECT] = skelObj
print mod[Blender.Modifier.Settings.OBJECT]
mod[Blender.Modifier.Settings.OBJECT] = mod[
Blender.Modifier.Settings.OBJECT]
mod[Blender.Modifier.Settings.VGROUPS] = True
ob.makeDisplayList()
Blender.Redraw()
def blender_frame(new_frame=None, redraw=False):
""" Set blender frame if one is given, return current frame,
and optionally redraw 3D windows. """
## print " blender_frame: type(new_frame) = '%s'" % str(type(new_frame))
if new_frame == None:
current = Blender.Get('curframe')
else:
new_frame = int(new_frame) # in case a float is passed
current = new_frame
Blender.Set('curframe', new_frame)
if redraw:
Blender.Redraw()
return current
def doScript():
# Main script Function
# Consists of choosing between 2 loops, one with a redraw, one without, see comments for why
global CUROFFS
translateParams()
total = len(PARAMS['ImagePaths'])
broken = 0
if GUIPARAMS['RedrawImp'].val: # Reduces the need to compare on every go through the loop
for i, path in enumerate(PARAMS['ImagePaths']):
CUROFFS = i # Could be passed to the import Function, but I chose a global instead
Window.DrawProgressBar(float(i)/total, "Importing %i of %i Images..." %(i+1, total))
imgImport(path)
Blender.Redraw()
if Blender.Get('version') >= 246:
if Window.TestBreak():
broken = 1
break
else:
for i, path in enumerate(PARAMS['ImagePaths']):
CUROFFS = i
Window.DrawProgressBar(float(i)/total, "Importing %i of %i Images..." %(i+1, total))
imgImport(path)
if Blender.Get('version') >= 246:
if Window.TestBreak():
broken = 1
break
if broken:
Window.DrawProgressBar(1.0, "Script Execution Aborted")
else:
Window.DrawProgressBar(1.0, "Finished Importing")
Blender.Redraw() # Force a refresh, since the user may have chosen to not refresh as they go along
return