def exportSelMesh(self): print "exporting ..." self.writeHeader() self.writeRootFrame() tex = [] objs = Object.GetSelected() for obj in objs: if obj.type == 'Mesh': mesh = obj.data self.writeTextures(obj, tex) self.writeMeshcoordArm(obj, arm_ob=None) self.writeMeshMaterialList(obj, mesh, tex) self.writeMeshNormals(obj, mesh) self.writeMeshTextureCoords(obj, mesh) self.writeMeshVertexColors(obj, mesh) self.file.write(" }\n") self.file.write("}\n") ind = objs.index(obj) if ind == len(objs) - 1: self.file.write("}\n") ip_list = obj.ipo if ip_list != None: self.file.write("AnimationSet AnimationSet0 {\n") self.writeAnimationObj(obj) self.file.write("}\n") else: print "The selected object is not a mesh" print "...finished"
def load_point_set(filename): """Read a point set and duplicate obj for each location. Insert every created object in sc """ Window.WaitCursor(True) sc = Scene.GetCurrent() ref_obj = sc.getActiveObject() #unselect everything except ref for obj in Object.GetSelected(): obj.sel = 0 ref_obj.sel = 1 #read points pts = load(open(filename, 'rb')) for pid, vec in pts.iteritems(): Object.Duplicate() obj = sc.getActiveObject() obj.setLocation(*vec) #return Window.RedrawAll()
def deform2rvk(): scn = Blender.Scene.GetCurrent() # ================================================================= # at leat 2 objects =============================================== # ================================================================= if len(scn.objects.selected) > 1: RVK1 = Object.GetSelected()[0] RVK2 = Object.GetSelected()[1] if RVK2.getType() == 'Mesh': copy_shapes(RVK1, RVK2) # ================================================================= # ... but if only one...=========================================== # ================================================================= elif len(scn.objects.selected) == 1: name = "At least 2 Meshes must be selected %t| Ok. %x1| Add one ? %x2" result = Draw.PupMenu(name) RVK1 = Object.GetSelected()[0] if result and RVK1.getType() == 'Mesh': Blender.Object.Duplicate(mesh=1) RVK2 = scn.objects.active mod = RVK2.modifiers for m in mod: RVK2.modifiers.remove(m) RVK2.LocX += 2.0 copy_shapes(RVK1, RVK2) scn.objects.selected = [] RVK2.sel = 1 RVK1.sel = 1 # ================================================================ # ... and not a mesh...=========================================== # ================================================================ elif result: name = "Selected object must be a mesh %t| Ok. %x1" result = Draw.PupMenu(name) return else: return # ================================================================ # ... if not object at all. ===================================== # ================================================================ else: name = "At least one Mesh object must be selected %t| Ok. %x1" result = Draw.PupMenu(name) return Blender.Redraw()
def getparents(): global lookup, hierarchy, firstlevel, has_sim, armature, bones, theobject if Window.EditMode(): objects = [Scene.GetCurrent().objects.active] else: objects = Object.GetSelected() for theobject in objects: parent = theobject.parent if not parent or parent.getType() != 'Armature': Draw.PupMenu('Object "%s" is not a child of a bone.' % theobject.name) return None bonename = theobject.getParentBoneName() if not bonename: Draw.PupMenu( 'Object "%s" is the child of an armature. It should be the child of a bone.' % theobject.name) return None thisbones = parent.getData().bones if bonename in thisbones.keys(): bone = thisbones[bonename] else: Draw.PupMenu('Object "%s" has a deleted bone as its parent.' % theobject.name) return None if armature and (parent != armature or bone != bones[0]): Draw.PupMenu( 'You have selected multiple objects with different parents.') return None else: armature = parent bones = [bone] if not bones: return bone = bones[0] while bone.parent: bones.append(bone.parent) bone = bone.parent try: has_sim = False (lookup, hierarchy) = getDatarefs() firstlevel = [] for key in lookup: if lookup[key]: (path, n) = lookup[key] ref = path.split('/') if not ref[0] in firstlevel: firstlevel.append(ref[0]) if len(firstlevel) == 1: firstlevel = hierarchy['sim'].keys() has_sim = True firstlevel.sort(lambda x, y: -cmp(x.lower(), y.lower())) except IOError, e: Draw.PupMenu(str(e)) return None
def CheckSelection(): selob = Object.GetSelected() if not selob: Draw.PupMenu("Warning%t|Please make a selection.") elif ob and selob[0].name == ob.name: Draw.PupMenu("Warning%t|Object already selected.") else: return selob[0] return None
def main(): selected = Object.GetSelected() if len(selected) == 0: print "Nothing selected" return for obj in selected: if obj.getType() != "Mesh": continue file = open("%s.xml" % (obj.getName()), "w") file.write("<? xml version=\"1.0\" ?>\n") export(obj, file) file.close()
def processSelected(): global outputdir if not os.path.isdir(outputdir): outputdir = os.curdir os.chdir(outputdir) objs = Object.GetSelected() if len(objs) == 0: print("Error: No Objects Selected") else: for obj in objs: if obj.getType() != "Mesh": print("Error: Object " + obj.name + " is a " + obj.getType() + ", not a mesh!") else: print("Object is a " + obj.getType()) exportObject(obj) print "Finished: xmesh files written to %s" % os.getcwd()
def DeselectAllObjects(): for object in Object.GetSelected(): object.select(0)
def select_modifier(RVK1, RVK2, DATA2): # ====================================================== # in case of modifiers, use ============================= # ====================================================== if RVK1.modifiers: #MODIFIERS=1 POSSMOD = [Value(t) for t in POSSMOD_list] AUTHMOD = [Value(t) for t in AUTHMOD_list] if DEBUG: print 'POSSMOD:', POSSMOD, '\nAUTHMOD:', AUTHMOD MODRVK1 = RVK1.modifiers block = [] # =================================================== # === Bloc Menu Modifiers ===1 doc ================= # =================================================== m = 0 for mod in MODRVK1: if DEBUG: print mod.type if mod.type in POSSMOD: BMOD[0].append([ Draw.Create(0), mod.type, m, POSSMOD_list[POSSMOD.index(mod.type)], mod[Modifier.Settings.RENDER] == 1, mod[Modifier.Settings.EDITMODE] == 1 ]) elif mod.type in AUTHMOD: BMOD[1].append([ Draw.Create(1), mod.type, m, AUTHMOD_list[AUTHMOD.index(mod.type)], mod[Modifier.Settings.RENDER] == 1, mod[Modifier.Settings.EDITMODE] == 1 ]) m += 1 # =================================================== # === Bloc Menu Modifiers ===2 display ============= # =================================================== block.append(BMOD[1][0]) for B in BMOD[1][1:]: block.append((B[3], B[0], "")) block.append(BMOD[0][0]) block.append("not alredy implemented") block.append("in this script.") for B in BMOD[0][1:]: block.append((B[3], B[0], "")) retval = Blender.Draw.PupBlock("MESH 2 RVK", block) # =================================================== # === unset Modifiers ============================= # =================================================== for B in BMOD[0][1:]: if DEBUG: print B[2] MODRVK1[B[2]][Modifier.Settings.RENDER] = 0 for B in BMOD[1]: if not B[1]: MODRVK1[B[2]][Modifier.Settings.RENDER] = 0 # =================================================== # === update Modifiers ============================= # =================================================== #RVK1.makeDisplayList() # ======================================================= # === get deformed mesh ================================ # ======================================================= RVK1NAME = Object.GetSelected()[0].getName() meshrvk1 = NMesh.GetRawFromObject(RVK1NAME) if DEBUG: print len(meshrvk1.verts) # ======================================================= # === get normal mesh for vertex group ================= # ======================================================= DATA1 = RVK1.getData() # ======================================================= # === get destination mesh ============================ # ======================================================= DATA2 = RVK2.getData() if DEBUG: print len(meshrvk1.verts) if DEBUG: print len(DATA2.verts) # ======================================================== # ===== is there the same number of vertices ============= # ======================================================== if len(meshrvk1.verts) == len(DATA2.verts): name = "Do you want to replace or add vertex groups ? %t| YES %x1| NO ? %x2 " result = Draw.PupMenu(name) if result == 1: # ===================================================== # ===== Do we save vertex groups ? =================== # ===================================================== GROUPNAME2 = DATA2.getVertGroupNames() if len(GROUPNAME2) != 0: for GROUP2 in GROUPNAME2: DATA2.removeVertGroup(GROUP2) GROUPNAME1 = DATA1.getVertGroupNames() if len(GROUPNAME1) != 0: for GROUP1 in GROUPNAME1: DATA2.addVertGroup(GROUP1) DATA2.assignVertsToGroup( GROUP1, DATA1.getVertsFromGroup(GROUP1), 1.0, 'replace') # ======================================================== # ===== now copy the vertices coords ===================== # ======================================================== for v in meshrvk1.verts: i = meshrvk1.verts.index(v) v1 = DATA2.verts[i] for n in [0, 1, 2]: v1.co[n] = v.co[n] DATA2.update() DATA2.insertKey(FRAME, 'relative') DATA2.update() RVK2.makeDisplayList() if RVK1.modifiers: # =================================================== # === unset Modifiers ============================= # =================================================== for B in BMOD[0][1:]: MODRVK1[B[2]][Modifier.Settings.RENDER] |= B[-2] for B in BMOD[1]: if not B[1]: MODRVK1[B[2]][Modifier.Settings.RENDER] |= B[-2] else: name = "Meshes Objects must have the same number of vertices %t|Ok. %x1" result = Draw.PupMenu(name) return
def deform2rvk(): POSSMOD_list=['EDGESPLIT', 'DECIMATE', 'SUBSURF', 'BOOLEAN', 'BUILD', 'MIRROR', 'ARRAY'] AUTHMOD_list=['LATTICE', 'CURVE', 'WAVE', 'ARMATURE'] MODIFIERS=0 BMOD=[['Possible Modifiers'], ['Allowed Modifiers']] # ================================================================= # at leat 2 objects =============================================== # ================================================================= if len(Object.GetSelected())>1 : RVK1=Object.GetSelected()[0] RVK2=Object.GetSelected()[1] # ============================================================= # must be 2 meshes ============================================ # ============================================================= if RVK1.getType()=='Mesh' and RVK2.getType()=='Mesh': FRAME=Blender.Get('curframe') DATA2=RVK2.getData() if DEBUG: print DATA2.getKey() # ============================================================ # at least the second must have a shape key ================== # ============================================================ if DATA2.getKey(): # ====================================================== # in case of modifiers use ============================= # ====================================================== if RVK1.modifiers: MODIFIERS=1 POSSMOD=[Value(t) for t in POSSMOD_list] AUTHMOD=[Value(t) for t in AUTHMOD_list] if DEBUG: print 'POSSMOD:',POSSMOD,'\nAUTHMOD:', AUTHMOD MODRVK1=RVK1.modifiers block = [] # =================================================== # === Bloc Menu Modifiers ===1 doc ================= # =================================================== m=0 for mod in MODRVK1: if DEBUG: print mod.type if mod.type in POSSMOD: BMOD[0].append([Draw.Create(0),mod.type, m, POSSMOD_list[POSSMOD.index(mod.type)], mod[Modifier.Settings.RENDER]==1, mod[Modifier.Settings.EDITMODE]==1 ]) elif mod.type in AUTHMOD: BMOD[1].append([Draw.Create(1), mod.type, m, AUTHMOD_list[AUTHMOD.index(mod.type)], mod[Modifier.Settings.RENDER]==1, mod[Modifier.Settings.EDITMODE]==1 ]) m+=1 # =================================================== # === Bloc Menu Modifiers ===2 display ============= # =================================================== block.append(BMOD[1][0]) for B in BMOD[1][1:]: block.append((B[3],B[0],"")) block.append(BMOD[0][0]) block.append("not alredy implemented") block.append("in this script.") for B in BMOD[0][1:]: block.append((B[3],B[0],"")) retval = Blender.Draw.PupBlock("MESH 2 RVK", block) # =================================================== # === unset Modifiers ============================= # =================================================== for B in BMOD[0][1:]: if DEBUG: print B[2] MODRVK1[B[2]][Modifier.Settings.RENDER]=0 for B in BMOD[1]: if not B[1]: MODRVK1[B[2]][Modifier.Settings.RENDER]=0 # =================================================== # === update Modifiers ============================= # =================================================== #RVK1.makeDisplayList() # ======================================================= # === get deformed mesh ================================ # ======================================================= RVK1NAME=Object.GetSelected()[0].getName() meshrvk1=NMesh.GetRawFromObject(RVK1NAME) if DEBUG: print len(meshrvk1.verts) # ======================================================= # === get normal mesh for vertex group ================= # ======================================================= DATA1=RVK1.getData() # ======================================================= # === get destination mesh ============================ # ======================================================= DATA2=RVK2.getData() if DEBUG: print len(meshrvk1.verts) if DEBUG: print len(DATA2.verts) # ======================================================== # ===== is there the same number of vertices ============= # ======================================================== if len(meshrvk1.verts)==len(DATA2.verts): name = "Do you want to replace or add vertex groups ? %t| YES %x1| NO ? %x2 " result = Draw.PupMenu(name) if result==1: # ===================================================== # ===== Do we save vertex groups ? =================== # ===================================================== GROUPNAME2=DATA2.getVertGroupNames() if len(GROUPNAME2)!=0: for GROUP2 in GROUPNAME2: DATA2.removeVertGroup(GROUP2) GROUPNAME1=DATA1.getVertGroupNames() if len(GROUPNAME1)!=0: for GROUP1 in GROUPNAME1: DATA2.addVertGroup(GROUP1) DATA2.assignVertsToGroup(GROUP1,DATA1.getVertsFromGroup(GROUP1),1.0,'replace') # ======================================================== # ===== now copy the vertices coords ===================== # ======================================================== for v in meshrvk1.verts: i= meshrvk1.verts.index(v) v1=DATA2.verts[i] for n in [0,1,2]: v1.co[n]=v.co[n] DATA2.update() DATA2.insertKey(FRAME,'relative') DATA2.update() RVK2.makeDisplayList() if MODIFIERS: # =================================================== # === unset Modifiers ============================= # =================================================== for B in BMOD[0][1:]: MODRVK1[B[2]][Modifier.Settings.RENDER]|=B[-2] for B in BMOD[1]: if not B[1]: MODRVK1[B[2]][Modifier.Settings.RENDER]|=B[-2] else: name = "Meshes Objects must the same number of vertices %t| Ok. %x1" result = Draw.PupMenu(name) return else: name = "Second Object must have at least a shape key %t| Ok. %x1" result = Draw.PupMenu(name) return else: name = "Object must be Meshes %t| Ok. %x1" result = Draw.PupMenu(name) return else : name = "At least 2 Meshes as to be selected %t| Ok. %x1" result = Draw.PupMenu(name) return Blender.Redraw()
the occupied in the original file, so you may no notice anything till you turn that layers on. It can also be used in a single instance (ie: first open the file with object, copy, open the destination blend, paste) Save the .blend containing the objects you want to copy first, even if it already has a filename, only saved objects can be copied (if you had altered something, then save). """ import Blender from Blender import Draw, Text, Library, Object choice = Draw.PupMenu("Copy object(s) to buffer|Paste object(s) from buffer") if choice == 1: objs = Object.GetSelected() if len(objs) == 0: Draw.PupMenu("Please select at least 1 object!") else: txt = open(Blender.Get("datadir") + "/buffer", "w") txt.write(Blender.Get("filename") + "\n") for item in objs: txt.write(item.getName() + "\n") txt.close() elif choice == 2: txt = Text.Load(Blender.Get("datadir") + "/buffer") buffer = txt.asLines() Library.Open(buffer[0]) buffer.pop(0) for item in buffer: Library.Load(item, "Object", 0)
def renderGUI(): """ Renders the GUI for the script. """ global G # find the selection set and update some selection # related flags haveEmpty = False haveCamera = False emptyName = "" G.selection = Object.GetSelected() G.curempty = None if G.selection is not None and len(G.selection) > 0: mso = G.selection[0] msotype = mso.getType() if msotype == 'Empty': haveEmpty = True G.curempty = mso emptyName = G.curempty.getName() elif msotype == 'Camera': haveCamera = True emptyHasCoords = G.coordmap.has_key(emptyName) removeUnknownsFromCoords() # clear any buttons that need to have set states G.buttons.add = G.buttons.delete = None # clear the window c = COLOR_BACKGROUND BGL.glClearColor(c[0], c[1], c[2], c[3]) BGL.glClear(BGL.GL_COLOR_BUFFER_BIT) # paint the image in the background if G.image is not None: #drawImage(G.image, G.imgpos, G.iw, G.ih, G.zoom) Draw.Image(G.image, G.imgpos[0], G.imgpos[1], G.zoom, G.zoom) # paint 2D vertices in the image BGL.glPushAttrib(BGL.GL_POINT_BIT | BGL.GL_CURRENT_BIT) BGL.glPointSize(POINT_SIZE) x0 = int(G.imgpos[0] / G.zoom) y0 = int(G.imgpos[1] / G.zoom) def drawvc(ec): emptyname, coord = ec if Object.Get(emptyname) in G.selection: c = COLOR_VERTSEL else: c = COLOR_VERTUNSEL BGL.glColor4f(c[0], c[1], c[2], c[3]) BGL.glVertex2f(G.zoom * (coord[0] + x0), G.zoom * (coord[1] + y0)) BGL.glBegin(BGL.GL_POINTS) map(drawvc, G.coordmap.items()) BGL.glEnd() BGL.glPopAttrib() # if we're in add mode then draw some extra stuff if G.mode == MODE_ADD: xm, ym = map(int, getWMCoords()) xm -= 10 ym += 10 (xw, yw, ww, hw) = getWinRect() # draw crosshairs c = COLOR_CROSSHAIRS BGL.glColor4f(c[0], c[1], c[2], c[3]) verts = [(xm, 0), (xm, hw), (0, ym), (ww, ym)] BGL.glBegin(BGL.GL_LINES) map(lambda x: BGL.glVertex2d(x[0], x[1]), verts) BGL.glEnd() ############################################# # UNCOMMENT THIS SECTION FOR A COOL MINIMAP # EFFECT - NOT VERY USEFUL THOUGH # ## draw "minimap" background #c = COLOR_MINIMAP #BGL.glColor4f(c[0], c[1], c[2], c[3]) #verts = [ (119,10), (221,10), (221,111), (119,111) ] #BGL.glBegin(BGL.GL_QUADS) #map(lambda x: BGL.glVertex2i(x[0],x[1]), verts) #BGL.glEnd() # ## paint the image into the minimap #ix,iy = wc2ic((xm,ym)) #ix,iy = map(int, [ix, iy]) #drawImage(G.ibuf, (120,10), G.iw, G.ih, 10.0, (ix-5,iy-5,10,10)) # # END OF MINIMAP SECTION ############################################# # paint the current empty name if haveEmpty: c = COLOR_TEXT BGL.glColor4d(c[0], c[1], c[2], c[3]) BGL.glRasterPos2i(220, 10) Draw.Text(emptyName, 'small') # paint the normal GUI buttons G.buttons.quit = Draw.PushButton('Quit', BUTTON_QUIT, 5, 5, 100, 20, 'Exits the script.') G.buttons.load = Draw.PushButton('Load Image', BUTTON_LOAD, 5, 25, 100, 20, 'Loads an image.') G.buttons.zoom = Draw.Number('Zoom', BUTTON_ZOOM, 5, 45, 100, 20, G.zoom, ZOOM_MIN, ZOOM_MAX, 'Adjusts image zoom.') # paint camera-specific stuff if haveCamera: G.buttons.fullopt = Draw.Toggle('Full Optimization', BUTTON_FULLOPT, 110, 5, 120, 20, G.fullopt, 'Full or partial optimization.') G.buttons.coplanar = Draw.Toggle('Coplanar', BUTTON_COPLANAR, 110, 25, 120, 20, G.coplanar, 'Coplanar or non-coplanar target.') # Origin offset is not currently working in the Tsai module. # It should be brought back here when it is. #G.buttons.ofsz = Draw.Number('OfsZ', BUTTON_OFSZ, 110, 50, 100, 20, G.ofsz, OFS_MIN, OFS_MAX, 'Z origin offset.') #G.buttons.ofsy = Draw.Number('OfsY', BUTTON_OFSY, 110, 70, 100, 20, G.ofsy, OFS_MIN, OFS_MAX, 'Y origin offset.') #G.buttons.ofsx = Draw.Number('OfsX', BUTTON_OFSX, 110, 90, 100, 20, G.ofsx, OFS_MIN, OFS_MAX, 'X origin offset.') G.buttons.calibrate = Draw.PushButton( 'Calibrate', BUTTON_CALIBRATE, 235, 5, 100, 20, 'Calibrates the selected camera.') # paint empty-specific stuff elif haveEmpty and (G.mode == MODE_NORMAL): if emptyHasCoords: G.buttons.delete = Draw.PushButton( 'Delete', BUTTON_DELETE, 110, 5, 100, 20, 'Adds an image calibration coordinate.') else: G.buttons.add = Draw.PushButton( 'Add', BUTTON_ADD, 110, 5, 100, 20, 'Removes an image calibration coordinate.')
def main(): scn = Scene.GetCurrent() act_ob = scn.getActiveObject() if act_ob.getType() != 'Mesh': act_ob = None sel = [ ob for ob in Object.GetSelected() if ob.getType() == 'Mesh' if ob != act_ob ] if not sel and not act_ob: Draw.PupMenu('Error, select a mesh as your active object') return # Defaults PREF_EDITMESH_ONLY = Draw.Create(1) PREF_MIRROR_LOCATION = Draw.Create(1) PREF_XMID_SNAP = Draw.Create(1) PREF_MAX_DIST = Draw.Create(0.02) PREF_XZERO_THRESH = Draw.Create(0.002) #PREF_MODE= Draw.Create(0) # THIS IS TOOO CONFUSING, HAVE 2 BUTTONS AND MAKE THE MODE FROM THEM. PREF_MODE_L2R = Draw.Create(1) PREF_MODE_R2L = Draw.Create(0) PREF_SEL_ONLY = Draw.Create(1) PREF_EDGE_USERS = Draw.Create(0) # Weights PREF_MIRROR_WEIGHTS = Draw.Create(0) PREF_FLIP_NAMES = Draw.Create(1) PREF_CREATE_FLIP_NAMES = Draw.Create(1) pup_block = [\ ('EditMesh Only', PREF_EDITMESH_ONLY, 'If disabled, will mirror all selected meshes.'),\ 'Left (-), Right (+)',\ ('Left > Right', PREF_MODE_L2R, 'Copy from the Left to Right of the mesh. Enable Both for a mid loc/weight.'),\ ('Right > Left', PREF_MODE_R2L, 'Copy from the Right to Left of the mesh. Enable Both for a mid loc/weight.'),\ '',\ ('MaxDist:', PREF_MAX_DIST, 0.0, 1.0, 'Generate interpolated verts so closer vert weights can be copied.'),\ ('XZero limit:', PREF_XZERO_THRESH, 0.0, 1.0, 'Mirror verts above this distance from the middle, else lock to X/zero.'),\ ('Sel Verts Only', PREF_SEL_ONLY, 'Only mirror selected verts. Else try and mirror all'),\ ('Edge Users', PREF_EDGE_USERS, 'Only match up verts that have the same number of edge users.'),\ 'Location Prefs',\ ('Mirror Location', PREF_MIRROR_LOCATION, 'Mirror vertex locations.'),\ ('XMidSnap Verts', PREF_XMID_SNAP, 'Snap middle verts to X Zero (uses XZero limit)'),\ 'Weight Prefs',\ ('Mirror Weights', PREF_MIRROR_WEIGHTS, 'Mirror vertex locations.'),\ ('Flip Groups', PREF_FLIP_NAMES, 'Mirror flip names.'),\ ('New Flip Groups', PREF_CREATE_FLIP_NAMES, 'Make new groups for flipped names.'),\ ] if not Draw.PupBlock("X Mirror mesh tool", pup_block): return # WORK OUT THE MODE 0 # PREF_MODE, 0:middle, 1: Left. 2:Right. PREF_MODE_R2L = PREF_MODE_R2L.val PREF_MODE_L2R = PREF_MODE_L2R.val if PREF_MODE_R2L and PREF_MODE_L2R: PREF_MODE = 0 # Middle elif not PREF_MODE_R2L and PREF_MODE_L2R: PREF_MODE = 1 # Left to Right elif PREF_MODE_R2L and not PREF_MODE_L2R: PREF_MODE = 2 # Right to Left else: # Neither Selected. Do middle anyway PREF_MODE = 0 PREF_EDITMESH_ONLY = PREF_EDITMESH_ONLY.val PREF_MIRROR_LOCATION = PREF_MIRROR_LOCATION.val PREF_XMID_SNAP = PREF_XMID_SNAP.val PREF_MAX_DIST = PREF_MAX_DIST.val PREF_XZERO_THRESH = PREF_XZERO_THRESH.val PREF_SEL_ONLY = PREF_SEL_ONLY.val PREF_EDGE_USERS = PREF_EDGE_USERS.val # weights PREF_MIRROR_WEIGHTS = PREF_MIRROR_WEIGHTS.val PREF_FLIP_NAMES = PREF_FLIP_NAMES.val PREF_CREATE_FLIP_NAMES = PREF_CREATE_FLIP_NAMES.val t = sys.time() is_editmode = Window.EditMode() # Exit Editmode. if is_editmode: Window.EditMode(0) Mesh.Mode(Mesh.SelectModes['VERTEX']) Window.WaitCursor(1) if act_ob: mesh_mirror(act_ob.getData(mesh=1), PREF_MIRROR_LOCATION, PREF_XMID_SNAP, PREF_MAX_DIST, PREF_XZERO_THRESH, PREF_MODE, PREF_SEL_ONLY, PREF_EDGE_USERS, PREF_MIRROR_WEIGHTS, PREF_FLIP_NAMES, PREF_CREATE_FLIP_NAMES) if (not PREF_EDITMESH_ONLY) and sel: for ob in sel: mesh_mirror(ob.getData(mesh=1), PREF_MIRROR_LOCATION, PREF_XMID_SNAP, PREF_MAX_DIST, PREF_XZERO_THRESH, PREF_MODE, PREF_SEL_ONLY, PREF_EDGE_USERS, PREF_MIRROR_WEIGHTS, PREF_FLIP_NAMES, PREF_CREATE_FLIP_NAMES) if is_editmode: Window.EditMode(1) Window.WaitCursor(0) Window.DrawProgressBar(1.0, '') Window.RedrawAll() print 'Mirror done in %.6f sec.' % (sys.time() - t)
def main(): print '\nStarting BoneWeight Copy...' scn = Blender.Scene.GetCurrent() contextSel = Object.GetSelected() if not contextSel: Blender.Draw.PupMenu( 'Error%t|2 or more mesh objects need to be selected.|aborting.') return PREF_QUALITY = Blender.Draw.Create(0) PREF_NO_XCROSS = Blender.Draw.Create(0) PREF_SEL_ONLY = Blender.Draw.Create(0) pup_block = [\ ('Quality:', PREF_QUALITY, 0, 4, 'Generate interpolated verts for a higher quality result.'),\ ('No X Crossing', PREF_NO_XCROSS, 'Do not snap across the zero X axis'),\ '',\ '"Update Selected" copies',\ 'active object weights to',\ 'selected verts on the other',\ 'selected mesh objects.',\ ('Update Selected', PREF_SEL_ONLY, 'Only copy new weights to selected verts on the target mesh. (use active object as source)'),\ ] if not Blender.Draw.PupBlock("Copy Weights for %i Meshs" % len(contextSel), pup_block): return PREF_SEL_ONLY = PREF_SEL_ONLY.val PREF_NO_XCROSS = PREF_NO_XCROSS.val quality = PREF_QUALITY.val act_ob = scn.objects.active if PREF_SEL_ONLY and act_ob == None: Blender.Draw.PupMenu( 'Error%t|When dealing with 2 or more meshes with vgroups|There must be an active object|to be used as a source|aborting.' ) return sel = [] from_data = None for ob in contextSel: if ob.type == 'Mesh': me = ob.getData(mesh=1) groups = me.getVertGroupNames() # If this is the only mesh with a group OR if its one of many, but its active. if groups and ((ob == act_ob and PREF_SEL_ONLY) or (not PREF_SEL_ONLY)): if from_data: Blender.Draw.PupMenu( 'More then 1 mesh has vertex weights, only select 1 mesh with weights. aborting.' ) return else: # This uses worldspace_verts_idx which gets (idx,co) pairs, then zsorts. if quality: for _ob in contextSel: _ob.sel = 0 ob.sel = 1 Object.Duplicate(mesh=1) ob = scn.objects.active me = ob.getData(mesh=1) # groups will be the same print '\tGenerating higher %ix quality weights.' % quality subdivMesh(me, quality) scn.unlink(ob) from_data = (ob, me, worldspace_verts_idx(me, ob), groups) else: data = (ob, me, worldspace_verts(me, ob), groups) sel.append(data) if not from_data: Blender.Draw.PupMenu('Error%t|No mesh with vertex groups found.') return if not sel: Blender.Draw.PupMenu( 'Error%t|Select 2 or more mesh objects, aborting.') if quality: from_data[1].verts = None return t = Blender.sys.time() Window.WaitCursor(1) # Now do the copy. print '\tCopying from "%s" to %i other mesh(es).' % (from_data[0].name, len(sel)) for data in sel: copy_bone_influences(from_data, data, PREF_SEL_ONLY, PREF_NO_XCROSS) # We cant unlink the mesh, but at least remove its data. if quality: from_data[1].verts = None print 'Copy Complete in %.6f sec' % (Blender.sys.time() - t) Window.DrawProgressBar(1.0, '') Window.WaitCursor(0)
def exportMesh(obj, file, loc, size, quat): mesh = NMesh.GetRawFromObject(obj.getName()) indent(file) file.write("<Mesh name=\"%s\" numVertices=\"%d\" numFaces=\"%d\" " % (obj.getName(), len(mesh.verts), len(mesh.faces))) file.write("x=\"%3.5f\" y=\"%3.5f\" z=\"%3.5f\" " % (loc[0], loc[2], -loc[1])) file.write("sx=\"%3.5f\" sy=\"%3.5f\" sz=\"%3.5f\" " % (size[0], size[1], size[2])) file.write("qw=\"%3.5f\" qx=\"%3.5f\" qy=\"%3.5f\" qz=\"%3.5f\"" % (quat[0], quat[1], quat[2], quat[3])) file.write(">\n") setIndent(1) for mat in mesh.materials: exportMaterial(mat, file) if len(mesh.materials) > 0: file.write("\n") textures = [] if mesh.hasFaceUV(): for face in mesh.faces: if not face.image: continue if textures.count(face.image) == 0: textures.append(face.image) for tex in textures: exportTexture(tex, file) if len(textures) > 0: file.write("\n") for vert in mesh.verts: indent(file) file.write("<Vertex x=\"%3.5f\" y=\"%3.5f\" z=\"%3.5f\" " % (vert.co[0], vert.co[2], -vert.co[1])) file.write("nx=\"%3.5f\" ny=\"%3.5f\" nz=\"%3.5f\"/>\n" % (vert.no[0], vert.no[2], -vert.no[1])) file.write("\n") for face in mesh.faces: indent(file) file.write("<Face smooth=\"%d\" " % face.smooth) file.write("nx=\"%3.5f\" ny=\"%3.5f\" nz=\"%3.5f\" " % (face.normal[0], face.normal[2], -face.normal[1])) if face.image: file.write("texture=\"%d\" " % (textures.index(face.image))) else: file.write("texture=\"-1\" ") mat = face.materialIndex if mat >= len(mesh.materials): mat = -1 file.write("material=\"%d\">\n" % (mat)) setIndent(1) for i in range(3): indent(file) file.write("<Vertex index=\"%d\" " % face.v[i].index) if mesh.hasFaceUV() and face.image: file.write("u=\"%1.3f\" v=\"%1.3f\"" % (face.uv[i][0], 1.0 - face.uv[i][1])) file.write("/>\n") setIndent(-1) # file.write(" vertex1=\"%d\" vertex2=\"%d\" vertex3=\"%d\"/>\n" %(face.v[0].index, face.v[1].index, face.v[2].index)) indent(file) file.write("</Face>\n") Object.GetSelected().remove(obj) for child in Object.GetSelected(): if child.parent == obj: export(child, file) Object.GetSelected().remove(child) setIndent(-1) indent(file) file.write("</Mesh>\n\n")
import Blender import math, sys from Blender import NMesh, Object, Scene from math import * PATH = "/home/carlos/" # La ruta donde se salvara el OREj nframes = 50 object = Object.GetSelected() objname = object[0].name meshname = object[0].data.name mesh = NMesh.GetRaw(meshname) filename = PATH + objname + ".orj" file = open(filename, "w") std = sys.stdout # Asociamos stdout al fichero .orj sys.stdout = file print "# Objeto OREj:", objname print "# Vertices Totales:", len(mesh.verts) print "# Caras Totales:", len(mesh.faces) # Escribimos toda la lista de vertices (v x y z) for vertex in mesh.verts: x, y, z = vertex.co print "v %f %f %f" % (x, y, z) # Escribimos toda la lista de caras (f v1 v2 v3 ...) for face in mesh.faces: print "f", face.v.reverse() # Invertimos las normales for vertex in face.v:
def save_opengl(filename): # Open file f = open(filename + ".c", "w") header_file = open(filename + ".h", "w") bone_file = open(filename + ".bone", "w") print "File %s created and opened. Now exporting..." % filename # Write all the preprocessors in the header file required to # make it work w/ vbo_Utilities.h : header_file.write("#ifndef MODEL_H") header_file.write("\n#define MODEL_H") header_file.write("\n\n#include <GL/gl.h>") header_file.write("\n#include <GL/glu.h>") header_file.write("\n\n#include \"Transformation.h\"") header_file.write("\n\n#include \"vbo_Utilities.h\"") header_file.write("\n\n#include \"bone.h\"") header_file.write( "\n\n// The following is the list of objects that will be exported :") # The actual object names and their estern declarations will be written out in the loop below f.write("#include \"%s.h\"\n\n" % filename) # Which object to export # currently all objects (meshes only - see below) objects = [ob for ob in Object.GetSelected() if ob.getType() == 'Mesh'] obj_index = 0 for obj in objects: nmesh = NMesh.GetRawFromObject(obj.name) header_file.write("\n\nextern CVBO_Model %s;" % (nmesh.name)) f.write("\n// Object: %s" % (nmesh.name)) f.write("\nCVBO_Model %s;" % (nmesh.name)) f.write("\n\nvoid make_%s_vbo_arrays () {" % (nmesh.name)) # Get the list of vertices for the object vertices = nmesh.verts[:] # Get the list of faces for the object faces = nmesh.faces[:] # initialize a refCount array for the vertices refCount_for_vertices = [] for idx in range(len(vertices)): refCount_for_vertices.append(0) # Make one pass through all the faces in the object # to identify all the vertices that will have to be split # into 2 or more vertices if they have different texture coordinates # as part of different faces. Example : vertices along uv-unwrapping_seams. # Naturally, this has to be done only if the mesh uses face-UV textures if nmesh.hasFaceUV(): for face in faces: for idx in range(len(face.v)): vertex_idx = face.v[idx].index if refCount_for_vertices[vertex_idx] == 0: refCount_for_vertices[vertex_idx] = 1 vertices[vertex_idx].uvco.x = face.uv[idx][0] vertices[vertex_idx].uvco.y = face.uv[idx][1] elif face.uv[idx][0] != vertices[ vertex_idx].uvco.x or face.uv[idx][1] != vertices[ vertex_idx].uvco.y: # get a new temp vert of type MyVert newVert = MyVert(0.0, 0.0, 0.0) refCount_for_vertices.append(1) # Copy over relevant stuff to newVert newVert.co = Co(vertices[vertex_idx].co.x, vertices[vertex_idx].co.y, vertices[vertex_idx].co.z) newVert.index = vertices[vertex_idx].index newVert.dup_vertex_index = vertices[vertex_idx].index newVert.no = No(vertices[vertex_idx].no.x, vertices[vertex_idx].no.y, vertices[vertex_idx].no.z) newVert.uvco = Uvco(vertices[vertex_idx].uvco.x, vertices[vertex_idx].uvco.y) # Append it to the list vertices.append(newVert) vertex_idx = len( vertices ) - 1 # new vertex_idx, of the newly appended vertex # Now set the diverged uvco and index at the newly appended vertex vertices[vertex_idx].uvco.x = face.uv[idx][0] vertices[vertex_idx].uvco.y = face.uv[idx][1] vertices[vertex_idx].index = vertex_idx # And, set the face's v to point to this newly appended vertex face.v[idx] = vertices[vertex_idx] numVerts = len(vertices) f.write("\n\tint numVertices = %d;\n" % numVerts) # Write out the list of vertices for the object f.write("\n\t// List of vertices for object %s" % (nmesh.name)) f.write("\n\tGLfloat vertices[] = {") for vertex in vertices: f.write("\n\t\t%f,\t%f,\t%f,\t1.0000," % (vertex.co.x, vertex.co.y, vertex.co.z)) f.write("\t\t// index : %d" % (vertex.index)) f.write("\n\t};") f.write( "\n\t%s.bulk_init_vertices (numVertices, (vec4 *)vertices);\n\n" % (nmesh.name)) # Write out the texture coordinates for the object if nmesh.hasFaceUV(): f.write("\n\t// List of texture_coords for object %s" % (nmesh.name)) f.write("\n\tGLfloat textures[] = {") for vertex in vertices: f.write("\n\t\t%f,\t%f," % (vertex.uvco.x, vertex.uvco.y)) f.write("\t\t// index : %d" % (vertex.index)) f.write("\n\t};") f.write( "\n\t%s.bulk_init_textures (numVertices, (vec2 *)textures);\n\n" % (nmesh.name)) # Write out the normals for the object f.write("\n\t// List of normals for object %s" % (nmesh.name)) f.write("\n\tGLfloat normals[] = {") for vertex in vertices: f.write("\n\t\t%f,\t%f,\t%f," % (vertex.no.x, vertex.no.y, vertex.no.z)) f.write("\t\t// index : %d" % (vertex.index)) f.write("\n\t};") f.write( "\n\t%s.bulk_init_normals (numVertices, (vec3 *)normals);\n\n" % (nmesh.name)) numFaces = 0 for face in nmesh.faces: numFaces = numFaces + 1 if len( face.v ) == 4: # , because quads will be exported as 2 triangles (see below) numFaces = numFaces + 1 f.write("\n\tint numFaces = %d;\n" % numFaces) # Write out the indices to form each face of the object f.write("\n\tGLuint indices[] = {") for face in nmesh.faces: f.write("\n\t\t") f.write("%d, " % face.v[0].index) f.write("%d, " % face.v[1].index) f.write("%d, " % face.v[2].index) if len(face.v) == 4: f.write("\n\t\t") f.write("%d, " % face.v[3].index) f.write("%d, " % face.v[0].index) f.write("%d, " % face.v[2].index) f.write("\n\t};") f.write("\n\t%s.bulk_init_indices (numFaces, (GLuint *)indices);\n\n" % (nmesh.name)) #translation locx = 0 locy = 0 locz = 0 if obj.LocX > 0.0001 or obj.LocX < -0.0001: locx = obj.LocX if obj.LocY > 0.0001 or obj.LocY < -0.0001: locy = obj.LocY if obj.LocZ > 0.0001 or obj.LocZ < -0.0001: locz = obj.LocZ f.write("\n\t%s.locX = %f;" % (nmesh.name, locx)) f.write("\n\t%s.locY = %f;" % (nmesh.name, locy)) f.write("\n\t%s.locZ = %f;" % (nmesh.name, locz)) f.write("\n\treturn;") f.write("\n}") # Bone stuff mesh = Mesh.Get(obj.name) obj.link(mesh) f.write("\n\n// Object : %s " % (mesh.name)) numRealVerts = len(mesh.verts) armatures = Armature.Get() # type: dict armature_names = armatures.keys() for armature_name in armature_names: f.write("\n// Armature %s, being used by %d users" % (armature_name, armatures[armature_name].users)) if armatures[ armature_name].users > 0: # being used by at least 1 user (helps discard deleted armatures which are (for some reason) still lying around in Blender) armature = armatures[armature_name] bones = armature.bones # type: dict bone_names = bones.keys() for bone_name in bone_names: # loop over all bones bone = bones[bone_name] f.write("\n\nBone %s;" % bone.name) header_file.write("\nextern Bone %s;" % bone.name) f.write("\n\nvoid init_%s_bone_influences () {" % bone.name) f.write("\n\tInfluence influences[] = {") num_influences = 0 for vertex_idx in range( numVerts ): # loop over all vertices, looking for The bone's influences # bone_file.write("\nindex : %d " % (vertex_idx)) if vertex_idx < numRealVerts: for influence in mesh.getVertexInfluences( vertex_idx): if influence[0] == bone.name: # bone_file.write("\n %s, %f" % (influence[0], influence[1])) f.write("\n\t\tInfluence(%d, %f)," % (vertex_idx, influence[1])) num_influences = num_influences + 1 elif vertex_idx >= numRealVerts: for influence in mesh.getVertexInfluences( vertices[vertex_idx].dup_vertex_index): if influence[0] == bone.name: # bone_file.write("\n %s, %f" % (influence[0], influence[1])) f.write("\n\t\tInfluence(%d, %f)," % (vertex_idx, influence[1])) num_influences = num_influences + 1 f.write("\n\t};") f.write("\n\n\t%s.bulkInitInfluences (%d, influences);" % (bone.name, num_influences)) f.write("\n\t%s.name = \"%s\";" % (bone.name, bone.name)) f.write("\n\n\treturn;") f.write("\n};\n") obj_index += 1 header_file.write("\n\nvoid initialize_all_models ();") header_file.write("\nvoid ready_all_models_for_render ();") f.write("\n\nvoid initialize_all_models () {") for obj in objects: nmesh = NMesh.GetRawFromObject(obj.name) f.write("\n\n\tmake_%s_vbo_arrays ();" % (nmesh.name)) f.write("\n\t%s.setTexture (\"./cube_texture_test.png\", PNG);" % nmesh.name) f.write("\n\t%s.setMatColor (0.2, 0.3, 0.4, 1.0);" % nmesh.name) # Bone stuff : armatures = Armature.Get() # type: dict armature_names = armatures.keys() for armature_name in armature_names: if armatures[ armature_name].users > 0: # being used by at least 1 user (helps discard deleted armatures which are (for some reason) still lying around in Blender) armature = armatures[armature_name] bones = armature.bones # type: dict bone_names = bones.keys() for bone_name in bone_names: # loop over all bones bone = bones[bone_name] f.write("\n\tinit_%s_bone_influences ();" % bone.name) f.write("\n\t%s.setVBO (&%s);" % (bone.name, obj.name)) f.write("\n\t%s.addBone (&%s);" % (obj.name, bone.name)) f.write("\n\n\treturn;\n}\n") f.write("\n\nvoid ready_all_models_for_render () {") for obj in objects: nmesh = NMesh.GetRawFromObject(obj.name) f.write("\n\t%s.make_ready_for_render ();" % nmesh.name) f.write("\n\n\treturn;\n}\n\n") header_file.write("\n\n#endif\n\n") print "Export complete" f.close()
def save_opengl(filename): ## Open file f = open(filename, "w") print "File %s created and opened. Now exporting..." % filename ## Which object to export #currently all objects (meshes only - see below) objects = [ob for ob in Object.GetSelected() if ob.getType() == 'Mesh'] index = 0 for obj in objects: nmesh = NMesh.GetRawFromObject(obj.name) f.write("\n\n//object: %s_%d\n" % (nmesh.name, index)) f.write("function load_%d() {\n" % index) index += 1 #used for materials f.write("\tvar matColors=[];\n") #transformation data #first translate, then rotate, then scale # because they are applied from "back to front" #we also store the current matrix and restore it # after the object is rendered (push, pop) f.write("\tgl.PushMatrix();\n") #translation locx = 0 locy = 0 locz = 0 if obj.LocX > 0.0001 or obj.LocX < -0.0001: locx = obj.LocX if obj.LocY > 0.0001 or obj.LocY < -0.0001: locy = obj.LocY if obj.LocZ > 0.0001 or obj.LocZ < -0.0001: locz = obj.LocZ f.write("\tgl.Translated(%.6f, %.6f, %.6f);\n" % (locx, locy, locz)) #rotation - this seems to be buggy !? if obj.RotX > 0.0001 or obj.RotX < -0.0001: f.write(" gl.Rotated(%.6f,1,0,0);\n" % (-obj.RotX * 180 * 0.31831)) if obj.RotY > 0.0001 or obj.RotY < -0.0001: f.write(" gl.Rotated(%.6f,0,1,0);\n" % (-obj.RotY * 180 * 0.31831)) if obj.RotZ > 0.0001 or obj.RotZ < -0.0001: f.write(" gl.Rotated(%.6f,0,0,1);\n" % (-obj.RotZ * 180 * 0.31831)) #scaling f.write("\tgl.Scaled(%.6f, %.6f, %.6f);\n" % tuple(obj.size)) tricount = 0 lastMaterialIndex = -1 for face in nmesh.faces: vn = 0 tricount = tricount + 1 #material - can be changed between glBegin and glEnd if nmesh.materials: if face.materialIndex != lastMaterialIndex: lastMaterialIndex = face.materialIndex material = nmesh.materials[face.materialIndex] print "exporting face material" #ambient and diffuse f.write("\tmatColors[0] = %.6f;\n" % material.R) f.write("\tmatColors[1] = %.6f;\n" % material.G) f.write("\tmatColors[2] = %.6f;\n" % material.B) f.write("\tmatColors[3] = %.6f;\n" % material.alpha) f.write( "\tgl.Materialfv(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE,matColors);\n" ) #specular specs = material.getSpecCol() f.write("\tmatColors[0] = %.6f;\n" % specs[0]) f.write("\tmatColors[1] = %.6f;\n" % specs[1]) f.write("\tmatColors[2] = %.6f;\n" % specs[2]) f.write("\tmatColors[3] = %.6f;\n" % material.getSpecTransp()) f.write( "\tgl.Materialfv(GL_FRONT_AND_BACK,GL_SPECULAR,matColors);\n" ) print "Exporting %s triangle(s)" % tricount if len(face) == 3: f.write("\tgl.Begin(GL_TRIANGLES);\n") elif len(face) == 4: f.write("\tgl.Begin(GL_QUADS);\n") for vertex in face.v: ## Build glVertex3f f.write("\tgl.Normal3f(%.6f, %.6f, %.6f);\n" % tuple(vertex.no)) f.write("\tgl.Vertex3f(%.6f, %.6f, %.6f);\n" % tuple(vertex.co)) vn += 1 #print "glEnd();" f.write("\tgl.End();\n") f.write("\tgl.PopMatrix();\n") f.write("}\n") f.write("\n\n") #print "void loadModel() {" f.write("function loadModel() {\n") index = 0 for obj in objects: f.write("\tload_%d();" % index) f.write("\t//object: %s\n" % obj.getData()) index += 1 f.write("}\n") print "Export complete" f.close()