def read_main(filename):
global counts
counts = {'verts': 0, 'tris': 0}
start = time.clock()
file = open(filename, "r")
print_boxed("----------------start-----------------")
print 'Import Patch: ', filename
editmode = Window.EditMode() # are we in edit mode? If so ...
if editmode: Window.EditMode(0) # leave edit mode before getting the mesh
lines = file.readlines()
read_file(file, lines)
Blender.Window.DrawProgressBar(1.0, '') # clear progressbar
file.close()
print "----------------end-----------------"
end = time.clock()
seconds = " in %.2f %s" % (end - start, "seconds")
totals = "Verts: %i Tris: %i " % (counts['verts'], counts['tris'])
print_boxed(totals)
message = "Successfully imported " + Blender.sys.basename(
filename) + seconds
#meshtools.print_boxed(message)
print_boxed(message)
def edl_reload():
Window.WaitCursor(1)
filename = PREF['filename'].val
sce = bpy.data.scenes.active
fps = sce.render.fps
elist = EditList()
if filename:
if not elist.parse(filename, fps):
Draw.PupMenu('Error%t|Could not open the file "' + filename + '"')
reels = elist.getReels()
else:
reels = {}
REEL_UI.clear()
for reel_key, edits in reels.iteritems():
if reel_key == 'bw':
continue
flag = 0
for edit in edits:
flag |= edit.edit_type
reel_item = REEL_UI[reel_key] = ReelItemUI()
reel_item.ui_text = '%s (%s): ' % (reel_key, editFlagsToText(flag))
Window.WaitCursor(0)
def bevel():
""" The main function, which creates the bevel """
global me, NV, NV_ext, NE, NC, old_faces, old_dist
ob = act_mesh_ob()
if not ob: return
Window.WaitCursor(1) # Change the Cursor
t = Blender.sys.time()
is_editmode = Window.EditMode()
if is_editmode: Window.EditMode(0)
me = ob.data
NV = {}
#PY23 NO SETS# NV_ext = set()
NV_ext = {}
NE = {}
NC = {}
old_faces = []
make_faces()
make_edges()
make_corners()
clear_old()
old_dist = dist.val
print '\tbevel in %.6f sec' % (Blender.sys.time() - t)
me.update(1)
if is_editmode: Window.EditMode(1)
Window.WaitCursor(0)
Blender.Redraw()
def loadImage(fileName):
"""
Handles loading an image. This method populates
G.image, G.ibuf, G.iw, G.ih.
@param fileName: Name of the file to load.
"""
Window.WaitCursor(True)
# load the image and set up parameters
global G
try:
iloaded = loadTGARAW(fileName)
except Exception:
menuError('Could not load image.')
iloaded = None
if iloaded is None:
return
(G.image, ) = iloaded
G.iw, G.ih = G.image.size
G.imagename = fileName
# centre the image in the window rectangle
xw, yw, ww, hw = getWinRect()
G.imgpos[0] = (ww - G.iw) / 2
G.imgpos[1] = (hw - G.ih) / 2
Window.WaitCursor(False)
def main():
# 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
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
my_mesh_util(me)
# 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 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 main(): # 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() 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 vgroup_invert(ob_act, me) # Timing the script is a good way to be aware on any speed hits when scripting print 'Invert VGroup in %.2f seconds' % (sys.time()-t) Window.WaitCursor(0) if is_editmode: Window.EditMode(1)
def main():
# Gets the current scene, there can be many scenes in 1 blend file.
sce = Scene.GetCurrent()
# Get the active object, there can only ever be 1
# and the active object is always the editmode object.
ob_act = sce.objects.active
me = ob_act.getData(mesh=1)
if not ob_act or ob_act.type != 'Mesh' or not me.faceUV:
BPyMessages.Error_NoMeshUvActive()
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)
t = sys.time()
# Run the mesh editing function
seams_from_islands(me)
if is_editmode: Window.EditMode(1)
# Timing the script is a good way to be aware on any speed hits when scripting
print 'UV Seams from Islands finished in %.2f seconds' % (sys.time() - t)
Window.WaitCursor(0)
def export(self, scene):
theObjects = scene.objects
print "Starting OBJ export to " + self.filename
if not checkFile(self.filename):
return
Blender.Window.WaitCursor(1)
Window.DrawProgressBar(0, "Examining textures")
self.texture = getTexture(self, theObjects, self.iscsl, 7)
if self.regions:
(pwidth, pheight) = PanelRegionHandler().panelimage().size
for img, (n, x1, y1, width, height) in self.regions.iteritems():
self.regions[img] = (float(x1) / pwidth, float(y1) / pheight,
float(width) / pwidth,
float(height) / pheight)
#clock=time.clock() # Processor time
self.file = open(self.filename, "w")
self.writeHeader()
self.writeObjects(theObjects)
checkLayers(self, theObjects)
self.file.close()
Window.DrawProgressBar(1, "Finished")
#print "%s CPU time" % (time.clock()-clock)
print "Finished - exported %s primitives\n" % self.nprim
if self.log:
r = Draw.PupMenu(("Exported %s primitives%%t|" % self.nprim) +
'|'.join([a[0] for a in self.log]))
if r > 0: raise ExportError(None, self.log[r - 1][1])
else:
Draw.PupMenu("Exported %s primitives%%t|OK" % self.nprim)
def button_event(evt):
global config_data
if (evt == BROWSE_HOME_CLICKED):
default_path = "C:\\"
if (Blender.sys.exists(config_data["home"])):
default_path = config_data["home"]
Window.FileSelector(SetHomeDir, "Nebula Home", default_path)
if (evt == BROWSE_PROJ_CLICKED):
default_path = "C:\\"
if (Blender.sys.exists(config_data["home"])):
default_path = config_data["proj"]
Window.FileSelector(SetProjDir, "Project Dir", default_path)
if (evt == ASSIGN_DIR_CHANGED):
for data in config_data:
if (data != "home" and data != "texture_dir" and data != "proj"):
config_data[data] = dir_assigns[data].val
if (evt == OK_CLICKED):
SaveConfig()
result = Draw.PupMenu("Saved%t|Do you want to exit?")
if (result != -1):
Draw.Exit()
return
if (evt == CANCEL_CLICKED):
result = Draw.PupMenu("Exit%t|Exit and Discard Changes?")
if (result != -1):
Draw.Exit()
return
def main():
# get selected meshes
obs = [ob for ob in self.context.selected_objects if ob.type == 'MESH']
# ask for weights to delete
PREF_CUTOFF = Blender.Draw.Create(0.02)
PREF_NBONES = Blender.Draw.Create(4)
pup_block = [\
('Weight Cutoff', PREF_CUTOFF, 0.001, 0.499, 'Vertices with weight less than this number will be deleted from the vertex group.'),\
('Max Bones', PREF_NBONES, 1, 10, 'Also remove weakest influences so total number of bone influences is never larger than this number.'),\
]
if not Blender.Draw.PupBlock('Vertex Squash', pup_block):
return
# saves editmode state and exit editmode if it is enabled
# (cannot make changes mesh data in editmode)
is_editmode = Window.EditMode()
Window.EditMode(0)
Window.WaitCursor(1)
t = sys.time()
# run script
num_affected = 0
for ob in obs:
me = ob.getData(mesh=1) # get Mesh, not NMesh
num_affected += weight_squash(me, cutoff = PREF_CUTOFF.val, nbones = PREF_NBONES.val)
print(f'Weight Squash finished in {(sys.time()-t):.2f} seconds')
print(f'{num_affected} vertices removed from groups')
Window.WaitCursor(0)
if is_editmode: Window.EditMode(1)
def copy_act_vgroup(me, PREF_NAME, PREF_SEL_ONLY):
Window.WaitCursor(1)
groupNames, vWeightDict = BPyMesh.meshWeight2Dict(me)
act_group = me.activeGroup
if not PREF_SEL_ONLY:
for wd in vWeightDict:
try:
wd[PREF_NAME] = wd[act_group]
except:
pass
else:
# Selected faces only
verts = {} # should use set
for f in me.faces:
if f.sel:
for v in f:
verts[v.index] = None
for i in verts.iterkeys():
wd = vWeightDict[i]
try:
wd[PREF_NAME] = wd[act_group]
except:
pass
groupNames.append(PREF_NAME)
# Copy weights back to the mesh.
BPyMesh.dict2MeshWeight(me, groupNames, vWeightDict)
Window.WaitCursor(0)
def main():
# 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
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()
# Restore editmode if it was enabled
if is_editmode: Window.EditMode(1)
print 'ActionScript 3.0 Exporter Script finished in %.2f seconds' % (
sys.time() - t)
Window.WaitCursor(0)
def get_coordinates(self):
win_id = Window.GetAreaID()
win_data = Window.GetScreenInfo()
for win in win_data:
if win["id"] == win_id:
return win["vertices"]
def file_callback(filename):
obj = NETimport(filename)
try:
obj.doimport()
Blender.Scene.GetCurrent().update()
except ParseError, e:
Window.WaitCursor(0)
Window.DrawProgressBar(0, 'ERROR')
if e.type == ParseError.HEADER:
msg = 'This is not a valid X-Plane v6, v7 or v8 OBJ file'
elif e.type == ParseError.NAME:
msg = 'Missing dataref or light name at line %s\n' % obj.m.lineno
elif e.type == ParseError.MISC:
msg = '%s at line %s' % (e.value, obj.m.lineno)
else:
thing = ParseError.TEXT[e.type]
if e.value:
msg = 'Expecting a %s, found "%s" at line %s' % (
thing, e.value, obj.m.lineno)
else:
msg = 'Missing %s at line %s' % (thing, obj.m.lineno)
print "ERROR:\t%s\n" % msg
Draw.PupMenu("ERROR%%t|%s" % msg)
Window.RedrawAll()
Window.DrawProgressBar(1, 'ERROR')
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():
# 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)
t = sys.time()
# Run the mesh editing function
report = find_unassigned_verts(ob_act)
# Restore editmode if it was enabled
if is_editmode: Window.EditMode(1)
if report != "":
report = report + "!!! I have selected all affected verts. Please lookup your mesh in edit mode !!!"
text = "Report: %t|" + report +"|OK"
Draw.PupMenu(text)
Window.WaitCursor(0)
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 actWeightNormalize(me, PREF_MODE, PREF_MAX_DIST, PREF_STRENGTH, PREF_ITERATIONS): Window.WaitCursor(1) groupNames, vWeightDict= BPyMesh.meshWeight2Dict(me) act_group= me.activeGroup # Start with assumed zero weights orig_vert_weights= [0.0] * len(vWeightDict) # Will be directly assigned to orig_vert_weights # fill in the zeros with real weights. for i, wd in enumerate(vWeightDict): try: orig_vert_weights[i]= wd[act_group] except: pass new_vert_weights= list(orig_vert_weights) for dummy in xrange(PREF_ITERATIONS): # Minimize or maximize the weights. connection based. if PREF_MODE==0: # Grow op= max else: # Shrink op= min for ed in me.edges: if not PREF_MAX_DIST or ed.length < PREF_MAX_DIST: i1= ed.v1.index i2= ed.v2.index new_weight= op(orig_vert_weights[i1], orig_vert_weights[i2]) if PREF_STRENGTH==1.0: # do a full copy new_vert_weights[i1]= op(new_weight, new_vert_weights[i1]) new_vert_weights[i2]= op(new_weight, new_vert_weights[i2]) else: # Do a faded copy new_vert_weights[i1]= op(new_weight, new_vert_weights[i1]) new_vert_weights[i2]= op(new_weight, new_vert_weights[i2]) # Face the copy with the original (orig is updated per iteration) new_vert_weights[i1]= (new_vert_weights[i1]*PREF_STRENGTH) + (orig_vert_weights[i1]*(1-PREF_STRENGTH)) new_vert_weights[i2]= (new_vert_weights[i2]*PREF_STRENGTH) + (orig_vert_weights[i2]*(1-PREF_STRENGTH)) for i, wd in enumerate(vWeightDict): new_weight= new_vert_weights[i] if new_weight != orig_vert_weights[i]: wd[act_group]= new_weight if dummy+1 != PREF_ITERATIONS: # dont copy the list on the last round. orig_vert_weights= list(new_vert_weights) # Copy weights back to the mesh. BPyMesh.dict2MeshWeight(me, groupNames, vWeightDict) Window.WaitCursor(0)
def do_export(sel_group, filepath):
Window.WaitCursor(1)
t = sys.time()
#init Drawing ---------------------
d=Drawing()
#add Tables -----------------
#d.blocks.append(b) #table blocks
d.styles.append(Style()) #table styles
d.views.append(View('Normal')) #table view
d.views.append(ViewByWindow('Window',leftBottom=(1,0),rightTop=(2,1))) #idem
#add Entities --------------------
something_ready = False
#ViewVector = Mathutils.Vector(Window.GetViewVector())
#print 'deb: ViewVector=', ViewVector #------------------
mw0 = Window.GetViewMatrix()
#mw0 = Window.GetPerspMatrix() #TODO: how get it working?
mw = mw0.copy()
if FLATTEN:
m0 = Mathutils.Matrix()
m0[2][2]=0.0
mw *= m0 #flatten ViewMatrix
for ob in sel_group:
entities = []
mx = ob.matrix.copy()
mb = mx.copy()
#print 'deb: mb =\n', mb #---------
#print 'deb: mw0 =\n', mw0 #---------
mx_n = mx.rotationPart() * mw0.rotationPart() #trans-matrix for normal_vectors
if SCALE_FACTOR!=1.0: mx *= SCALE_FACTOR
if FLATTEN: mx *= mw
#mx_inv = mx.copy().invert()
#print 'deb: mx =\n', mx #---------
#print 'deb: mx_inv=\n', mx_inv #---------
if (ob.type == 'Mesh'):
entities = exportMesh(ob, mx, mx_n)
elif (ob.type == 'Curve'):
entities = exportCurve(ob, mx)
for e in entities:
d.append(e)
something_ready = True
if something_ready:
d.saveas(filepath)
Window.WaitCursor(0)
#Draw.PupMenu('DXF Exporter: job finished')
print 'exported to %s' % filepath
print 'finished in %.2f seconds' % (sys.time()-t)
else:
Window.WaitCursor(0)
print "Abort: selected objects dont mach choosen export option, nothing exported!"
Draw.PupMenu('DXF Exporter: nothing exported!|selected objects dont mach choosen export option!')
def filesel_callback(filename):
inform("\nTrying to import AC3D model(s) from:\n%s ..." % filename)
Window.WaitCursor(1)
starttime = bsys.time()
test = AC3DImport(filename)
Window.WaitCursor(0)
endtime = bsys.time() - starttime
inform('Done! Data imported in %.3f seconds.\n' % endtime)
def mouseup():
# Loop until click
mouse_buttons = Window.GetMouseButtons()
while not mouse_buttons & LMB:
sys.sleep(10)
mouse_buttons = Window.GetMouseButtons()
while mouse_buttons & LMB:
sys.sleep(10)
mouse_buttons = Window.GetMouseButtons()
def buttonEventHandler(button):
"""
Event handler for button presses.
@param button: Button ID.
"""
global G
G.havebupclik = False
if button == BUTTON_QUIT:
removeCustomScriptLink()
writeDataToRegistry()
Draw.Exit()
Window.RedrawAll()
elif button == BUTTON_LOAD:
G.havebupclik = True
Window.ImageSelector(loadImage)
elif button == BUTTON_ZOOM:
x, y, w, h = getWinRect()
setZoom((w / 2, h / 2), G.buttons.zoom.val)
elif button == BUTTON_FULLOPT:
G.fullopt = G.buttons.fullopt.val
elif button == BUTTON_COPLANAR:
G.coplanar = G.buttons.coplanar.val
elif button == BUTTON_OFSX:
G.ofsx = G.buttons.ofsx.val
elif button == BUTTON_OFSY:
G.ofsy = G.buttons.ofsy.val
elif button == BUTTON_OFSZ:
G.ofsz = G.buttons.ofsz.val
elif button == BUTTON_ADD:
G.mode = MODE_ADD
Draw.Redraw(1)
elif button == BUTTON_DELETE:
def delmap(x):
del G.coordmap[x.getName()]
x.select(False)
map(delmap, G.selection)
Window.RedrawAll()
elif button == BUTTON_CALIBRATE:
Window.WaitCursor(True)
G.last_camera = G.selection[0]
calibrate()
def create_topomesh(filename):
Window.WaitCursor(True)
#current object
sc = Scene.GetCurrent()
ref_obj = sc.getActiveObject()
save_topomesh(filename, ref_obj.data)
Window.RedrawAll()
def layer_number(elem):
layer_number = int(elem.name)
visible_layers = Window.ViewLayers()
if layer_number in visible_layers:
if len(visible_layers) > 1:
visible_layers.remove(layer_number)
else:
visible_layers.append(layer_number)
Window.ViewLayers(visible_layers)
def runAsTextPlugin():
'''Called when run as a text plugin.'''
import Blender
from Blender import Window, sys, Draw
import BPyTextPlugin, bpy
message = ("Convert Game Engine script from 4.48 API to 2.49 API%t|"
"Run on active script only%x1|"
"Run on ALL text buffers%x2")
convertAllBuffers = Draw.PupMenu(message) == 2
Window.WaitCursor(1)
try:
nconverted = 0
nerrors = 0
if convertAllBuffers:
texts = bpy.data.texts
else:
if not bpy.data.texts.active:
Draw.PupMenu("No active buffer.")
return
texts = [bpy.data.texts.active]
Blender.SaveUndoState('Convert BGE 2.49')
for txt in texts:
bufName = txt.name
if txt.lib:
bufName = txt.lib + '/' + bufName
lines = txt.asLines()
for i in range(0, len(lines)):
if not lines[i].endswith('\n'):
lines[i] = lines[i] + '\n'
nc, ne = convert248to249(lines, fileName=bufName)
nconverted = nconverted + nc
nerrors = nerrors + ne
txt.clear()
for line in lines:
txt.write(line)
finally:
Window.WaitCursor(0)
message = "Converted %d attributes." % nconverted
if nerrors == 1:
message = message + " There was 1 error (see console)."
if nerrors > 1:
message = message + " There were %d errors (see console)." % nerrors
message = message + "|Please review all the changes."
Draw.PupMenu(message)
def main(arg):
# get selected bones
obs = [ob for ob in self.context.selected_objects if ob.type == 'ARMATURE']
if obs:
boneitems = [(bonename, bone)
for (bonename,
bone) in list(obs[0].getPose().bones.items())
if bone.sel]
else:
boneitems = []
# exit if no bones selected
if not boneitems:
print("no bones selected in pose mode")
Blender.Draw.PupMenu('ERROR%t|no bones selected in pose mode')
return
# ask for weights to delete
PREF_PRIORITY = Blender.Draw.Create(30)
pup_block = [\
('Priority', PREF_PRIORITY, 0, 200, 'Bone priority.'),\
]
if not Blender.Draw.PupBlock('Set Bone Priority', pup_block):
return
# saves editmode state and exit editmode if it is enabled
# (cannot make changes mesh data in editmode)
is_editmode = Window.EditMode()
Window.EditMode(0)
Window.WaitCursor(1)
t = sys.time()
# run script
for bonename, bone in boneitems:
# get priorty null constraint
print(("setting priority %i on %s" % (PREF_PRIORITY.val, bonename)))
priorityconstr = None
for constr in bone.constraints:
if constr.type == Blender.Constraint.Type.NULL \
and constr.name[:9] == "priority:":
priorityconstr = constr
break
if not priorityconstr:
priorityconstr = bone.constraints.append(
Blender.Constraint.Type.NULL)
priorityconstr.name = "priority:%i" % PREF_PRIORITY.val
print('Set bone priority finished in %.2f seconds' % (sys.time() - t))
Window.WaitCursor(0)
if is_editmode: Window.EditMode(1)
def create_topomesh(filename):
Window.WaitCursor(True)
#link to object
obj = Object.New('Mesh', 'myObj')
#link to scene
sc = Scene.GetCurrent()
sc.link(obj)
me = load_topomesh(filename, obj)
Window.RedrawAll()
def setUpMesh():
""" Imports the mesh and connects it to the armature. """
print 'Setting up mesh...'
t1= Blender.sys.time()
# A little hack because import_obj.py doesnt provide the names of the imported objects
objectsBefore = [ob for ob in scene.objects]
import_obj.load_obj(MESHString)
names = [ob.name for ob in scene.objects if ob not in objectsBefore]
global mesh_name
# The mesh created in makehuman is split up in parts, and these need to be
# joined together before connecting it to the armature. Uses 'body' as the
# main mesh part and connects all other parts to this.
mesh_name = [s for s in names if 'body' in s][0]
restmesh_name = [s for s in names if s is not mesh_name]
armature = [ob for ob in scene.objects if ob.name == armature_name][0]
armature.RotX = math.pi/2
bodymesh = [ob for ob in scene.objects if ob.name == mesh_name][0]
restmesh = [ob for ob in scene.objects if ob.name in restmesh_name]
bodymesh.join(restmesh)
for ob in restmesh:
scene.objects.unlink(ob)
print 'done moving armature and joining mesh parts, it took %.4fs' % (Blender.sys.time()-t1)
t2 = Blender.sys.time()
editmode = Window.EditMode() # are we in edit mode? If so ...
if editmode: Window.EditMode(0) # leave edit mode
# Actual code for connection to armature. We still need to fix the remaining
# verts though. This is done in fixVerts()
armature.makeParent([bodymesh])
bodymesh.addVertexGroupsFromArmature(armature)
mods = bodymesh.modifiers
mod = mods.append(Modifier.Types.ARMATURE)
mod[Modifier.Settings.OBJECT] = armature
mod[Modifier.Settings.VGROUPS] = True
mod[Modifier.Settings.ENVELOPES] = True
print 'done adding mesh using bone heat, it took %.4fs' % (Blender.sys.time()-t2)
if editmode: Window.EditMode(1) # optional, just being nice
print 'Setting up mesh took %.4fs' % (Blender.sys.time()-t1)
def build(type):
global shapes, widmenu, rangename
sce = bpy.data.scenes.active
ob = sce.objects.active
try:
ob.getData(mesh=1).key
except:
Blender.Draw.PupMenu('Aborting%t|Object has no keys')
return
loc = Window.GetCursorPos()
range = makeRange(sce, type, rangename.val)
controller = makeController(sce, rangename.val)
text = makeText(sce, rangename.val)
range.restrictRender = True
controller.restrictRender = True
text.restrictRender = True
range.setLocation(loc)
controller.setLocation(loc)
text.setLocation(loc)
range.makeParent([controller], 1)
range.makeParent([text], 0)
sce.update()
setupDrivers(ob, controller, widmenu.val)
def progress(self, message=None):
if message==None:
message=self.status
Window.drawProgressBar(1.0-len(self.lines)/self.length, message)
