def main(): scn = Scene.GetCurrent() ob = scn.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me = ob.getData(mesh=1) act_group = me.activeGroup PREF_NAME = Draw.Create(act_group + '_copy') PREF_SEL_ONLY = Draw.Create(0) pup_block= [\ ('', PREF_NAME, 0, 31, 'Name of group copy.'),\ ('Only Selected', PREF_SEL_ONLY, 'Only include selected faces in the new grop.'),\ ] if not Draw.PupBlock('New Name...', pup_block): return PREF_NAME = PREF_NAME.val PREF_SEL_ONLY = PREF_SEL_ONLY.val copy_act_vgroup(me, PREF_NAME, PREF_SEL_ONLY) try: me.activeGroup = PREF_NAME except: pass
def main(): scn = Scene.GetCurrent() if not scn.objects.context: return PREF_LOC = Draw.Create(0.0) PREF_SIZE = Draw.Create(0.0) PREF_ROT = Draw.Create(0.0) PREF_LINK_AXIS = Draw.Create(0) PREF_X_AXIS = Draw.Create(1) PREF_Y_AXIS = Draw.Create(1) PREF_Z_AXIS = Draw.Create(1) pup_block = [\ ('loc:', PREF_LOC, 0.0, 100.0, 'Amount to randomize the location'),\ ('size:', PREF_SIZE, 0.0, 100.0, 'Amount to randomize the size'),\ ('rot:', PREF_ROT, 0.0, 360.0, 'Amount to randomize the rotation'),\ '',\ ('Link Axis', PREF_LINK_AXIS, 'Use the same random value for each objects XYZ'),\ ('X Axis', PREF_X_AXIS, 'Enable X axis randomization'),\ ('Y Axis', PREF_Y_AXIS, 'Enable Y axis randomization'),\ ('Z Axis', PREF_Z_AXIS, 'Enable Z axis randomization'),\ ] if not Draw.PupBlock('Object Randomize', pup_block): return randomize(scn.objects.context, PREF_LOC.val, PREF_SIZE.val, PREF_ROT.val, PREF_LINK_AXIS.val, PREF_X_AXIS.val, PREF_Y_AXIS.val, PREF_Z_AXIS.val)
def x3d_export_ui(filename): if not filename.endswith(extension): filename += extension #if _safeOverwrite and sys.exists(filename): # result = Draw.PupMenu("File Already Exists, Overwrite?%t|Yes%x1|No%x0") #if(result != 1): # return # Get user options EXPORT_APPLY_MODIFIERS = Draw.Create(1) EXPORT_TRI = Draw.Create(0) EXPORT_GZIP = Draw.Create(filename.lower().endswith('.x3dz')) # Get USER Options pup_block = [\ ('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data from each object.'),\ ('Triangulate', EXPORT_TRI, 'Triangulate quads.'),\ ('Compress', EXPORT_GZIP, 'GZip the resulting file, requires a full python install'),\ ] if not Draw.PupBlock('Export...', pup_block): return Blender.Window.EditMode(0) Blender.Window.WaitCursor(1) x3d_export(filename,\ EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val,\ EXPORT_TRI = EXPORT_TRI.val,\ EXPORT_GZIP = EXPORT_GZIP.val\ ) Blender.Window.WaitCursor(0)
def read_ui(filename): global guiTable, IMPORT_VC, IMPORT_UV guiTable = {'VC': 1, 'UV': 1} for s in Window.GetScreenInfo(): Window.QHandle(s['id']) IMPORT_VC = Draw.Create(guiTable['VC']) IMPORT_UV = Draw.Create(guiTable['UV']) # Get USER Options pup_block = [ ('Import Options'), ('Vertex Color', IMPORT_VC, 'Import Vertex Colors if exist'), ('UV', IMPORT_UV, 'Import UV if exist'), ] if not Draw.PupBlock('Import...', pup_block): return Window.WaitCursor(1) guiTable['VC'] = IMPORT_VC.val guiTable['UV'] = IMPORT_UV.val read_main(filename) Window.WaitCursor(0)
def main(): scn= Scene.GetCurrent() ob= scn.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me= ob.getData(mesh=1) PREF_MAXDIST= Draw.Create(0.0) PREF_STRENGTH= Draw.Create(1.0) PREF_MODE= Draw.Create(0) PREF_ITERATIONS= Draw.Create(1) pup_block= [\ ('Bleed Dist:', PREF_MAXDIST, 0.0, 1.0, 'Set a distance limit for bleeding.'),\ ('Bleed Strength:', PREF_STRENGTH, 0.01, 1.0, 'Bleed strength between adjacent verts weight. 1:full, 0:None'),\ ('Iterations', PREF_ITERATIONS, 1, 20, 'Number of times to run the blending calculation.'),\ ('Contract (Shrink)', PREF_MODE, 'Shrink instead of growing.'),\ ] if not Draw.PupBlock('Grow/Shrink...', pup_block): return actWeightNormalize(me, PREF_MODE.val, PREF_MAXDIST.val, PREF_STRENGTH.val, PREF_ITERATIONS.val)
def main(): scn = Scene.GetCurrent() ob = scn.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me = ob.getData(mesh=1) PREF_PEAKWEIGHT = Draw.Create(1.0) PREF_ACTIVE_ONLY = Draw.Create(1) PREF_KEEP_PROPORTION = Draw.Create(1) PREF_ARMATURE_ONLY = Draw.Create(0) pup_block= [\ ('Peak Weight:', PREF_PEAKWEIGHT, 0.01, 1.0, 'Upper weight for normalizing.'),\ ('Active Only', PREF_ACTIVE_ONLY, 'Only Normalize groups that have matching bones in an armature (when an armature is used).'),\ ('Proportional', PREF_KEEP_PROPORTION, 'Scale other weights so verts (Keep weights with other groups in proportion).'),\ ('Armature Only', PREF_ARMATURE_ONLY, 'Only Normalize groups that have matching bones in an armature (when an armature is used).'),\ ] if not Draw.PupBlock('Clean Selected Meshes...', pup_block): return actWeightNormalize(me, ob, PREF_PEAKWEIGHT.val, PREF_ACTIVE_ONLY.val, PREF_ARMATURE_ONLY.val, PREF_KEEP_PROPORTION.val)
def write_ui(filename): global guiTable, EXPORT_MOD, EXPORT_MTL, EXPORT_UV, EXPORT_VC, EXPORT_SELO, EXPORT_UVI, EXPORT_VG2SG guiTable = { 'MOD': 1, 'MTL': 1, 'UV': 1, 'VC': 1, 'SELO': 1, 'UVI': 0, 'VG2SG': 1, 'RECENTER': 0 } EXPORT_MOD = Draw.Create(guiTable['MOD']) EXPORT_MTL = Draw.Create(guiTable['MTL']) EXPORT_UV = Draw.Create(guiTable['UV']) EXPORT_VC = Draw.Create(guiTable['VC']) EXPORT_SELO = Draw.Create(guiTable['SELO']) EXPORT_VG2SG = Draw.Create(guiTable['VG2SG']) EXPORT_REC = Draw.Create(guiTable['RECENTER']) # Get USER Options pup_block = [ ('Mesh Options...'), ('Apply Modifiers', EXPORT_MOD, 'Use modified mesh data from each object.'), ('Materials', EXPORT_MTL, 'Export Materials.'), ('Face UV', EXPORT_UV, 'Export texface UV coords.'), ('Vertex Colors', EXPORT_VC, 'Export vertex colors'), ('Context...'), ('Selection Only', EXPORT_SELO, 'Only export objects in visible selection, else export all mesh object.' ), ('Bonus...'), ('VertGr. as SmoothGr.', EXPORT_VG2SG, 'Make SmoothGroups by VertGroups. See doc.'), ('Center Objects', EXPORT_REC, 'Center ALL objects to World-Grid-Origin-Center-Point-(0,0,0). ;)') ] if not Draw.PupBlock('Export...', pup_block): return Window.WaitCursor(1) guiTable['MOD'] = EXPORT_MOD.val guiTable['MTL'] = EXPORT_MTL.val guiTable['UV'] = EXPORT_UV.val guiTable['VC'] = EXPORT_VC.val guiTable['SELO'] = EXPORT_SELO.val guiTable['VG2SG'] = EXPORT_VG2SG.val guiTable['RECENTER'] = EXPORT_REC.val if not filename.lower().endswith('.ase'): filename += '.ase' write(filename) Window.WaitCursor(0)
def main(): scn = bpy.data.scenes.active ob_sel = list(scn.objects.context) PREF_KEEP_ASPECT = False # Error Checking if len(ob_sel) < 2: Draw.PupMenu("Error%t|Select 2 mesh objects") return me_ob = scn.objects.active if not me_ob: Draw.PupMenu("Error%t|No active mesh selected.") try: ob_sel.remove(me_ob) except: pass if me_ob.type != 'Mesh': Draw.PupMenu( "Error%t|Active Object must be a mesh to write billboard images too" ) return me_data = me_ob.getData(mesh=1) for f in me_data.faces: if len(f) != 4: Draw.PupMenu("Error%t|Active mesh must have only quads") return # Get user input block = [\ 'Image Pixel Size',\ ("Packed Size: ", PREF_RES, 128, 2048, "Pixel width and height to render the billboard to"),\ ("Tile Size: ", PREF_TILE_RES, 64, 1024, "Pixel width and height for each tile to render to"),\ 'Render Settings',\ ("Pack Final", PREF_IMG_PACK , "Pack the image for each face into images into a single image"),\ ("Oversampling", PREF_AA , "Higher quality woth extra sampling"),\ ("Alpha Clipping", PREF_ALPHA , "Render empty areas as transparent"),\ ("Cam ZOffset: ", PREF_Z_OFFSET, 0.1, 100, "Distance to place the camera away from the quad when rendering")\ ] if not Draw.PupBlock("Billboard Render", block): return # Set globals GLOBALS['ob_sel'] = ob_sel GLOBALS['me_ob'] = me_ob GLOBALS['me_data'] = me_data Blender.Window.FileSelector(save_billboard, 'SAVE BILLBOARD', Blender.sys.makename(ext='.png'))
def show_popup(): pup_block = [ ('Selection Only', export_selection_only, 'Only export objects in visible selection. Else export whole scene.'), ('Rotate +Z to +Y', export_rotate_z_to_y, 'Rotate such that +Z axis (Blender up) becomes +Y (VRML up).'), ('Compress', export_compressed, 'Generate a .wrz file (normal VRML compressed by gzip).') ] return Draw.PupBlock('Export VRML 97...', pup_block)
def button_event(evt): # Вызывает функции для формирования таблицы и ввода global allPoints if evt == 1: # 1 – идентификатор кнопки вызова x = Draw.Create(0) y = Draw.Create(0) # Создание кнопок с начальными данными block = [] # Данные для формирования таблицы block.append( ("X= ", x, 0, 400)) #Ввод с ограничением границ и типа данных block.append(("Y= ", y, 0, 600)) retVal = Draw.PupBlock("Line coords", block) # Создание таблицы allPoints.append(x.val) allPoints.append(y.val) # Извлечение данных print "data", allPoints Draw.Redraw(1) return
def button_event(evt): global x2, y2, r1 if evt == 1: x = Draw.Create(x2) y = Draw.Create(y2) r = Draw.Create(r1) block = [] block.append(("X= ", x, 0, 400)) block.append(("Y= ", y, 0, 600)) block.append(("R= ", r, 0, 600)) retVal = Draw.PupBlock("Line coords and radius", block) x2 = x.val y2 = y.val r1 = r.val Draw.Redraw(1) return
def main(): sce= bpy.data.scenes.active ob= sce.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me= ob.getData(mesh=1) PREF_BLUR_ITERATIONS= Draw.Create(1) PREF_BLUR_RADIUS= Draw.Create(0.05) PREF_MIN_EDLEN= Draw.Create(0.01) PREF_CLAMP_CONCAVE= Draw.Create(90) PREF_CLAMP_CONVEX= Draw.Create(20) PREF_SHADOW_ONLY= Draw.Create(0) PREF_SEL_ONLY= Draw.Create(0) pup_block= [\ 'Post AO Blur',\ (' Iterations:', PREF_BLUR_ITERATIONS, 0, 40, 'Number times to blur the colors. (higher blurs more)'),\ (' Blur Radius:', PREF_BLUR_RADIUS, 0.01, 40.0, 'How much distance effects blur transfur (higher blurs more).'),\ (' Min EdgeLen:', PREF_MIN_EDLEN, 0.00001, 1.0, 'Minimim edge length to blur (very low values can cause errors).'),\ 'Angle Clipping',\ (' Highlight Angle:', PREF_CLAMP_CONVEX, 0, 180, 'Less then 180 limits the angle used in the tonal range.'),\ (' Shadow Angle:', PREF_CLAMP_CONCAVE, 0, 180, 'Less then 180 limits the angle used in the tonal range.'),\ ('Shadow Only', PREF_SHADOW_ONLY, 'Dont calculate highlights for convex areas.'),\ ('Sel Faces Only', PREF_SEL_ONLY, 'Only apply to UV/Face selected faces (mix vpain/uvface select).'),\ ] if not Draw.PupBlock('SelfShadow...', pup_block): return PREF_BLUR_ITERATIONS= PREF_BLUR_ITERATIONS.val PREF_BLUR_RADIUS= PREF_BLUR_RADIUS.val PREF_MIN_EDLEN= PREF_MIN_EDLEN.val PREF_CLAMP_CONCAVE= PREF_CLAMP_CONCAVE.val PREF_CLAMP_CONVEX= PREF_CLAMP_CONVEX.val PREF_SHADOW_ONLY= PREF_SHADOW_ONLY.val PREF_SEL_ONLY= PREF_SEL_ONLY.val if not me.vertexColors: me.vertexColors= 1 t= sys.time() vertexFakeAO(me, PREF_BLUR_ITERATIONS, PREF_BLUR_RADIUS, PREF_MIN_EDLEN, PREF_CLAMP_CONCAVE, PREF_CLAMP_CONVEX, PREF_SHADOW_ONLY, PREF_SEL_ONLY) print 'done in %.6f' % (sys.time()-t)
def button_event(evt): if evt == 1: global yes global xy0 global xy1 global point0 global point1 global mddl global a global b X0 = Draw.Create(0) Y0 = Draw.Create(0) X1 = Draw.Create(0) Y1 = Draw.Create(0) A = Draw.Create(0) B = Draw.Create(0) block = [] block.append(("X1= ", X0, 0, 1000)) block.append(("Y1= ", Y0, 0, 1000)) block.append(("X2= ", X1, 0, 1000)) block.append(("Y2= ", Y1, 0, 1000)) block.append(("A= ", A, -1000, 1000)) block.append(("B= ", B, -1000, 1000)) retVal = Draw.PupBlock("LINE'S POINTS", block) xy0[0] = X0.val xy0[1] = Y0.val xy1[0] = X1.val xy1[1] = Y1.val a = A.val b = B.val #LINE point0[0] = 1 point0[1] = a * point0[0] + b point1[1] = 1000 point1[0] = (point1[1] - b) / a yes = 1 return
def main(): sce = bpy.data.scenes.active ob = sce.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me = ob.getData(mesh=1) PREF_BLUR_ITERATIONS = Draw.Create(1) PREF_BLUR_STRENGTH = Draw.Create(0.5) PREF_CLAMP_CONCAVE = Draw.Create(90) PREF_CLAMP_CONVEX = Draw.Create(20) PREF_SHADOW_ONLY = Draw.Create(0) PREF_SEL_ONLY = Draw.Create(0) pup_block= [\ 'Post AO Blur',\ ('Strength:', PREF_BLUR_STRENGTH, 0, 1, 'Blur strength per iteration'),\ ('Iterations:', PREF_BLUR_ITERATIONS, 0, 40, 'Number times to blur the colors. (higher blurs more)'),\ 'Angle Clipping',\ ('Highlight Angle:', PREF_CLAMP_CONVEX, 0, 180, 'Less then 180 limits the angle used in the tonal range.'),\ ('Shadow Angle:', PREF_CLAMP_CONCAVE, 0, 180, 'Less then 180 limits the angle used in the tonal range.'),\ ('Shadow Only', PREF_SHADOW_ONLY, 'Dont calculate highlights for convex areas.'),\ ('Sel Faces Only', PREF_SEL_ONLY, 'Only apply to UV/Face selected faces (mix vpain/uvface select).'),\ ] if not Draw.PupBlock('SelfShadow...', pup_block): return if not me.vertexColors: me.vertexColors = 1 t = sys.time() vertexFakeAO(me, PREF_BLUR_ITERATIONS.val, \ PREF_BLUR_STRENGTH.val, \ PREF_CLAMP_CONCAVE.val, \ PREF_CLAMP_CONVEX.val, \ PREF_SHADOW_ONLY.val, \ PREF_SEL_ONLY.val) if ob.modifiers: me.update() print 'done in %.6f' % (sys.time() - t)
def main(): THICK = Draw.Create(0.02) if not Draw.PupBlock('Cube wireframe', [\ ('Thick:', THICK, 0.0001, 10, 'Thickness of the skinned edges'),\ ]): return # Gets the current scene, there can be many scenes in 1 blend file. sce = bpy.data.scenes.active # Get the active object, there can only ever be 1 # and the active object is always the editmode object. ob_act = sce.objects.active if not ob_act or ob_act.type != 'Mesh': BPyMessages.Error_NoMeshActive() return # Saves the editmode state and go's out of # editmode if its enabled, we cant make # changes to the mesh data while in editmode. is_editmode = Window.EditMode() if is_editmode: Window.EditMode(0) Window.WaitCursor(1) me = ob_act.getData(mesh=1) # old NMesh api is default t = sys.time() # Run the mesh editing function create_wired_mesh(me, THICK.val/2.0) ob_act.select(False) # Restore editmode if it was enabled if is_editmode: Window.EditMode(1) # Timing the script is a good way to be aware on any speed hits when scripting print 'My Script finished in %.2f seconds' % (sys.time()-t) Window.WaitCursor(0)
def main(): scn = Scene.GetCurrent() ob = scn.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me = ob.getData(mesh=1) PREF_TOLERENCE = Draw.Create(0.1) pup_block= [\ ('Tolerence:', PREF_TOLERENCE, 0.01, 1.0, 'Tolerence for selecting faces of the same weight.'),\ ] if not Draw.PupBlock('Select Same Weight...', pup_block): return PREF_TOLERENCE = PREF_TOLERENCE.val selSameWeights(me, PREF_TOLERENCE)
def main(): scn = Scene.GetCurrent() ob = scn.objects.active if not ob or ob.type != 'Mesh': Draw.PupMenu('Error, no active mesh object, aborting.') return me = ob.getData(mesh=1) PREF_PEAKWEIGHT = Draw.Create(0.001) PREF_KEEP_SINGLE = Draw.Create(1) PREF_OTHER_GROUPS = Draw.Create(0) pup_block= [\ ('Peak Weight:', PREF_PEAKWEIGHT, 0.005, 1.0, 'Remove verts from groups below this weight.'),\ ('All Other Groups', PREF_OTHER_GROUPS, 'Clean all groups, not just the current one.'),\ ('Keep Single User', PREF_KEEP_SINGLE, 'Keep verts in at least 1 group.'),\ ] if not Draw.PupBlock('Clean Selected Meshes...', pup_block): return rem_count = weightClean(me, PREF_PEAKWEIGHT.val, PREF_KEEP_SINGLE.val, PREF_OTHER_GROUPS.val) # Run on entire blend file. usefull sometimes but dont let users do it. ''' rem_count = 0 for ob in Object.Get(): if ob.type != 'Mesh': continue me= ob.getData(mesh=1) rem_count += weightClean(me, PREF_PEAKWEIGHT.val, PREF_KEEP_SINGLE.val, PREF_OTHER_GROUPS.val) ''' Draw.PupMenu('Removed %i verts from groups' % rem_count)
def write_ui(filename): if filename.lower().endswith('.svg'): filename = filename[:-4] PREF_SEP= Draw.Create(0) PREF_SCALE= Draw.Create(90) PREF_SPACE= Draw.Create(2.0) block = [\ ("Separate Files", PREF_SEP, "Export each view axis as a seperate file"),\ ("Space: ", PREF_SPACE, 0.0, 10.0, "Space between views in blender units"),\ ("Scale: ", PREF_SCALE, 10, 100000, "Scale, 1200 is a good default")] if not Draw.PupBlock("Export SVG", block): return edges = [] bounds = collect_edges(edges) if PREF_SEP.val: writexy(edges, bounds, filename + '_XY.svg', PREF_SCALE.val, PREF_SPACE.val) writexz(edges, bounds, filename + '_XZ.svg', PREF_SCALE.val, PREF_SPACE.val) writeyz(edges, bounds, filename + '_YZ.svg', PREF_SCALE.val, PREF_SPACE.val) writeall(edges, bounds, filename + '.svg', PREF_SCALE.val, PREF_SPACE.val)
h.delRegion(image) h.panelimage().makeCurrent() elif r == 2: maxx = 2**int(log(image.size[0], 2)) maxy = 2**int(log(image.size[1], 2)) xoff = Draw.Create(0) yoff = Draw.Create(0) width = Draw.Create(min(maxx, 1024)) height = Draw.Create(min(maxy, 1024)) block = [] block.append(('Left:', xoff, 0, image.size[0])) block.append(('Bottom:', yoff, 0, image.size[1])) block.append(('Width:', width, 0, maxx)) block.append(('Height:', height, 0, maxy)) while Draw.PupBlock('Create new region', block): if not width.val or not height.val or 2**int( log(width.val, 2)) != width.val or 2**int( log(height.val, 2)) != height.val: if isinstance(block[-1], tuple): block.extend(['', '']) block[-2] = 'Width & Height must' block[-1] = 'be powers of 2' elif xoff.val + width.val > image.size[0]: if isinstance(block[-1], tuple): block.extend(['', '']) block[-2] = 'Left + Width must' block[-1] = 'be less than %d' % image.size[0] elif yoff.val + height.val > image.size[1]: if isinstance(block[-1], tuple): block.extend(['', '']) block[-2] = 'Bottom + Height must' block[-1] = 'be less than %d' % image.size[1] else:
def edit_extern(image=None): if not image: image = Image.GetCurrent() if not image: # Image is None Draw.PupMenu('ERROR: You must select an active Image.') return if image.packed: Draw.PupMenu('ERROR: Image is packed, unpack before editing.') return imageFileName = sys.expandpath(image.filename) if not sys.exists(imageFileName): Draw.PupMenu('ERROR: Image path does not exist.') return pupblock = [imageFileName.split('/')[-1].split('\\')[-1]] new_text = False try: appstring = Registry.GetKey('ExternalImageEditor', True) appstring = appstring['path'] # for ZanQdo if he removed the path from the textbox totaly. ;) - Cam if not appstring or appstring.find('%f') == -1: new_text = True except: new_text = True if new_text: pupblock.append('first time, set path.') if platform == 'win32': appstring = 'start "" /B "%f"' elif platform == 'darwin': appstring = 'open "%f"' else: appstring = 'gimp-remote "%f"' appstring_but = Draw.Create(appstring) save_default_but = Draw.Create(0) pupblock.append( ('editor: ', appstring_but, 0, 48, 'Path to application, %f will be replaced with the image path.')) pupblock.append(('Set Default', save_default_but, 'Store this path in the blender registry.')) # Only configure if Shift is held, if Blender.Window.GetKeyQualifiers() & Blender.Window.Qual.SHIFT: if not Draw.PupBlock('External Image Editor...', pupblock): return appstring = appstring_but.val save_default = save_default_but.val if save_default: Registry.SetKey('ExternalImageEditor', {'path': appstring}, True) if appstring.find('%f') == -1: Draw.PupMenu( 'ERROR: The comment you entered did not contain the filename ("%f")' ) return # ------------------------------- appstring = appstring.replace('%f', imageFileName) print '\tediting image with command "%s"' % appstring os.system(appstring)
def main(): sce = Scene.GetCurrent() ob_act = sce.objects.active if not ob_act: Draw.PupMenu("Error%t|no active object") return objects = list(sce.objects.context) try: objects.remove(ob_act) except: pass if not objects: Draw.PupMenu("Error%t|no objects selected") return curframe = Blender.Get('curframe') FRAME_START = Draw.Create(Blender.Get('staframe')) FRAME_END = Draw.Create(Blender.Get('endframe')) # Get USER Options pup_block= [\ ('Start:', FRAME_START, 1, 300000, 'Use the active objects position starting at this frame'),\ ('End:', FRAME_END, 1, 300000, 'Use the active objects position starting at this frame'),\ ] if not Draw.PupBlock('Set timeoffset...', pup_block): return FRAME_START = FRAME_START.val FRAME_END = FRAME_END.val if FRAME_START >= FRAME_END: Draw.PupMenu("Error%t|frames are not valid") # Ok - all error checking locls_act = [] for f in xrange((FRAME_END - FRAME_START)): i = FRAME_START + f Blender.Set('curframe', i) locls_act.append(ob_act.matrixWorld.translationPart()) for ob in objects: loc = ob.matrixWorld.translationPart() best_frame = -1 best_dist = 100000000 for i, loc_act in enumerate(locls_act): dist = (loc_act - loc).length if dist < best_dist: best_dist = dist best_frame = i + FRAME_START ob.timeOffset = float(best_frame) # Set the original frame Blender.Set('curframe', curframe)
cam = Camera.New('persp', 'TCam') camob = scn.objects.new(cam) scn.objects.camera = camob camob.setLocation(Window.GetCursorPos()) if camob: target = scn.objects.new('Empty', (camob.name + '.target')) matrix = camob.getMatrix() tvect = Mathutils.Vector([0,0,-10]) targetv = tvect*matrix target.setLocation(targetv) cam = camob.data #cam.drawLimits = 1 cam.drawSize = 2.0 campos = Mathutils.Vector([camob.dloc[0],camob.dloc[1],camob.dloc[2]]) dofdistv = campos-targetv dofdist = dofdistv.length #cam.dofDist = dofdist cam.clipEnd = 1500 const = camob.constraints.append(Constraint.Type.TRACKTO) const[Constraint.Settings.TARGET] = target const[Constraint.Settings.TRACK] = Constraint.Settings.TRACKNEGZ const[Constraint.Settings.UP] = Constraint.Settings.UPY scn.update() else: block = [] block.append("") msg = Draw.PupBlock("No Camera in Scene !!", block)
def main(): global USER_FILL_HOLES global USER_FILL_HOLES_QUALITY global USER_STRETCH_ASPECT global USER_ISLAND_MARGIN objects = bpy.data.scenes.active.objects # we can will tag them later. obList = [ob for ob in objects.context if ob.type == 'Mesh'] # Face select object may not be selected. ob = objects.active if ob and ob.sel == 0 and ob.type == 'Mesh': # Add to the list obList = [ob] del objects if not obList: Draw.PupMenu('error, no selected mesh objects') return # Create the variables. USER_PROJECTION_LIMIT = Draw.Create(66) USER_ONLY_SELECTED_FACES = Draw.Create(1) USER_SHARE_SPACE = Draw.Create(1) # Only for hole filling. USER_STRETCH_ASPECT = Draw.Create(1) # Only for hole filling. USER_ISLAND_MARGIN = Draw.Create(0.0) # Only for hole filling. USER_FILL_HOLES = Draw.Create(0) USER_FILL_HOLES_QUALITY = Draw.Create(50) # Only for hole filling. USER_VIEW_INIT = Draw.Create(0) # Only for hole filling. USER_AREA_WEIGHT = Draw.Create(1) # Only for hole filling. pup_block = [\ 'Projection',\ ('Angle Limit:', USER_PROJECTION_LIMIT, 1, 89, 'lower for more projection groups, higher for less distortion.'),\ ('Selected Faces Only', USER_ONLY_SELECTED_FACES, 'Use only selected faces from all selected meshes.'),\ ('Init from view', USER_VIEW_INIT, 'The first projection will be from the view vector.'),\ ('Area Weight', USER_AREA_WEIGHT, 'Weight projections vector by face area.'),\ '',\ '',\ '',\ 'UV Layout',\ ('Share Tex Space', USER_SHARE_SPACE, 'Objects Share texture space, map all objects into 1 uvmap.'),\ ('Stretch to bounds', USER_STRETCH_ASPECT, 'Stretch the final output to texture bounds.'),\ ('Island Margin:', USER_ISLAND_MARGIN, 0.0, 0.5, 'Margin to reduce bleed from adjacent islands.'),\ 'Fill in empty areas',\ ('Fill Holes', USER_FILL_HOLES, 'Fill in empty areas reduced texture waistage (slow).'),\ ('Fill Quality:', USER_FILL_HOLES_QUALITY, 1, 100, 'Depends on fill holes, how tightly to fill UV holes, (higher is slower)'),\ ] # Reuse variable if len(obList) == 1: ob = "Unwrap %i Selected Mesh" else: ob = "Unwrap %i Selected Meshes" # HACK, loop until mouse is lifted. ''' while Window.GetMouseButtons() != 0: sys.sleep(10) ''' if not Draw.PupBlock(ob % len(obList), pup_block): return del ob # Convert from being button types USER_PROJECTION_LIMIT = USER_PROJECTION_LIMIT.val USER_ONLY_SELECTED_FACES = USER_ONLY_SELECTED_FACES.val USER_SHARE_SPACE = USER_SHARE_SPACE.val USER_STRETCH_ASPECT = USER_STRETCH_ASPECT.val USER_ISLAND_MARGIN = USER_ISLAND_MARGIN.val USER_FILL_HOLES = USER_FILL_HOLES.val USER_FILL_HOLES_QUALITY = USER_FILL_HOLES_QUALITY.val USER_VIEW_INIT = USER_VIEW_INIT.val USER_AREA_WEIGHT = USER_AREA_WEIGHT.val USER_PROJECTION_LIMIT_CONVERTED = cos(USER_PROJECTION_LIMIT * DEG_TO_RAD) USER_PROJECTION_LIMIT_HALF_CONVERTED = cos( (USER_PROJECTION_LIMIT / 2) * DEG_TO_RAD) # Toggle Edit mode is_editmode = Window.EditMode() if is_editmode: Window.EditMode(0) # Assume face select mode! an annoying hack to toggle face select mode because Mesh dosent like faceSelectMode. if USER_SHARE_SPACE: # Sort by data name so we get consistant results try: obList.sort(key=lambda ob: ob.getData(name_only=1)) except: obList.sort(lambda ob1, ob2: cmp(ob1.getData(name_only=1), ob2.getData(name_only=1))) collected_islandList = [] Window.WaitCursor(1) time1 = sys.time() # Tag as False se we dont operate on teh same mesh twice. bpy.data.meshes.tag = False for ob in obList: me = ob.getData(mesh=1) if me.tag or me.lib: continue # Tag as used me.tag = True if not me.faceUV: # Mesh has no UV Coords, dont bother. me.faceUV = True if USER_ONLY_SELECTED_FACES: meshFaces = [thickface(f) for f in me.faces if f.sel] else: meshFaces = map(thickface, me.faces) if not meshFaces: continue Window.DrawProgressBar( 0.1, 'SmartProj UV Unwrapper, mapping "%s", %i faces.' % (me.name, len(meshFaces))) # ======= # Generate a projection list from face normals, this is ment to be smart :) # make a list of face props that are in sync with meshFaces # Make a Face List that is sorted by area. # meshFaces = [] # meshFaces.sort( lambda a, b: cmp(b.area , a.area) ) # Biggest first. try: meshFaces.sort(key=lambda a: -a.area) except: meshFaces.sort(lambda a, b: cmp(b.area, a.area)) # remove all zero area faces while meshFaces and meshFaces[-1].area <= SMALL_NUM: # Set their UV's to 0,0 for uv in meshFaces[-1].uv: uv.zero() meshFaces.pop() # Smallest first is slightly more efficient, but if the user cancels early then its better we work on the larger data. # Generate Projection Vecs # 0d is 1.0 # 180 IS -0.59846 # Initialize projectVecs if USER_VIEW_INIT: # Generate Projection projectVecs = [ Vector(Window.GetViewVector()) * ob.matrixWorld.copy().invert().rotationPart() ] # We add to this allong the way else: projectVecs = [] newProjectVec = meshFaces[0].no newProjectMeshFaces = [] # Popping stuffs it up. # Predent that the most unique angke is ages away to start the loop off mostUniqueAngle = -1.0 # This is popped tempMeshFaces = meshFaces[:] # This while only gathers projection vecs, faces are assigned later on. while 1: # If theres none there then start with the largest face # add all the faces that are close. for fIdx in xrange(len(tempMeshFaces) - 1, -1, -1): # Use half the angle limit so we dont overweight faces towards this # normal and hog all the faces. if newProjectVec.dot(tempMeshFaces[fIdx].no ) > USER_PROJECTION_LIMIT_HALF_CONVERTED: newProjectMeshFaces.append(tempMeshFaces.pop(fIdx)) # Add the average of all these faces normals as a projectionVec averageVec = Vector(0, 0, 0) if USER_AREA_WEIGHT: for fprop in newProjectMeshFaces: averageVec += (fprop.no * fprop.area) else: for fprop in newProjectMeshFaces: averageVec += fprop.no if averageVec.x != 0 or averageVec.y != 0 or averageVec.z != 0: # Avoid NAN projectVecs.append(averageVec.normalize()) # Get the next vec! # Pick the face thats most different to all existing angles :) mostUniqueAngle = 1.0 # 1.0 is 0d. no difference. mostUniqueIndex = 0 # dummy for fIdx in xrange(len(tempMeshFaces) - 1, -1, -1): angleDifference = -1.0 # 180d difference. # Get the closest vec angle we are to. for p in projectVecs: temp_angle_diff = p.dot(tempMeshFaces[fIdx].no) if angleDifference < temp_angle_diff: angleDifference = temp_angle_diff if angleDifference < mostUniqueAngle: # We have a new most different angle mostUniqueIndex = fIdx mostUniqueAngle = angleDifference if mostUniqueAngle < USER_PROJECTION_LIMIT_CONVERTED: #print 'adding', mostUniqueAngle, USER_PROJECTION_LIMIT, len(newProjectMeshFaces) # Now weight the vector to all its faces, will give a more direct projection # if the face its self was not representive of the normal from surrounding faces. newProjectVec = tempMeshFaces[mostUniqueIndex].no newProjectMeshFaces = [tempMeshFaces.pop(mostUniqueIndex)] else: if len(projectVecs) >= 1: # Must have at least 2 projections break # If there are only zero area faces then its possible # there are no projectionVecs if not len(projectVecs): Draw.PupMenu( 'error, no projection vecs where generated, 0 area faces can cause this.' ) return faceProjectionGroupList = [[] for i in xrange(len(projectVecs))] # MAP and Arrange # We know there are 3 or 4 faces here for fIdx in xrange(len(meshFaces) - 1, -1, -1): fvec = meshFaces[fIdx].no i = len(projectVecs) # Initialize first bestAng = fvec.dot(projectVecs[0]) bestAngIdx = 0 # Cycle through the remaining, first alredy done while i - 1: i -= 1 newAng = fvec.dot(projectVecs[i]) if newAng > bestAng: # Reverse logic for dotvecs bestAng = newAng bestAngIdx = i # Store the area for later use. faceProjectionGroupList[bestAngIdx].append(meshFaces[fIdx]) # Cull faceProjectionGroupList, # Now faceProjectionGroupList is full of faces that face match the project Vecs list for i in xrange(len(projectVecs)): # Account for projectVecs having no faces. if not faceProjectionGroupList[i]: continue # Make a projection matrix from a unit length vector. MatProj = VectoMat(projectVecs[i]) # Get the faces UV's from the projected vertex. for f in faceProjectionGroupList[i]: f_uv = f.uv for j, v in enumerate(f.v): f_uv[j][:] = (MatProj * v.co)[:2] if USER_SHARE_SPACE: # Should we collect and pack later? islandList = getUvIslands(faceProjectionGroupList, me) collected_islandList.extend(islandList) else: # Should we pack the islands for this 1 object? islandList = getUvIslands(faceProjectionGroupList, me) packIslands(islandList) # update the mesh here if we need to. # We want to pack all in 1 go, so pack now if USER_SHARE_SPACE: Window.DrawProgressBar(0.9, "Box Packing for all objects...") packIslands(collected_islandList) print "Smart Projection time: %.2f" % (sys.time() - time1) # Window.DrawProgressBar(0.9, "Smart Projections done, time: %.2f sec." % (sys.time() - time1)) if is_editmode: Window.EditMode(1) Window.DrawProgressBar(1.0, "") Window.WaitCursor(0) Window.RedrawAll()
def main(): scn = Scene.GetCurrent() act_ob = scn.objects.active if not act_ob or act_ob.type != 'Mesh': BPyMessages.Error_NoMeshActive() return act_me = act_ob.getData(mesh=1) if act_me.multires: BPyMessages.Error_NoMeshMultiresEdit() return act_group = act_me.activeGroup if not act_group: act_group = '' # Defaults PREF_REDUX = Draw.Create(0.5) PREF_BOUNDRY_WEIGHT = Draw.Create(5.0) PREF_REM_DOUBLES = Draw.Create(1) PREF_FACE_AREA_WEIGHT = Draw.Create(1.0) PREF_FACE_TRIANGULATE = Draw.Create(1) VGROUP_INF_ENABLE = Draw.Create(0) VGROUP_INF_REDUX = Draw.Create(act_group) VGROUP_INF_WEIGHT = Draw.Create(10.0) PREF_DO_UV = Draw.Create(1) PREF_DO_VCOL = Draw.Create(1) PREF_DO_WEIGHTS = Draw.Create(1) PREF_OTHER_SEL_OBS = Draw.Create(0) pup_block = [\ ('Poly Reduce:', PREF_REDUX, 0.05, 0.95, 'Scale the meshes poly count by this value.'),\ ('Boundry Weight:', PREF_BOUNDRY_WEIGHT, 0.0, 20.0, 'Weight boundry verts by this scale, 0.0 for no boundry weighting.'),\ ('Area Weight:', PREF_FACE_AREA_WEIGHT, 0.0, 20.0, 'Collapse edges effecting lower area faces first.'),\ ('Triangulate', PREF_FACE_TRIANGULATE, 'Convert quads to tris before reduction, for more choices of edges to collapse.'),\ '',\ ('VGroup Weighting', VGROUP_INF_ENABLE, 'Use a vertex group to influence the reduction, higher weights for higher quality '),\ ('vgroup name: ', VGROUP_INF_REDUX, 0, 32, 'The name of the vertex group to use for the weight map'),\ ('vgroup mult: ', VGROUP_INF_WEIGHT, 0.0, 100.0, 'How much to make the weight effect the reduction'),\ ('Other Selected Obs', PREF_OTHER_SEL_OBS, 'reduce other selected objects.'),\ '',\ '',\ '',\ ('UV Coords', PREF_DO_UV, 'Interpolate UV Coords.'),\ ('Vert Colors', PREF_DO_VCOL, 'Interpolate Vertex Colors'),\ ('Vert Weights', PREF_DO_WEIGHTS, 'Interpolate Vertex Weights'),\ ('Remove Doubles', PREF_REM_DOUBLES, 'Remove doubles before reducing to avoid boundry tearing.'),\ ] if not Draw.PupBlock("Poly Reducer", pup_block): return PREF_REDUX = PREF_REDUX.val PREF_BOUNDRY_WEIGHT = PREF_BOUNDRY_WEIGHT.val PREF_REM_DOUBLES = PREF_REM_DOUBLES.val PREF_FACE_AREA_WEIGHT = PREF_FACE_AREA_WEIGHT.val PREF_FACE_TRIANGULATE = PREF_FACE_TRIANGULATE.val VGROUP_INF_ENABLE = VGROUP_INF_ENABLE.val VGROUP_INF_WEIGHT = VGROUP_INF_WEIGHT.val if VGROUP_INF_ENABLE and VGROUP_INF_WEIGHT: VGROUP_INF_REDUX = VGROUP_INF_REDUX.val else: VGROUP_INF_WEIGHT = 0.0 VGROUP_INF_REDUX = None PREF_DO_UV = PREF_DO_UV.val PREF_DO_VCOL = PREF_DO_VCOL.val PREF_DO_WEIGHTS = PREF_DO_WEIGHTS.val PREF_OTHER_SEL_OBS = PREF_OTHER_SEL_OBS.val t = sys.time() is_editmode = Window.EditMode() # Exit Editmode. if is_editmode: Window.EditMode(0) Window.WaitCursor(1) print 'reducing:', act_ob.name, act_ob.getData(1) BPyMesh.redux(act_ob, PREF_REDUX, PREF_BOUNDRY_WEIGHT, PREF_REM_DOUBLES, PREF_FACE_AREA_WEIGHT, PREF_FACE_TRIANGULATE, PREF_DO_UV, PREF_DO_VCOL, PREF_DO_WEIGHTS, VGROUP_INF_REDUX, VGROUP_INF_WEIGHT) if PREF_OTHER_SEL_OBS: for ob in scn.objects.context: if ob.type == 'Mesh' and ob != act_ob: print 'reducing:', ob.name, ob.getData(1) BPyMesh.redux(ob, PREF_REDUX, PREF_BOUNDRY_WEIGHT, PREF_REM_DOUBLES, PREF_FACE_AREA_WEIGHT, PREF_FACE_TRIANGULATE, PREF_DO_UV, PREF_DO_VCOL, PREF_DO_WEIGHTS, VGROUP_INF_REDUX, VGROUP_INF_WEIGHT) Window.RedrawAll() if is_editmode: Window.EditMode(1) Window.WaitCursor(0) Window.RedrawAll() print 'Reduction done in %.6f sec.' % (sys.time() - t)
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 file_callback(filename): if not filename.lower().endswith('.submesh'): filename += '.submesh' scn = bpy.data.scenes.active ob = scn.objects.active if not ob: Blender.Draw.PupMenu('Error%t|Select 1 active object') return file = open(filename, 'wb') EXPORT_APPLY_MODIFIERS = Draw.Create(1) EXPORT_NORMALS = Draw.Create(1) EXPORT_UV = Draw.Create(1) EXPORT_COLORS = Draw.Create(1) #EXPORT_EDGES = Draw.Create(0) pup_block = [\ ('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data.'),\ ('Normals', EXPORT_NORMALS, 'Export vertex normal data.'),\ ('UVs', EXPORT_UV, 'Export texface UV coords.'),\ ('Colors', EXPORT_COLORS, 'Export vertex Colors.'),\ #('Edges', EXPORT_EDGES, 'Edges not connected to faces.'),\ ] if not Draw.PupBlock('Export...', pup_block): return is_editmode = Blender.Window.EditMode() if is_editmode: Blender.Window.EditMode(0, '', 0) Window.WaitCursor(1) EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val EXPORT_NORMALS = EXPORT_NORMALS.val EXPORT_UV = EXPORT_UV.val EXPORT_COLORS = EXPORT_COLORS.val #EXPORT_EDGES = EXPORT_EDGES.val mesh = BPyMesh.getMeshFromObject(ob, None, EXPORT_APPLY_MODIFIERS, False, scn) if not mesh: Blender.Draw.PupMenu( 'Error%t|Could not get mesh data from active object') return mesh.transform(ob.matrixWorld) faceUV = mesh.faceUV vertexUV = mesh.vertexUV vertexColors = mesh.vertexColors if (not faceUV) and (not vertexUV): EXPORT_UV = False if not vertexColors: EXPORT_COLORS = False if not EXPORT_UV: faceUV = vertexUV = False if not EXPORT_COLORS: vertexColors = False # incase color = uvcoord = uvcoord_key = normal = normal_key = None verts = [] # list of dictionaries # vdict = {} # (index, normal, uv) -> new index vdict = [{} for i in xrange(len(mesh.verts))] vert_count = 0 for i, f in enumerate(mesh.faces): smooth = f.smooth if not smooth: normal = tuple(f.no) normal_key = rvec3d(normal) if faceUV: uv = f.uv if vertexColors: col = f.col for j, v in enumerate(f): if smooth: normal = tuple(v.no) normal_key = rvec3d(normal) if faceUV: uvcoord = uv[j][0], 1.0 - uv[j][1] uvcoord_key = rvec2d(uvcoord) elif vertexUV: uvcoord = v.uvco[0], 1.0 - v.uvco[1] uvcoord_key = rvec2d(uvcoord) if vertexColors: color = col[j].r, col[j].g, col[j].b key = normal_key, uvcoord_key, color vdict_local = vdict[v.index] if (not vdict_local) or (not vdict_local.has_key(key)): vdict_local[key] = vert_count verts.append((tuple(v.co), normal, uvcoord, color)) vert_count += 1 file.write('SUBMESHTEXT0001\n') file.write( '#Created by Blender3D %s - www.blender.org, source file: %s\n' % (Blender.Get('version'), Blender.Get('filename').split('/')[-1].split('\\')[-1])) #file.write('element vertex %d\n' % len(verts)) file.write('vertex format: position:3,texture0:2,normal:3\n') file.write('vertex count: %d\n' % len(verts)) for i, v in enumerate(verts): file.write('[%.6f,%.6f,%.6f]' % v[0]) # co #if EXPORT_UV: file.write(' [%.6f,%.6f]' % v[2]) # uv #if EXPORT_NORMALS: file.write(' [%.6f,%.6f,%.6f]' % v[1]) # no #if EXPORT_COLORS: # file.write('%u %u %u' % v[3]) # col file.write('\n') triangles = [] for (i, f) in enumerate(mesh.faces): #file.write('%d ' % len(f)) smooth = f.smooth if not smooth: no = rvec3d(f.no) if faceUV: uv = f.uv if vertexColors: col = f.col if (len(f) == 3): triangle = [] for j, v in enumerate(f): if f.smooth: normal = rvec3d(v.no) else: normal = no if faceUV: uvcoord = rvec2d((uv[j][0], 1.0 - uv[j][1])) elif vertexUV: uvcoord = rvec2d((v.uvco[0], 1.0 - v.uvco[1])) if vertexColors: color = col[j].r, col[j].g, col[j].b triangle += [vdict[v.index][normal, uvcoord, color]] triangles += [triangle] #file.write('%d ' % vdict[v.index][normal, uvcoord, color]) #file.write('\n') else: x = [] for j, v in enumerate(f): if f.smooth: normal = rvec3d(v.no) else: normal = no if faceUV: uvcoord = rvec2d((uv[j][0], 1.0 - uv[j][1])) elif vertexUV: uvcoord = rvec2d((v.uvco[0], 1.0 - v.uvco[1])) if vertexColors: color = col[j].r, col[j].g, col[j].b #file.write('%d ' % vdict[v.index][normal, uvcoord, color]) x += [vdict[v.index][normal, uvcoord, color]] triangles += [[x[1], x[2], x[0]]] triangles += [[x[2], x[3], x[0]]] #file.write('[%d,%d,%d]\n'%()) #file.write('[%d,%d,%d]\n'%(x[1],x[2],x[3])) file.write('triangle count: %d\n' % len(triangles)) for (i, f) in enumerate(triangles): file.write('[%d,' % f[0]) file.write('%d,' % f[1]) file.write('%d]\n' % f[2]) file.close() if is_editmode: Blender.Window.EditMode(1, '', 0)
def dxf_export_ui(filepath): global ONLYSELECTED,\ POLYLINES,\ ONLYFACES,\ POLYFACES,\ FLATTEN,\ HIDDEN_MODE,\ SCALE_FACTOR print '\n\nDXF-Export %s -----------------------' %__version__ #filepath = 'blend_test.dxf' # Dont overwrite if not BPyMessages.Warning_SaveOver(filepath): print 'Aborted by user: nothing exported' return #test():return PREF_ONLYSELECTED= Draw.Create(ONLYSELECTED) PREF_POLYLINES= Draw.Create(POLYLINES) PREF_ONLYFACES= Draw.Create(ONLYFACES) PREF_POLYFACES= Draw.Create(POLYFACES) PREF_FLATTEN= Draw.Create(FLATTEN) PREF_HIDDEN_MODE= Draw.Create(HIDDEN_MODE) PREF_SCALE_FACTOR= Draw.Create(SCALE_FACTOR) PREF_HELP= Draw.Create(0) block = [\ ("only selected", PREF_ONLYSELECTED, "export only selected geometry"),\ ("global Scale:", PREF_SCALE_FACTOR, 0.001, 1000, "set global Scale factor for exporting geometry"),\ ("only faces", PREF_ONLYFACES, "from mesh-objects export only faces, otherwise only edges"),\ ("write POLYFACE", PREF_POLYFACES, "export mesh to POLYFACE, otherwise to 3DFACEs"),\ ("write POLYLINEs", PREF_POLYLINES, "export curve to POLYLINE, otherwise to LINEs"),\ ("3D-View to Flat", PREF_FLATTEN, "flatten geometry according current 3d-View"),\ ("Hidden Mode", PREF_HIDDEN_MODE, "filter out hidden lines"),\ #(''),\ ("online Help", PREF_HELP, "calls DXF-Exporter Manual Page on Wiki.Blender.org"),\ ] if not Draw.PupBlock("DXF-Exporter %s" %__version__[:10], block): return if PREF_HELP.val!=0: try: import webbrowser webbrowser.open('http://wiki.blender.org/index.php?title=Scripts/Manual/Export/autodesk_dxf') except: Draw.PupMenu('DXF Exporter: %t|no connection to manual-page on Blender-Wiki! try:|\ http://wiki.blender.org/index.php?title=Scripts/Manual/Export/autodesk_dxf') return ONLYSELECTED = PREF_ONLYSELECTED.val POLYLINES = PREF_POLYLINES.val ONLYFACES = PREF_ONLYFACES.val POLYFACES = PREF_POLYFACES.val FLATTEN = PREF_FLATTEN.val HIDDEN_MODE = PREF_HIDDEN_MODE.val SCALE_FACTOR = PREF_SCALE_FACTOR.val sce = Scene.GetCurrent() if ONLYSELECTED: sel_group = sce.objects.selected else: sel_group = sce.objects if sel_group: do_export(sel_group, filepath) else: print "Abort: selection was empty, no object to export!" Draw.PupMenu('DXF Exporter: nothing exported!|empty selection!')
def write_ui(filename): if not filename.lower().endswith('.obj'): filename += '.obj' if not BPyMessages.Warning_SaveOver(filename): return EXPORT_APPLY_MODIFIERS = Draw.Create(1) EXPORT_ROTX90 = Draw.Create(1) EXPORT_TRI = Draw.Create(1) EXPORT_EDGES = Draw.Create(1) EXPORT_NORMALS = Draw.Create(1) EXPORT_NORMALS_HQ = Draw.Create(1) EXPORT_UV = Draw.Create(1) EXPORT_MTL = Draw.Create(1) EXPORT_SEL_ONLY = Draw.Create(1) EXPORT_ALL_SCENES = Draw.Create(0) EXPORT_ANIMATION = Draw.Create(0) EXPORT_COPY_IMAGES = Draw.Create(0) EXPORT_BLEN_OBS = Draw.Create(1) EXPORT_GROUP_BY_OB = Draw.Create(1) EXPORT_GROUP_BY_MAT = Draw.Create(0) EXPORT_MORPH_TARGET = Draw.Create(0) EXPORT_VERTEX_GROUPS = Draw.Create(1) EXPORT_ARMATURE = Draw.Create(1) # removed too many options are bad! # Get USER Options pup_block = [\ ('Context...'),\ ('Selection Only', EXPORT_SEL_ONLY, 'Only export objects in visible selection. Else export whole scene.'),\ ('All Scenes', EXPORT_ALL_SCENES, 'Each scene as a separate OBJ file.'),\ ('Animation', EXPORT_ANIMATION, 'Each frame as a numbered OBJ file.'),\ ('Object Prefs...'),\ ('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data from each object. May break vert order for morph targets.'),\ ('Rotate X90', EXPORT_ROTX90 , 'Rotate on export so Blenders UP is translated into OBJs UP'),\ ('Morph Target', EXPORT_MORPH_TARGET, 'Keep vert and face order, disables some other options.'),\ ('Extra Data...'),\ ('Edges', EXPORT_EDGES, 'Edges not connected to faces.'),\ ('Normals', EXPORT_NORMALS, 'Export vertex normal data (Ignored on import).'),\ ('High Quality Normals', EXPORT_NORMALS_HQ, 'Calculate high quality normals for rendering.'),\ ('UVs', EXPORT_UV, 'Export texface UV coords.'),\ ('Materials', EXPORT_MTL, 'Write a separate MTL file with the OBJ.'),\ ('Copy Images', EXPORT_COPY_IMAGES, 'Copy image files to the export directory, never overwrite.'),\ ('Triangulate', EXPORT_TRI, 'Triangulate quads.'),\ ('Grouping...'),\ ('Objects', EXPORT_BLEN_OBS, 'Export blender objects as "OBJ objects".'),\ ('Object Groups', EXPORT_GROUP_BY_OB, 'Export blender objects as "OBJ Groups".'),\ ('Material Groups', EXPORT_GROUP_BY_MAT, 'Group by materials.'),\ ('Vertex Groups', EXPORT_VERTEX_GROUPS, 'Add influences & Weights.'),\ ('Armature', EXPORT_ARMATURE, 'Export Armature'),\ ] if not Draw.PupBlock('Export...', pup_block): return if EXPORT_MORPH_TARGET.val: EXPORT_BLEN_OBS.val = False EXPORT_GROUP_BY_OB.val = False EXPORT_GROUP_BY_MAT.val = False EXPORT_GROUP_BY_MAT.val = False EXPORT_APPLY_MODIFIERS.val = False Window.EditMode(0) Window.WaitCursor(1) EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val EXPORT_ROTX90 = EXPORT_ROTX90.val EXPORT_TRI = EXPORT_TRI.val EXPORT_EDGES = EXPORT_EDGES.val EXPORT_NORMALS = EXPORT_NORMALS.val EXPORT_NORMALS_HQ = EXPORT_NORMALS_HQ.val EXPORT_UV = EXPORT_UV.val EXPORT_MTL = EXPORT_MTL.val EXPORT_SEL_ONLY = EXPORT_SEL_ONLY.val EXPORT_ALL_SCENES = EXPORT_ALL_SCENES.val EXPORT_ANIMATION = EXPORT_ANIMATION.val EXPORT_COPY_IMAGES = EXPORT_COPY_IMAGES.val EXPORT_BLEN_OBS = EXPORT_BLEN_OBS.val EXPORT_GROUP_BY_OB = EXPORT_GROUP_BY_OB.val EXPORT_GROUP_BY_MAT = EXPORT_GROUP_BY_MAT.val EXPORT_MORPH_TARGET = EXPORT_MORPH_TARGET.val EXPORT_VERTEX_GROUPS = EXPORT_VERTEX_GROUPS.val EXPORT_ARMATURE = EXPORT_ARMATURE.val base_name, ext = splitExt(filename) context_name = [base_name, '', '', ext] # basename, scene_name, framenumber, extension # Use the options to export the data using write() # def write(filename, objects, EXPORT_EDGES=False, EXPORT_NORMALS=False, EXPORT_MTL=True, EXPORT_COPY_IMAGES=False, EXPORT_APPLY_MODIFIERS=True): orig_scene = Scene.GetCurrent() if EXPORT_ALL_SCENES: export_scenes = Scene.Get() else: export_scenes = [orig_scene] # Export all scenes. for scn in export_scenes: scn.makeCurrent() # If alredy current, this is not slow. context = scn.getRenderingContext() orig_frame = Blender.Get('curframe') if EXPORT_ALL_SCENES: # Add scene name into the context_name context_name[1] = '_%s' % BPySys.cleanName(scn.name) # WARNING, its possible that this could cause a collision. we could fix if were feeling parranoied. # Export an animation? if EXPORT_ANIMATION: scene_frames = xrange(context.startFrame(), context.endFrame()+1) # up to and including the end frame. else: scene_frames = [orig_frame] # Dont export an animation. # Loop through all frames in the scene and export. for frame in scene_frames: if EXPORT_ANIMATION: # Add frame to the filename. context_name[2] = '_%.6d' % frame Blender.Set('curframe', frame) if EXPORT_SEL_ONLY: export_objects = scn.objects.context else: export_objects = scn.objects full_path= ''.join(context_name) # erm... bit of a problem here, this can overwrite files when exporting frames. not too bad. # EXPORT THE FILE. write(full_path, export_objects,\ EXPORT_TRI, EXPORT_EDGES, EXPORT_NORMALS,\ EXPORT_NORMALS_HQ, EXPORT_UV, EXPORT_MTL,\ EXPORT_COPY_IMAGES, EXPORT_APPLY_MODIFIERS,\ EXPORT_ROTX90, EXPORT_BLEN_OBS,\ EXPORT_GROUP_BY_OB, EXPORT_GROUP_BY_MAT, EXPORT_MORPH_TARGET, EXPORT_ARMATURE) Blender.Set('curframe', orig_frame) # Restore old active scene. orig_scene.makeCurrent() Window.WaitCursor(0)
def file_callback(filename): if not filename.lower().endswith('.ctm'): filename += '.ctm' # Get object mesh from the selected object scn = bpy.data.scenes.active ob = scn.objects.active if not ob: Blender.Draw.PupMenu('Error%t|Select 1 active object') return mesh = BPyMesh.getMeshFromObject(ob, None, False, False, scn) if not mesh: Blender.Draw.PupMenu( 'Error%t|Could not get mesh data from active object') return # Check which mesh properties are present... hasVertexUV = mesh.vertexUV or mesh.faceUV hasVertexColors = mesh.vertexColors # Show a GUI for the export settings pupBlock = [] EXPORT_APPLY_MODIFIERS = Draw.Create(1) pupBlock.append(('Apply Modifiers', EXPORT_APPLY_MODIFIERS, 'Use transformed mesh data.')) EXPORT_NORMALS = Draw.Create(1) pupBlock.append(('Normals', EXPORT_NORMALS, 'Export vertex normal data.')) if hasVertexUV: EXPORT_UV = Draw.Create(1) pupBlock.append(('UVs', EXPORT_UV, 'Export texface UV coords.')) if hasVertexColors: EXPORT_COLORS = Draw.Create(1) pupBlock.append(('Colors', EXPORT_COLORS, 'Export vertex Colors.')) EXPORT_MG2 = Draw.Create(0) pupBlock.append( ('Fixed Point', EXPORT_MG2, 'Use limited precision algorithm (MG2 method = better compression).')) if not Draw.PupBlock('Export...', pupBlock): return # Adjust export settings according to GUI selections EXPORT_APPLY_MODIFIERS = EXPORT_APPLY_MODIFIERS.val EXPORT_NORMALS = EXPORT_NORMALS.val if hasVertexUV: EXPORT_UV = EXPORT_UV.val else: EXPORT_UV = False if hasVertexColors: EXPORT_COLORS = EXPORT_COLORS.val else: EXPORT_COLORS = False EXPORT_MG2 = EXPORT_MG2.val # If the user wants to export MG2, then show another GUI... if EXPORT_MG2: pupBlock = [] EXPORT_VPREC = Draw.Create(0.01) pupBlock.append(('Vertex', EXPORT_VPREC, 0.0001, 1.0, 'Relative vertex precision (fixed point).')) if EXPORT_NORMALS: EXPORT_NPREC = Draw.Create(1.0 / 256.0) pupBlock.append(('Normal', EXPORT_NPREC, 0.0001, 1.0, 'Normal precision (fixed point).')) if EXPORT_UV: EXPORT_UVPREC = Draw.Create(1.0 / 1024.0) pupBlock.append(('UV', EXPORT_UVPREC, 0.0001, 1.0, 'UV precision (fixed point).')) if EXPORT_COLORS: EXPORT_CPREC = Draw.Create(1.0 / 256.0) pupBlock.append(('Color', EXPORT_CPREC, 0.0001, 1.0, 'Color precision (fixed point).')) if not Draw.PupBlock('Fixed point precision...', pupBlock): return # Adjust export settings according to GUI selections if EXPORT_MG2: EXPORT_VPREC = EXPORT_VPREC.val else: EXPORT_VPREC = 0.1 if EXPORT_MG2 and EXPORT_NORMALS: EXPORT_NPREC = EXPORT_NPREC.val else: EXPORT_NPREC = 0.1 if EXPORT_MG2 and EXPORT_UV: EXPORT_UVPREC = EXPORT_UVPREC.val else: EXPORT_UVPREC = 0.1 if EXPORT_MG2 and EXPORT_COLORS: EXPORT_CPREC = EXPORT_CPREC.val else: EXPORT_CPREC = 0.1 is_editmode = Blender.Window.EditMode() if is_editmode: Blender.Window.EditMode(0, '', 0) Window.WaitCursor(1) try: # Get the mesh, again, if we wanted modifiers (from GUI selection) if EXPORT_APPLY_MODIFIERS: mesh = BPyMesh.getMeshFromObject(ob, None, EXPORT_APPLY_MODIFIERS, False, scn) if not mesh: Blender.Draw.PupMenu( 'Error%t|Could not get mesh data from active object') return mesh.transform(ob.matrixWorld, True) # Count triangles (quads count as two triangles) triangleCount = 0 for f in mesh.faces: if len(f.v) == 4: triangleCount += 2 else: triangleCount += 1 # Extract indices from the Blender mesh (quads are split into two triangles) pindices = cast((c_int * 3 * triangleCount)(), POINTER(c_int)) i = 0 for f in mesh.faces: pindices[i] = c_int(f.v[0].index) pindices[i + 1] = c_int(f.v[1].index) pindices[i + 2] = c_int(f.v[2].index) i += 3 if len(f.v) == 4: pindices[i] = c_int(f.v[0].index) pindices[i + 1] = c_int(f.v[2].index) pindices[i + 2] = c_int(f.v[3].index) i += 3 # Extract vertex array from the Blender mesh vertexCount = len(mesh.verts) pvertices = cast((c_float * 3 * vertexCount)(), POINTER(c_float)) i = 0 for v in mesh.verts: pvertices[i] = c_float(v.co.x) pvertices[i + 1] = c_float(v.co.y) pvertices[i + 2] = c_float(v.co.z) i += 3 # Extract normals if EXPORT_NORMALS: pnormals = cast((c_float * 3 * vertexCount)(), POINTER(c_float)) i = 0 for v in mesh.verts: pnormals[i] = c_float(v.no.x) pnormals[i + 1] = c_float(v.no.y) pnormals[i + 2] = c_float(v.no.z) i += 3 else: pnormals = POINTER(c_float)() # Extract UVs if EXPORT_UV: ptexCoords = cast((c_float * 2 * vertexCount)(), POINTER(c_float)) if mesh.faceUV: for f in mesh.faces: for j, v in enumerate(f.v): k = v.index if k < vertexCount: uv = f.uv[j] ptexCoords[k * 2] = uv[0] ptexCoords[k * 2 + 1] = uv[1] else: i = 0 for v in mesh.verts: ptexCoords[i] = c_float(v.uvco[0]) ptexCoords[i + 1] = c_float(v.uvco[1]) i += 2 else: ptexCoords = POINTER(c_float)() # Extract colors if EXPORT_COLORS: pcolors = cast((c_float * 4 * vertexCount)(), POINTER(c_float)) for f in mesh.faces: for j, v in enumerate(f.v): k = v.index if k < vertexCount: col = f.col[j] pcolors[k * 4] = col.r / 255.0 pcolors[k * 4 + 1] = col.g / 255.0 pcolors[k * 4 + 2] = col.b / 255.0 pcolors[k * 4 + 3] = 1.0 else: pcolors = POINTER(c_float)() # Load the OpenCTM shared library if os.name == 'nt': libHDL = WinDLL('openctm.dll') else: libName = find_library('openctm') if not libName: Blender.Draw.PupMenu( 'Could not find the OpenCTM shared library') return libHDL = CDLL(libName) if not libHDL: Blender.Draw.PupMenu('Could not open the OpenCTM shared library') return # Get all the functions from the shared library that we need ctmNewContext = libHDL.ctmNewContext ctmNewContext.argtypes = [c_int] ctmNewContext.restype = c_void_p ctmFreeContext = libHDL.ctmFreeContext ctmFreeContext.argtypes = [c_void_p] ctmGetError = libHDL.ctmGetError ctmGetError.argtypes = [c_void_p] ctmGetError.restype = c_int ctmErrorString = libHDL.ctmErrorString ctmErrorString.argtypes = [c_int] ctmErrorString.restype = c_char_p ctmFileComment = libHDL.ctmFileComment ctmFileComment.argtypes = [c_void_p, c_char_p] ctmDefineMesh = libHDL.ctmDefineMesh ctmDefineMesh.argtypes = [ c_void_p, POINTER(c_float), c_int, POINTER(c_int), c_int, POINTER(c_float) ] ctmSave = libHDL.ctmSave ctmSave.argtypes = [c_void_p, c_char_p] ctmAddUVMap = libHDL.ctmAddUVMap ctmAddUVMap.argtypes = [c_void_p, POINTER(c_float), c_char_p, c_char_p] ctmAddUVMap.restype = c_int ctmAddAttribMap = libHDL.ctmAddAttribMap ctmAddAttribMap.argtypes = [c_void_p, POINTER(c_float), c_char_p] ctmAddAttribMap.restype = c_int ctmCompressionMethod = libHDL.ctmCompressionMethod ctmCompressionMethod.argtypes = [c_void_p, c_int] ctmVertexPrecisionRel = libHDL.ctmVertexPrecisionRel ctmVertexPrecisionRel.argtypes = [c_void_p, c_float] ctmNormalPrecision = libHDL.ctmNormalPrecision ctmNormalPrecision.argtypes = [c_void_p, c_float] ctmUVCoordPrecision = libHDL.ctmUVCoordPrecision ctmUVCoordPrecision.argtypes = [c_void_p, c_int, c_float] ctmAttribPrecision = libHDL.ctmAttribPrecision ctmAttribPrecision.argtypes = [c_void_p, c_int, c_float] # Create an OpenCTM context ctm = ctmNewContext(0x0102) # CTM_EXPORT try: # Set the file comment ctmFileComment( ctm, c_char_p('%s - created by Blender %s (www.blender.org)' % (ob.getName(), Blender.Get('version')))) # Define the mesh ctmDefineMesh(ctm, pvertices, c_int(vertexCount), pindices, c_int(triangleCount), pnormals) # Add UV coordinates? if EXPORT_UV: tm = ctmAddUVMap(ctm, ptexCoords, c_char_p(), c_char_p()) if EXPORT_MG2: ctmUVCoordPrecision(ctm, tm, EXPORT_UVPREC) # Add colors? if EXPORT_COLORS: cm = ctmAddAttribMap(ctm, pcolors, c_char_p('Color')) if EXPORT_MG2: ctmAttribPrecision(ctm, cm, EXPORT_CPREC) # Set compression method if EXPORT_MG2: ctmCompressionMethod(ctm, 0x0203) # CTM_METHOD_MG2 ctmVertexPrecisionRel(ctm, EXPORT_VPREC) if EXPORT_NORMALS: ctmNormalPrecision(ctm, EXPORT_NPREC) else: ctmCompressionMethod(ctm, 0x0202) # CTM_METHOD_MG1 # Save the file ctmSave(ctm, c_char_p(filename)) # Check for errors e = ctmGetError(ctm) if e != 0: s = ctmErrorString(e) Blender.Draw.PupMenu('Error%t|Could not save the file: ' + s) finally: # Free the OpenCTM context ctmFreeContext(ctm) finally: Window.WaitCursor(0) if is_editmode: Blender.Window.EditMode(1, '', 0)
def main(): NAME_DATA = Draw.Create('') NAME_INGROUP = Draw.Create('') NAME_DUPGROUP = Draw.Create('') NAME_IMAGE = Draw.Create('') NAME_MATERIAL = Draw.Create('') NAME_TEXTURE = Draw.Create('') PREF_CASESENS = Draw.Create(False) PREF_PART_MATCH = Draw.Create(True) # Get USER Options pup_block= [\ ('ObData:', NAME_DATA, 0, 32, 'Match with the objects data name'),\ ('InGroup:', NAME_INGROUP, 0, 32, 'Match with the group name to find one of its objects'),\ ('DupGroup:', NAME_DUPGROUP, 0, 32, 'Match with the group name to find an object that instances this group'),\ ('Image:', NAME_IMAGE, 0, 32, 'Match with the image name to find an object that uses this image'),\ ('Material:', NAME_MATERIAL, 0, 32, 'Match with the material name to find an object that uses this material'),\ ('Texture:', NAME_TEXTURE, 0, 32, 'Match with the texture name to find an object that uses this texture'),\ ('Case Sensitive', PREF_CASESENS, 'Do a case sensitive comparison?'),\ ('Partial Match', PREF_PART_MATCH, 'Match when only a part of the text is in the data name'),\ ] if not Draw.PupBlock('Find object using dataname...', pup_block): return NAME_DATA = NAME_DATA.val NAME_INGROUP = NAME_INGROUP.val NAME_DUPGROUP = NAME_DUPGROUP.val NAME_IMAGE = NAME_IMAGE.val NAME_MATERIAL = NAME_MATERIAL.val NAME_TEXTURE = NAME_TEXTURE.val PREF_CASESENS = PREF_CASESENS.val PREF_PART_MATCH = PREF_PART_MATCH.val if not PREF_CASESENS: NAME_DATA = NAME_DATA.lower() NAME_INGROUP = NAME_INGROUP.lower() NAME_DUPGROUP = NAME_DUPGROUP.lower() NAME_IMAGE = NAME_IMAGE.lower() NAME_MATERIAL = NAME_MATERIAL.lower() NAME_TEXTURE = NAME_TEXTURE.lower() def activate(ob, scn): bpy.data.scenes.active = scn scn.objects.selected = [] scn.Layers = ob.Layers & (1 << 20) - 1 ob.sel = 1 def name_cmp(name_search, name_found): if name_found == None: return False if not PREF_CASESENS: name_found = name_found.lower() if PREF_PART_MATCH: if name_search in name_found: # print name_found, name_search return True else: if name_found == name_search: # print name_found, name_search return True return False if NAME_INGROUP: # Best we speed this up. bpy.data.objects.tag = False ok = False for group in bpy.data.groups: if name_cmp(NAME_INGROUP, group.name): for ob in group.objects: ob.tag = True ok = True if not ok: Draw.PupMenu('No Objects Found') return for scn in bpy.data.scenes: for ob in scn.objects: if NAME_DATA: if name_cmp(NAME_DATA, ob.getData(1)): activate(ob, scn) return if NAME_INGROUP: # Crap and slow but not much we can do about that ''' for group in bpy.data.groups: if name_cmp(NAME_INGROUP, group.name): for ob_group in group.objects: if ob == ob_group: activate(ob, scn) return ''' # Use speedup, this is in a group whos name matches. if ob.tag: activate(ob, scn) return if NAME_DUPGROUP: if ob.DupGroup and name_cmp(NAME_DUPGROUP, ob.DupGroup.name): activate(ob, scn) return if NAME_IMAGE: for img in get_object_images(ob): if name_cmp(NAME_IMAGE, img.name) or name_cmp( NAME_IMAGE, img.filename.split('\\')[-1].split('/')[-1]): activate(ob, scn) return if NAME_MATERIAL or NAME_TEXTURE: try: materials = ob.getData(mesh=1).materials except: materials = [] # Add object materials materials.extend(ob.getMaterials()) for mat in materials: if mat: if NAME_MATERIAL: if name_cmp(NAME_MATERIAL, mat.name): activate(ob, scn) return if NAME_TEXTURE: for mtex in mat.getTextures(): if mtex: tex = mtex.tex if tex: if name_cmp(NAME_TEXTURE, tex.name): activate(ob, scn) return Draw.PupMenu('No Objects Found')