def writeBone(file,bone,armObj,recurse):
pose = armObj.getPose()
file.write('\t\t<bonedef name="%s">\n' % bone.name)
flipMat = Matrix([1,0,0,0],[0,0,-1,0],[0,1,0,0],[0,0,0,1])
# Write each frame
for f in range(Blender.Get('staframe'),Blender.Get('endframe')+1):
Blender.Set('curframe',f)
posebone = pose.bones[bone.name]
poseMatrix = armObj.matrixWorld.copy().invert() * posebone.localMatrix * armObj.matrixWorld
file.write('\t\t\t<frame num="%d"\n' % f)
file.write('\t\t\t\tm00="%.6f" m01="%.6f" m02="%.6f" m03="%.6f"\n' % tuple(poseMatrix[0]))
file.write('\t\t\t\tm10="%.6f" m11="%.6f" m12="%.6f" m13="%.6f"\n' % tuple(poseMatrix[1]))
file.write('\t\t\t\tm20="%.6f" m21="%.6f" m22="%.6f" m23="%.6f"\n' % tuple(poseMatrix[2]))
file.write('\t\t\t\tm30="%.6f" m31="%.6f" m32="%.6f" m33="%.6f"\n' % tuple(poseMatrix[3]))
file.write('\t\t\t/>\n')
# Skip bone weight for now, it doesn't seem to affect anything
file.write('\t\t</bonedef>\n')
if recurse and bone.hasChildren():
for child in bone.getAllChildren():
writeBone(file,child,armObj,False)
def write_header(file, filename, scn, worldTable):
print "Write Header"
context = scn.getRenderingContext()
file.write("*3DSMAX_ASCIIEXPORT%s200\n" % (Tab))
file.write("*COMMENT \"Exported from Blender %s - %s\"\n" %
(Blender.Get('version'), time.asctime(time.localtime())))
file.write("*SCENE {\n")
#file.write("%s*SCENE_FILENAME \"%s\"\n" % (Tab, os.path.basename(Blender.Get('filename'))))
name = Blender.Get('filename').split('/')[-1].split('\\')[
-1] #Blender 2.44
file.write("%s*SCENE_FILENAME \"%s\"\n" % (Tab, name))
file.write("%s*SCENE_FIRSTFRAME %d\n" % (Tab, context.startFrame()))
file.write("%s*SCENE_LASTFRAME %d\n" % (Tab, context.endFrame()))
file.write("%s*SCENE_FRAMESPEED %d\n" % (Tab, context.framesPerSec()))
file.write("%s*SCENE_TICKSPERFRAME 160\n" % (Tab)) #Blender has no Ticks?
file.write(
"%s*SCENE_BACKGROUND_STATIC %.4f %.4f %.4f\n" %
(Tab, worldTable['horR'], worldTable['horG'], worldTable['horB']))
file.write(
"%s*SCENE_AMBIENT_STATIC %.4f %.4f %.4f\n" %
(Tab, worldTable['ambR'], worldTable['ambG'], worldTable['ambB']))
file.write("}\n")
def __init__(self, **kvargs):
self.dir = Blender.Get('uscriptsdir')
self.file = ''
self.x_zoom = 1.0
self.y_zoom = 1.0
self.x_clip = 0
self.y_clip = 0
self.clip_width = -1
self.clip_height = -1
self.image_block = None
super(Image, self).__init__(**kvargs)
# TODO: it would be safer to check the file header
if self.file.endswith('svg'):
self.dir = get_icons_dir()
source_dir = Blender.Get('uscriptsdir')
svg_path = find_file_path(source_dir, self.file)
png_name = change_extension(self.file, 'png')
png_path = os.path.join(self.dir, png_name)
convert_svg_to_png(svg_path, png_path, self.width, self.height)
self.file = png_name # use png version from now on
self.image_block = load_image(self.dir, self.file)
self.set_element_dimensions()
def write(filename, objects):
def veckey3d(v):
return round(v.x, 6), round(v.y, 6), round(v.z, 6)
def veckey2d(v):
return round(v.x, 6), round(v.y, 6)
print 'OBJ Export path: "%s"' % filename
temp_mesh_name = '~tmp-mesh'
time1 = sys.time()
scn = Scene.GetCurrent()
file = open(filename, "w")
# Write Header
file.write('# Blender3D v%s EOL Armature File: %s\n' %
(Blender.Get('version'),
Blender.Get('filename').split('/')[-1].split('\\')[-1]))
file.write('# www.blender3d.org\n')
# Get all armatures
for ob_main in objects:
for ob, ob_mat in BPyObject.getDerivedObjects(ob_main):
write_armature(file, ob)
write_poses(file, ob)
file.close()
print "Armature Export time: %.2f" % (sys.time() - time1)
def getOutputFilename(self, frameNumber, useDate=True):
scene = self.scene
render = scene.getRenderingContext()
if frameNumber == None:
outDir = Blender.Get("renderdir")
if outDir == None: outDir = tempfile.gettempdir()
if useDate:
from datetime import datetime
dt = datetime.now()
outputFile = os.path.join(
outDir, 'yafaray-' + dt.strftime("%Y-%m-%d_%H%M%S"))
else:
outputFile = os.path.join(outDir, 'yafarayRender')
# animation, need to determine path + filename
else:
outPath = render.renderPath
if len(outPath) > 0:
padCount = outPath.count('#')
if padCount > 0:
formatStr = "%0" + str(padCount) + "d"
formatStr = formatStr % (frameNumber)
outPath = outPath.replace('#', formatStr, 1)
outPath = outPath.replace('#', '')
else:
formatStr = "%05d" % (frameNumber)
outPath += formatStr
outputFile = outPath % {'fn': frameNumber}
else:
outDir = Blender.Get("renderdir")
if outDir == None: outDir = tempfile.gettempdir()
outputFile = os.path.join(
outDir, 'yafaray-%(fn)05d' % {'fn': frameNumber})
outputFile = os.path.abspath(outputFile)
return outputFile
def button_event(evt): # gui button events
global SCREEN, START_SCREEN, SCRIPT_SCREEN
global BEVT_LINK, BEVT_EMAIL, BEVT_GMENU, BUT_GMENU, SCRIPT_INFO
global SCROLL_DOWN, FMODE
if evt >= 100: # group menus
for i in range(len(BUT_GMENU)):
if evt == BEVT_GMENU[i]:
group = AllGroups[i]
index = BUT_GMENU[i].val - 1
if index < 0: return # user didn't pick a menu entry
script = group.get_scripts()[BUT_GMENU[i].val - 1]
if parse_help_info(script):
SCREEN = SCRIPT_SCREEN
BEVT_LINK = range(20, len(SCRIPT_INFO.d['__url__']) + 20)
BEVT_EMAIL = range(50,
len(SCRIPT_INFO.d['__email__']) + 50)
Draw.Redraw()
else:
res = Draw.PupMenu(
"No help available%t|View Source|Cancel")
if res == 1:
load_script_text(script)
elif evt >= 20:
if not WEBBROWSER:
Draw.PupMenu(
'Missing standard Python module%t|You need module "webbrowser" to access the web'
)
return
if evt >= 50: # script screen email buttons
email = SCRIPT_INFO.d['__email__'][evt - 50][1]
webbrowser.open("mailto:%s" % email)
else: # >= 20: script screen link buttons
link = SCRIPT_INFO.d['__url__'][evt - 20][1]
webbrowser.open(link)
elif evt == BEVT_VIEWSOURCE:
if SCREEN == SCRIPT_SCREEN: load_script_text(SCRIPT_INFO.script)
elif evt == BEVT_EXIT:
Draw.Exit()
return
elif evt == BEVT_BACK:
if SCREEN == SCRIPT_SCREEN and not FMODE:
SCREEN = START_SCREEN
SCRIPT_INFO = None
SCROLL_DOWN = 0
Draw.Redraw()
elif evt == BEVT_EXEC: # Execute script
exec_line = ''
if SCRIPT_INFO.script.userdir:
exec_line = bsys.join(Blender.Get('uscriptsdir'),
SCRIPT_INFO.script.fname)
else:
exec_line = bsys.join(Blender.Get('scriptsdir'),
SCRIPT_INFO.script.fname)
Blender.Run(exec_line)
def choreoExport(scene, normalize=True):
SelectedObjects = Blender.Object.GetSelected()
listeners = Acoustic.getListeners()
sources = []
target = None
buffer = ""
for source in Acoustic.getSources():
if source.sel == 1:
sources.append(source)
for listener in listeners:
if listener.sel == 1:
target = listener
break
if target == None or not sources:
Blender.Draw.PupMenu(
'You have to select one listener and at least one source objects!')
return
allAcousticObjects = Acoustic.getAcousticObjects(scene)
# print list(allAcousticObjects)
#TODO: refactor this (checked three times!)
if normalize == True:
normalizationOffset, normalizationScale = getNormalizationParameters(
allAcousticObjects)
for frame in range(Blender.Get('staframe'), Blender.Get('endframe')):
Blender.Set('curframe', frame)
sourceOrientationMatrix = target.mat
if target.type == 'Camera': # if the listener is a camera, do a proper rotation acording to conventions: azimuth 0: seeing at x+
rotationMatrix = Blender.Mathutils.Euler(
90, 0, -90).toMatrix().invert().resize4x4()
sourceOrientationMatrix = rotationMatrix * sourceOrientationMatrix
roll, descention, azimuth = sourceOrientationMatrix.toEuler()
targetElevation = (-descention) % 360
if targetElevation > 180:
targetElevation = targetElevation - 360
targetRoll = (roll) % 360
targetAzimuth = (azimuth) % 360
if normalize == True:
targetX, targetY, targetZ = normalizePosition(
listener.mat.translationPart(), normalizationOffset,
normalizationScale, False)
else:
targetX, targetY, targetZ = listener.mat.translationPart()
sourcesPositions = ""
for source in sources:
if source.sel == 1:
if normalize == True:
sourceX, sourceY, sourceZ = normalizePosition(
source.mat.translationPart(), normalizationOffset,
normalizationScale, False)
else:
sourceX, sourceY, sourceZ = source.mat.translationPart()
sourcesPositions += " %f\t%f\t%f" % (sourceX, sourceY, sourceZ)
buffer += ChoreoLineTemplate % vars()
return buffer
def writeHeader(self):
bfile = sys.expandpath(Blender.Get('filename'))
self.file.write("#VRML V2.0 utf8\n\n")
self.file.write("# This file was authored with Blender " \
"(http://www.blender.org/)\n")
self.file.write("# Blender version %s\n" % Blender.Get('version'))
self.file.write("# Blender file %s\n" % sys.basename(bfile))
self.file.write("# Exported using VRML97 exporter " \
"v1.55 (2006/01/17)\n\n")
def fill_md2_tags(md2_tags, object):
global g_scale
Blender.Window.DrawProgressBar(0.0, "Filling MD2 Data")
# Set header information.
md2_tags.ident = 844121162
md2_tags.version = 1
md2_tags.num_tags += 1
# Add a name node to the tagnames data structure.
md2_tags.names.append(md2_tagname(object.name)) # TODO: cut to 64 chars
# Add a (empty) list of tags-positions (for each frame).
tag_frames = []
progress = 0.0
progressIncrement = 1.0 / md2_tags.num_frames
# Store currently set frame
previous_curframe = Blender.Get("curframe")
frame_counter = 0
# Fill in each tag with its positions per frame
print "Blender startframe:", Blender.Get('staframe')
print "Blender endframe:", Blender.Get('endframe')
for current_frame in range(Blender.Get('staframe'),
Blender.Get('endframe') + 1):
#print current_frame, "(", frame_counter, ")" # DEBUG
progress += progressIncrement
Blender.Window.DrawProgressBar(
progress,
"Tag:" + str(md2_tags.num_tags) + " Frame:" + str(frame_counter))
#add a frame
tag_frames.append(md2_tag())
#set blender to the correct frame (so the objects have their new positions)
Blender.Set("curframe", current_frame - 1)
# Set first coordiantes to the location of the empty.
tag_frames[frame_counter].origin = object.getLocation('worldspace')
# print tag_frames[frame_counter].origin[0], " ",tag_frames[frame_counter].origin[1]," ",tag_frames[frame_counter].origin[2] # Useful for DEBUG (slowdown!)
matrix = object.getMatrix('worldspace')
tag_frames[frame_counter].axis1 = (matrix[0][0], matrix[0][1],
matrix[0][2])
tag_frames[frame_counter].axis2 = (matrix[1][0], matrix[1][1],
matrix[1][2])
tag_frames[frame_counter].axis3 = (matrix[2][0], matrix[2][1],
matrix[2][2])
frame_counter += 1
# Restore curframe from before the calculation.
Blender.Set("curframe", previous_curframe)
md2_tags.tags.append(tag_frames)
def register(self,classObject,Object=None,**kw):
blenderUIDialog._store("upy_plugin",{self.plugin_name:Object})
prefdir = Blender.Get('uscriptsdir')
if prefdir is None:
prefdir = Blender.Get('scriptsdir')
#need to wrote the script as a text file that will be link to the object/scene
blenderHelper.addTextFile(name=Object.plugin_name,
text=self.string_representation)
scene = blenderHelper.getCurrentScene()
#should load the script for scene update...
scene.addScriptLink(Object.plugin_name, "FrameChanged")
def getFullFileName(self, filename):
fullFileName = Blender.sys.expandpath(filename)
if not Blender.sys.exists(fullFileName):
# Try the sound directory
baseFilename = Blender.sys.basename(filename)
fullFileName = Blender.Get('soundsdir') + Blender.sys.sep + baseFilename
if not Blender.sys.exists(fullFileName):
# Look in the same directory as the .blend file
blendfile = Blender.Get('filename')
fullFileName = Blender.sys.dirname(blendfile) + Blender.sys.sep + baseFilename
if not Blender.sys.exists(fullFileName):
fullFileName = None
return fullFileName
def __init__(self):
self.user_input = ''
self.current_file = ''
self.search_dirs = []
dir = Blender.Get('texturesdir')
if dir != None and dir != '':
self.search_dirs.append(dir)
dir = Blender.sys.dirname(Blender.Get('filename'))
if dir != None and dir != '':
print dir
self.search_dirs.append(dir)
def fLaunch(dummy):
if self.error is False:
print os.path.join(Blender.Get('scriptsdir'), EXPORTER_NAME)
Blender.Run(
os.path.join(Blender.Get('scriptsdir'), EXPORTER_NAME))
else:
if self.error is True:
word = "corrected"
elif self.error is None:
word = "validated"
Draw.PupMenu(
'Launch Error%s|Cannot launch until configuration is %s' %
('%t', word))
def _convertAnimations(self, fixUpAxis):
if (len(self.animationList) > 0):
# store current settings
frameAtExportTime = Blender.Get('curframe')
actionAtExportTime = self.bArmatureObject.getAction()
# frames per second
fps = Blender.Scene.GetCurrent().getRenderingContext(
).framesPerSec()
animationNameList = []
for animation in self.animationList:
# warn on morph animation name clash
animationName = animation.getName()
if animationName in animationNameList:
Log.getSingleton().logWarning("Duplicate animation name \"%s\" for skeleton \"%s\"!" \
% (animationName, self.getName()))
animationNameList.append(animationName)
# export
animation.export(fixUpAxis, self, fps)
# restore current settings
Blender.Set('curframe', frameAtExportTime)
if (actionAtExportTime is not None):
actionAtExportTime.setActive(self.bArmatureObject)
else:
self.bArmatureObject.action = None
return
def __init__(self):
self.credentials = PasswordManager("b2rex")
self.path = os.path.dirname(Blender.Get('filename'))
self.pack = 'pack'
self.username = ''
self.password = ''
self.server_url = 'http://delirium:9000'
self.export_dir = ''
self.locX = BoundedValueModel(-10000.0, 10000.0, 128.0)
self.locY = BoundedValueModel(-10000.0, 10000.0, 128.0)
self.locZ = BoundedValueModel(-1000.0, 1000.0, 20.0)
self.regenMaterials = True
self.regenObjects = False
self.regenTextures = False
self.regenMeshes = False
self.kbytesPerSecond = 100
self.agent_libs_path = ""
self.pool_workers = 5
self.rt_budget = 20
self.next_chat = ""
self.tools_path = ""
self.rt_sec_budget = 500
self.terrainLOD = 1
self.load()
return
def bakeFrames(self, tobake):
myipoName = tobake.getName()
debug('Baking frames for scene %s material %s to ipo %s' %
(bpy.data.scenes.active.getName(), self.material.getName(),
myipoName))
ipos = self.getCurves(tobake)
#TODO: Gui setup idea: myOffset
# reset action to start at frame 1 or at location
myOffset = 0 #=1-staframe
#loop through frames in the animation. Often, there is rollup and the mocap starts late
staframe, endframe, curframe = getRangeFromIpo(self.material.getIpo())
for frame in range(staframe, endframe + 1):
#tell Blender to advace to frame
Blender.Set(
'curframe', frame
) # computes the constrained location of the 'real' objects
#using the constrained Loc Rot of the object, set the location of the unconstrained clone. Yea! Clones are FreeMen
key = self.getColor(
self.material
) #a key is a set of specifed exact channel values (LocRotScale) for a certain frame
myframe = frame + myOffset
Blender.Set('curframe', myframe)
time = Blender.Get('curtime') #for BezTriple
ipos = addPoint(time, key,
ipos) #add this data at this time to the ipos
debug('%s %i %.3f %.2f %.2f %.2f %.2f' %
(myipoName, myframe, time, key[0], key[1], key[2], key[3]))
Blender.Set('curframe', staframe)
return tobake
def synchronize(self):
prefdir = Blender.Get('uscriptsdir')
if prefdir is None:
prefdir = Blender.Get('scriptsdir')
self.helper.addTextFile(name="epmv_synchro",
file=prefdir + os.sep +
"epmv_blender_update.py")
scene = self.helper.getCurrentScene()
#should load the script for scene update...
if self.synchro_realtime:
if not hasattr(self, "epmv_synchro") or not self.epmv_synchro:
scene.addScriptLink("epmv_synchro", "FrameChanged")
self.epmv_synchro = True
else:
scene.clearScriptLinks()
self.epmv_synchro = False
def LoadDefaultVals():
global toggleLookAt, toggleBakeMatrix, toggleSampleAnimation, toggleNewScene, \
toggleClearScene, toggleTriangles, togglePolygons, toggleExportSelection, \
scriptsLocation, doImport, defaultFilename, fileButton, valsLoaded, \
togglePhysics, toggleExportCurrentScene, toggleExportRelativePaths, \
toggleUseUV, toggleOnlyMainScene, toggleApplyModifiers
if valsLoaded:
return None
colladaReg = Blender.Registry.GetKey('collada',True)
if not (colladaReg is None):
fileButton.val = colladaReg.get('path', '')
fileParts = []
filePath = "";
fileParts = fileButton.val.split("\\");
partCount = len(fileParts);
if partCount > 0 :
for i in range(partCount):
if i == 0:
filePath = fileParts[i];
else :
if i != partCount - 1:
filePath = filePath + "\\" + fileParts[i];
else:
filePath = filePath + "\\";
blenderFilename = Blender.Get('filename');
fileParts = []
fileParts = blenderFilename.split("\\");
partCount = len(fileParts);
if partCount > 0 :
blenderFileOnlyName = fileParts[partCount -1];
blenderFileOnlyName = blenderFileOnlyName.replace(".blend", ".dae");
filePath = filePath + blenderFileOnlyName;
else :
filePath = filePath + "untitled.dae";
if len(filePath) > 0 :
fileButton.val = filePath;
if doImport:
toggleOnlyMainScene.val = colladaReg.get('onlyMainScene', False)
toggleNewScene.val = colladaReg.get('newScene', False)
toggleClearScene.val = colladaReg.get('clearScene', False)
else:
##toggleLookAt.val = colladaReg.get('lookAt', False)
toggleBakeMatrix.val = colladaReg.get('bakeMatrices', False)
toggleTriangles.val = colladaReg.get('useTriangles', False)
togglePolygons.val = colladaReg.get('usePolygons', False)
toggleExportSelection.val = colladaReg.get('exportSelection', False)
togglePhysics.val = not colladaReg.get('usePhysics', True)
toggleExportCurrentScene.val = colladaReg.get('exportCurrentScene', False)
toggleExportRelativePaths.val = colladaReg.get('exportRelativePaths', True)
toggleSampleAnimation.val = colladaReg.get('sampleAnimation', False)
toggleUseUV.val = colladaReg.get('useUV', False)
#TODO: "toggleOnlyMainScene" left out intentionally by the original plugin author?
toggleApplyModifiers.val = colladaReg.get('applyModifiers', True)
valsLoaded = True
def load_sculptie(filename):
time1 = Blender.sys.time()
Blender.SaveUndoState("Import Sculptie")
#print "--------------------------------"
print 'Importing "%s"' % filename
scene = Blender.Scene.GetCurrent()
for ob in scene.objects.selected:
ob.sel = False
in_editmode = Blender.Window.EditMode()
# MUST leave edit mode before changing an active mesh:
if in_editmode:
Blender.Window.EditMode(0)
else:
try:
in_editmode = Blender.Get('add_editmode')
except:
pass
f, e = Blender.sys.splitext(filename)
e = e.lower()
if e == '.dae':
import_collada(filename)
elif e == '.obj':
import_obj(filename)
else:
try:
ob = sculpty.open(filename)
except:
Blender.Draw.PupBlock(
"Sculptie Import Error",
["Unsupported file type", "Use .dae or an image file"])
if in_editmode:
Blender.Window.EditMode(1)
Blender.Redraw()
print 'Loaded Sculptmap "%s" in %.4f sec.' % (filename,
(Blender.sys.time() - time1))
def bakeFrames(ob,myipo): #bakes an object in a scene, returning the IPO containing the curves
myipoName = myipo.getName()
debug(20,'Baking frames for scene %s object %s to ipo %s' % (scn.getName(),ob.getName(),myipoName))
ipos = getCurves(myipo)
#TODO: Gui setup idea: myOffset
# reset action to start at frame 1 or at location
myOffset=0 #=1-staframe
#loop through frames in the animation. Often, there is rollup and the mocap starts late
staframe,endframe,curframe = getRenderInfo()
for frame in range(staframe, endframe+1):
debug(80,'Baking Frame %i' % frame)
#tell Blender to advace to frame
Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
if not BATCH: Blender.Redraw() # no secrets, let user see what we are doing
#using the constrained Loc Rot of the object, set the location of the unconstrained clone. Yea! Clones are FreeMen
key = getLocRot(ob,usrCoord) #a key is a set of specifed exact channel values (LocRotScale) for a certain frame
key = [a+b for a,b in zip(key, usrDelta)] #offset to the new location
myframe= frame+myOffset
Blender.Set(CURFRAME,myframe)
time = Blender.Get('curtime') #for BezTriple
ipos = addPoint(time,key,ipos) #add this data at this time to the ipos
debug(100,'%s %i %.3f %.2f %.2f %.2f %.2f %.2f %.2f' % (myipoName, myframe, time, key[0], key[1], key[2], key[3], key[4], key[5]))
# eye-candy - smoothly rewind the animation, showing now how the clone match moves
if endframe-staframe <400 and not BATCH:
for frame in range (endframe,staframe,-1): #rewind
Blender.Set(CURFRAME,frame) # computes the constrained location of the 'real' objects
Blender.Redraw()
Blender.Set(CURFRAME,staframe)
Blender.Redraw()
return ipos
def tstMoveOb(ob): # makes a simple LocRot animation of object in the scene
anim = [
#Loc Rot/10
#
( 0,0,0, 0, 0, 0), #frame 1 origin
( 1,0,0, 0, 0, 0), #frame 2
( 1,1,0, 0, 0, 0),
( 1,1,1, 0, 0, 0),
( 1,1,1,4.5, 0, 0),
( 1,1,1,4.5,4.5, 0),
( 1,1,1,4.5,4.5,4.5)
]
space = COORD_LOCAL
ipo = createIpo(ob) #create an Ipo and curves for this object
ipos = getCurves(ipo)
# span this motion over the currently set anim range
# to set points, i need time but do not know how it is computed, so will have to advance the animation
staframe,endframe,curframe = getRenderInfo()
frame = staframe #x position of new ipo datapoint. set to staframe if you want a match
frameDelta=(endframe-staframe)/(len(anim)) #accomplish the animation in frame range
for key in anim: #effectively does a getLocRot()
#tell Blender to advace to frame
Blender.Set('curframe',frame) # computes the constrained location of the 'real' objects
time = Blender.Get('curtime')
ipos = addPoint(time,key,ipos) #add this data at this time to the ipos
debug(100,'%s %i %.3f %.2f %.2f %.2f %.2f %.2f %.2f' % (ipo.name, frame, time, key[0], key[1], key[2], key[3], key[4], key[5]))
frame += frameDelta
Blender.Set(CURFRAME,curframe) # reset back to where we started
return
def mdd_export_ui(filepath):
# Dont overwrite
if not BPyMessages.Warning_SaveOver(filepath):
return
scn = bpy.data.scenes.active
ob_act = scn.objects.active
if not ob_act or ob_act.type != 'Mesh':
BPyMessages.Error_NoMeshActive()
ctx = scn.getRenderingContext()
orig_frame = Blender.Get('curframe')
PREF_STARTFRAME = Blender.Draw.Create(int(ctx.startFrame()))
PREF_ENDFRAME = Blender.Draw.Create(int(ctx.endFrame()))
PREF_FPS = Blender.Draw.Create(ctx.fps)
block = [\
("Start Frame: ", PREF_STARTFRAME, 1, 30000, "Start Bake from what frame?: Default 1"),\
("End Frame: ", PREF_ENDFRAME, 1, 30000, "End Bake on what Frame?"),\
("FPS: ", PREF_FPS, 1, 100, "Frames per second")\
]
if not Blender.Draw.PupBlock("Export MDD", block):
return
PREF_STARTFRAME, PREF_ENDFRAME=\
min(PREF_STARTFRAME.val, PREF_ENDFRAME.val),\
max(PREF_STARTFRAME.val, PREF_ENDFRAME.val)
print(filepath, ob_act, PREF_STARTFRAME, PREF_ENDFRAME, PREF_FPS.val)
mdd_export(filepath, ob_act, PREF_STARTFRAME, PREF_ENDFRAME, PREF_FPS.val)
Blender.Set('curframe', orig_frame)
def mdd_import_ui(filepath):
if BPyMessages.Error_NoFile(filepath):
return
scn = Scene.GetCurrent()
ob_act = scn.objects.active
if ob_act == None or ob_act.type != 'Mesh':
BPyMessages.Error_NoMeshActive()
return
PREF_IPONAME = Blender.Draw.Create(
filepath.split('/')[-1].split('\\')[-1].split('.')[0])
PREF_START_FRAME = Blender.Draw.Create(1)
PREF_JUMP = Blender.Draw.Create(1)
block = [\
("Ipo Name: ", PREF_IPONAME, 0, 30, "Ipo name for the new shape key"),\
("Start Frame: ", PREF_START_FRAME, 1, 3000, "Start frame for the animation"),\
("Key Skip: ", PREF_JUMP, 1, 100, "KeyReduction, Skip every Nth Frame")\
]
if not Blender.Draw.PupBlock("Import MDD", block):
return
orig_frame = Blender.Get('curframe')
mdd_import(filepath, ob_act, PREF_IPONAME.val, PREF_START_FRAME.val,
PREF_JUMP.val)
Blender.Set('curframe', orig_frame)
def getImageSourcePath(source, filePath):
# Try and load our texture from 'filePath' (local .dae import path)
texturesDir = filePath + '/'
texturesDir = texturesDir.replace('\\', '/') # Bill Gates!!!
splitPath = source.split('/')
if (len(splitPath) > 0):
fileName = splitPath[len(splitPath) - 1]
mupp = texturesDir + fileName
if (Blender.sys.exists(mupp) == 1):
return mupp
# File does not exist to try and remove characters from string and see if file exists
source = source.replace('file://', '')
if (Blender.sys.exists(source) == 1):
return source
source = source.replace('file://.', '')
if (Blender.sys.exists(source) == 1):
return source
# File did not exists so try and load our texture from 'texturesdir'
texturesDir = Blender.Get('texturesdir')
texturesDir = texturesDir.replace('\\', '/') # Bill Gates!!!
splitPath = source.split('/')
if (len(splitPath) > 0):
fileName = splitPath[len(splitPath) - 1]
source = texturesDir + fileName
if (Blender.sys.exists(source) == 1):
return source
return None
def GetDefaultFilename():
filename = Blender.Get("filename")
filename = filename.replace(".blend", "")
filename += "." + GetExtension()
return filename
def getRenderInfo(): context=scn.getRenderingContext() staframe = context.startFrame() endframe = context.endFrame() if endframe<staframe: endframe=staframe curframe = Blender.Get(CURFRAME) debug(90,'Scene is on frame %i and frame range is %i to %i' % (curframe,staframe,endframe)) return (staframe,endframe,curframe)
def __init__(self, filename):
cursor = Blender.Window.GetCursorPos()
self.file = open(filename, "w")
self.write('<?xml version="1.0"?>\n')
self.write("<!-- project: %s -->\n" % Blender.Get("filename"))
self.write("<!-- cursor: %0.12f %0.12f %0.12f -->\n\n" % (cursor[0], cursor[1], cursor[2]))
self.write("<PropertyList>\n")
self.write("\t<path>%s.ac</path>\n\n" % BASENAME)
def InterfaceDraw():
Blender.BGL.glClear(Blender.BGL.GL_COLOR_BUFFER_BIT)
Blender.BGL.glEnable(Blender.BGL.GL_BLEND)
Blender.BGL.glBlendFunc(Blender.BGL.GL_SRC_ALPHA,
Blender.BGL.GL_ONE_MINUS_SRC_ALPHA)
UI[0] = Blender.Draw.String("Author's Name: ", EV_AUTHOR, 5, 25, 400, 20,
EXPORTS[0], 255,
"The author's name; goes into $MODEL.cfg.")
UI[1] = Blender.Draw.String("Prepend Name: ", EV_PREPEND, 5, 45, 400, 20,
EXPORTS[1], 255,
"Prepend all model files with this string.")
UI[2] = Blender.Draw.Toggle(
"Export OpenGL", EV_EXPORTGL, 5, 65, 140, 20, EXPORTS[2],
"Change the up direction to Y; useful for some engines.")
UI[3] = Blender.Draw.Toggle("Calculate LODS", EV_LOD, 5, 85, 140, 20,
EXPORTS[3],
"Calculate Cal3D Level Of Detail steps.")
UI[4] = Blender.Draw.Toggle("Extra Data", EV_EXTRADATA, 5, 105, 140, 20,
EXPORTS[4],
"Add date, time, etc. into $MODEL.cfg.")
UI[5] = Blender.Draw.Number(
"XML Indent: ", EV_XMLINDENT, 5, 125, 200, 20, EXPORTS[5], 0, 10,
"Use this level of indentation in the XML files.")
UI[6] = Blender.Draw.Number(
"Float Precision: ", EV_FLOATPRE, 5, 145, 200, 20, EXPORTS[6], 3, 20,
"Use this level of float/double precision (significant digits).")
UI[7] = Blender.Draw.Number("Animation FPS: ", EV_ANIMFPS, 5, 165, 200,
20, EXPORTS[7], 1, 100, "Frames Per Second")
UI[8] = Blender.Draw.PushButton(
"View Stats", EV_VIEW, 5, 5, 200, 20,
"View the objects and groups the exporter will be aware of.")
UI[9] = Blender.Draw.PushButton("Quit", EV_CANCEL, 205, 5, 100, 20,
"Oh nos!")
UI[10] = Blender.Draw.PushButton("WRITE", EV_WRITE, 305, 5, 100, 20,
"Weee!")
global IMAGE
if not IMAGE:
# Don't load the logo if used in non-GUI mode
IMAGE = Blender.Image.Load(
os.path.join(Blender.Get("scriptsdir"), "blendercal", "logo.png"))
# Blender.Draw.Image(IMAGE, 145, 65)
Blender.BGL.glDisable(Blender.BGL.GL_BLEND)
def GetAnim():
global metrices
global poses
print "Extracting animation data..."
crntFra = Blender.Get("curframe")
MoveToFrame(1)
pose_bone_names = obj.getPose().bones.keys()
for pb_nam in pose_bone_names: # for every pose bone
poses[pb_nam] = range(GetFramesNum())
matrices[pb_nam] = []
for f in range(GetFirstFrame(),
GetFramesNum() + 1): # for every frame of that bone
MoveToFrame(f)
pb = obj.getPose().bones[pb_nam]
found = 0
i = -1 # set it as -1 cause in case of not exec of the below for
for i in range(0, len(
matrices[pb_nam])): # for all matrices of tha bone
if IdenticalMatrices(matrices[pb_nam][i], pb.localMatrix) == 1:
found = 1
break
if not found:
ide_mat = NewMatrix()
# if the local matrix is the identity matrix then put -1 to save space
if IdenticalMatrices(pb.localMatrix, ide_mat):
i = -1
else:
tmp = NewMatrix()
CopyMatrix(pb.localMatrix, tmp)
matrices[pb_nam].append(tmp)
i = i + 1
poses[pb_nam][f - 1] = i
# } end for every frame
# now do a check
# check if the bone has moved at all
ide_mat = NewMatrix()
if len(matrices[pb_nam]) == 0:
del poses[pb_nam]
MoveToFrame(1)
# end for every bone
MoveToFrame(crntFra)
print "Done!\n"
return 1
def export(self, dir=None, file=None, copyTextures=False):
exportDir = dir or self.dir
exportFile = file or self.file
Log.getSingleton().logInfo("Exporting materials \"%s\"" % exportFile)
f = open(Blender.sys.join(exportDir, exportFile), "w")
if self.customMaterial :
# set of material import lines.
templateImportSet = set()
# map of template strings.
templateStringDict = {}
for material in self.materialsDict.values():
if isinstance(material, CustomMaterial):
try:
template = material.properties['template']
if type(template) is not str:
Log.getSingleton().logWarning("Material \"%s\" not assigned to a valid template!" % material.getName())
else:
if not(templateStringDict.has_key(template)) :
Log.getSingleton().logInfo("Loading template \"%s\"" % template)
templateFile = Blender.sys.join(self.customMaterialTplPath, template + '.tpl')
if not(Blender.sys.exists(templateFile) == 1):
Log.getSingleton().logWarning("Material \"%s\" assigned to unknown template \"%s\"!" % (material.getName(), template))
Log.getSingleton().logWarning("The template file \"%s\" does not exist." % templateFile)
templateStringDict[template] = ''
else:
t = open(templateFile, 'r')
templateImportSet.add(t.readline())
templateStringDict[template] = t.read()
t.close()
material.setupTemplate(templateStringDict[template])
except KeyError:
Log.getSingleton().logWarning("Material \"%s\" is not assigned to a template! It will not be exported!" % (material.getName()))
# write import lines.
for importString in templateImportSet:
f.write(importString)
for material in self.materialsDict.values():
material.write(f)
f.close()
if copyTextures and os.path.exists(dir):
baseDirname = os.path.dirname(Blender.Get("filename"))
for path in self.textureFilesDict.values():
# convert Blender's relative paths "//" to absolute path
if (path[0:2] == "//"):
Log.getSingleton().logInfo("Converting relative image name \"%s\"" % path)
path = os.path.join(baseDirname, path[2:])
if os.path.exists(path):
# copy texture to dir
Log.getSingleton().logInfo("Copying texture \"%s\"" % path)
try:
shutil.copy(path, dir)
except (IOError, OSError), detail:
Log.getSingleton().logError("Error copying \"%s\": %s" % (path, str(detail)))
else:
Log.getSingleton().logWarning("Can't copy texture \"%s\" because file does not exists!" % path)