Dimension-Seven

moritz · Spieler Anmeldedatum: 20.10.2006 Beiträge: 12

Gibt es hir jemanden der Python kann.
wenn ja ich hab da ein Problem mit einem Direkt X exporter für Blender.
Mein Problem ist immer wenn ich da mit ein Object mit Animation abspeichere und in Blitz Basic 3D versuche die Animation abzuspielen bewegt sich das Object nicht obwol mir angezeigt wird das die Animation läuft.
Wenn ich beim Export Script Speed einstelle dann erscheint in Blitz Basic 3D ganiks.
Also hir der Script

#!BPY

""" Registration info for Blender menus:
Name: '.x File Export (DirectX) for V2.42'
Blender: 242
Group: 'Export'
Tip: 'Export to DirectX text file format format.'
"""
__author__ = "Richard Kopelow"
#######__url__ = ("blender", "elysiun", "Author's site, http://www.omariben.too.it")
__version__ = "0.1 (beta)"

__bpydoc__ = """\
This script exports a Blender mesh with armature to DirectX 8's text file
format.

Notes:<br>
Richard Kopelow's modification of an exporter by Arben (Ben) Omari.
"""

#
# Author's Note:
#
# This is a rewrite of a great script by Arben (Ben) Omari that I just
# couldn't get to work...
#
# Actually it has worked and failed and I never knew which it would
# do next. The reason is that "things" just had to be right for it to work
# (i.e. you MUST have a 3d window open in order to export an animation.)
# The catch is - How the heck would you know that? So I'm building this
# knowlege into the script with some tests, lots of console messages, etc.
#
# My goal is that this script should export a valid, usable DirectX file
# ... or tell you why it won't!
#
# I hope that this makes the script easier to use and at least point the
# user in the right direction when something goes wrong.
#

#
# .x File Export (DirectX) for V2.42 version 0.1 (beta)
# Copyright (C) 2006 Richard Kopelow
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.

# This script exports meshes created with Blender in DirectX8 file format
# it exports meshes,armatures,materials,normals,texturecoords and animations

import Blender
from Blender import Types, Object, NMesh, Material,Armature,Mesh
from Blender.Mathutils import *
from Blender import Draw, BGL
from Blender.BGL import *
import math

print ".x File Export (DirectX) for V2.42 version 0.1 (beta) Envoked."

global mat_flip,index_list,space,bone_list,mat_dict
global anim,flip_norm,swap_zy,flip_z,speed,ticks,no_light,recalc_norm,Bl_norm
global expMeshCount, expArmCount, expMeshChildren, expLocation

expMeshCount = 0
expArmCount = 0
expMeshChildren = 0
expLocation = ""

# Change the following line to set a default result path...
#expLocation = "f:\\net documents\\"

bone_list =[]
index_list = []
mat_dict = {}
space = 0;flip_z = 1;anim=1;swap_yz=1;flip_norm=0;speed=1;ticks= 25
Bl_norm = 1;recalc_norm = 0;no_light = 0;exportScene=1;

toggle_val = 1
toggle1_val = 0
toggle2_val = 1
toggle3_val = 1
toggle4_val = 1
toggle5_val = 1
toggle6_val = 0
toggle7_val = 0
toggle13_val = 1
anim_tick = Draw.Create(25)

#init diag vars
initDiags="N"

#***********************************************
# MAIN
#***********************************************

def my_callback_sel(filename):
global exportScene

CheckRequest()
if not expOkay:
Draw.Redraw(1)
else:
if filename.find('.x', -2) <= 0: filename += '.x'
xexport = xExport(filename)
if exportScene==1:
print "Exporting Scene..."
xexport.ExportScene(analyzeScene())
else:
print "Exporting Selection..."
xexport.ExportScene(analyzeSceneSel())

def event(evt, val):
if evt == Draw.ESCKEY:
Draw.Exit()
return

def button_event(evt):
global toggle_val,toggle1_val,toggle2_val,toggle3_val,toggle4_val,toggle5_val,toggle6_val,toggle7_val,toggle13_val
global flip_z,swap_yz,flip_norm,anim,ticks,speed,no_light,Bl_norm,recalc_norm,exportScene,expLocation
arg = __script__['arg']
if evt == 1:
if Get3DWindowCount()>0:
toggle_val = 1 - toggle_val
else:
toggle_val = 0
anim = toggle_val
Draw.Redraw(1)
if evt == 2:
toggle1_val = 1 - toggle1_val
flip_norm = toggle1_val
Draw.Redraw(1)
if evt == 3:
toggle2_val = 1 - toggle2_val
swap_yz = toggle2_val
Draw.Redraw(1)
if evt == 4:
toggle3_val = 1 - toggle3_val
flip_z = toggle3_val
Draw.Redraw(1)
if evt == 5:
toggle4_val = 1 - toggle4_val
speed = toggle4_val
Draw.Redraw(1)
if evt == 10:
toggle5_val = 1 - toggle5_val
if toggle5_val==1:
toggle6_val = 0
toggle7_val = 0
else :
toggle6_val = 1
toggle7_val = 1
no_light = toggle7_val
recalc_norm = toggle6_val
Bl_norm = toggle5_val
Draw.Redraw(1)
if evt == 11:
toggle6_val = 1 - toggle6_val
if toggle6_val==1:
toggle5_val = 0
toggle7_val = 0
else :
toggle5_val = 1
toggle7_val = 1
no_light = toggle7_val
recalc_norm = toggle6_val
Bl_norm = toggle5_val
Draw.Redraw(1)
if evt == 12:
toggle7_val = 1 - toggle7_val
if toggle7_val==1:
toggle6_val = 0
toggle5_val = 0
else :
toggle6_val = 1
toggle5_val = 1
no_light = toggle7_val
recalc_norm = toggle6_val
Bl_norm = toggle5_val
Draw.Redraw(1)
if evt == 6:
ticks = anim_tick.val
if evt == 8:
fname = Blender.sys.makename(ext = ".x")
Blender.Window.FileSelector(my_callback_sel, "Export DirectX", expLocation+fname)
if evt == 9:
print "DirectX Exporter Exitting."
Draw.Exit()
if evt == 13:
toggle13_val = 1 - toggle13_val
exportScene = toggle13_val
Draw.Redraw(1)

def draw():
global animsg,flipmsg,swapmsg,anim_tick
global flip_z,swap_yz,flip_norm,anim,ticks,speed,recalc_norm,Bl_norm,no_light,exportScene
glClearColor(0.55,0.6,0.6,1)
glClear(BGL.GL_COLOR_BUFFER_BIT)
#external box
glColor3f(0.2,0.3,0.3)
rect(10,402,300,382)
#--
glColor3f(0.5,0.75,0.65)
rect(14,398,292,30)
#--
glColor3f(0.5,0.75,0.65)
rect(14,366,292,248)
#--
glColor3f(0.5,0.75,0.65)
rect(14,114,292,90)

#initial diags...
global initDiags

glColor3f(0.8,.8,0.6)
glRasterPos2i(20, 380)
Draw.Text(".x File Export (DirectX) ",'large')
Draw.Text("for Blender 2.42", 'small')
#-------Aniamtion toggle---------------------------------------------
if Get3DWindowCount()>0:
toggle_val = anim
if toggle_val :
anim = 1
animsg = "Export: " + GetAnimName()
else:
anim = 0
animsg = "animation will be not exported"
glRasterPos2i(100,335)
Draw.Text(animsg)
else:
anim = 0
toggle_val = 0
glColor3f(1,0,0)
animsg = "No 3D windows open."
glRasterPos2i(100,335)
Draw.Text(animsg)
glColor3f(0.8,.8,0.6)
Draw.Toggle("Anim", 1, 20, 330, 55, 20, toggle_val,"export animations")
#---Flip normals toggle-----------------------------------------------
Draw.Toggle("Flip norm", 2, 20, 300, 55, 20, toggle1_val,"invert normals")
if toggle1_val :
flip_norm = 1
flipmsg = "flipped normals"
else:
flip_norm = 0
flipmsg = "not flipped normals"
glRasterPos2i(100,305)
Draw.Text(flipmsg)
#------Swap yz toggle----------------------------------------------------------------
Draw.Toggle("Swap zy", 3, 20, 270, 55, 20, toggle2_val,"swap z,y axis(y up)")
if toggle2_val :
swap_yz = 1
swapmsg = "Y-axis up"
else:
swap_yz = 0
swapmsg = "Z-axis up"
glRasterPos2i(100,275)
Draw.Text(swapmsg)
#------Flip z toggle----------------------------------------------------------------
Draw.Toggle("Flip z", 4, 20, 240, 55, 20, toggle3_val,"flip z axis")
if toggle3_val :
flip_z = 1
zmsg = "left handed system"
else:
flip_z = 0
zmsg = "right handed system"
glRasterPos2i(100,245)
Draw.Text(zmsg)
#------Speed toggle----------------------------------------------------------------
Draw.Toggle("Speed", 5, 20, 210, 55, 20, toggle4_val,"Animation speed")
if toggle4_val :
speed = 1
spedmsg = "set speed"
anim_tick = Draw.Number("", 6,200, 210, 85, 20, anim_tick.val,1,100000,"ticks per second")
else:
speed = 0
spedmsg = ""
glRasterPos2i(100,215)
Draw.Text(spedmsg)
#------Blender Normals toggle----------------------------------------------------------------
Draw.Toggle("Bl.normals", 10, 20, 125, 75, 25, toggle5_val,"export normals as in Blender")
if toggle5_val :
Bl_norm = 1
#------Recalculute Normals toggle----------------------------------------------------------------
Draw.Toggle("recalc.no", 11, 120, 125, 75, 25, toggle6_val,"export recalculated normals")
if toggle6_val :
recalc_norm = 1
#------Recalculute Normals toggle----------------------------------------------------------------
Draw.Toggle("no smooth", 12, 220, 125, 75, 25, toggle7_val,"every vertex has the face normal,no smoothing")
if toggle7_val :
no_light = 1

#------Target Selection toggle----------------------------------------------------------------
if toggle13_val :
Draw.Toggle("Scene", 13, 20, 180, 55, 20, toggle13_val,"What should be Exported?")
exportScenemsg = "Export entire scene."
exportScene = 1
else :
Draw.Toggle("Selected", 13, 20, 180, 55, 20, toggle13_val,"What should be Exported?")
exportScenemsg = "Export selected objects."
exportScene = 0
glRasterPos2i(100,185)
Draw.Text(exportScenemsg)

#------Draw Button export----------------------------------------------------------------

if exportScene==1:
analyzeScene()
else:
analyzeSceneSel()
CheckRequest()
if expOkay:
go_butt = Draw.Button("Go!",8,220, 70, 75, 30, "Go for it!")
glColor3f(1,0,0)
glRasterPos2i(20,95)
Draw.Text(expWarning)
glColor3f(0.8,.8,0.6)

exit_butt = Draw.Button("Exit",9,220, 30, 75, 30, "exit")
glRasterPos2i(20,75)
glRasterPos2i(20,55)
Draw.Text("Contact: rakar on ")
glRasterPos2i(20,35)
Draw.Text("http://blenderartists.org/forum/")

def rect(x,y,width,height):
glBegin(GL_LINE_LOOP)
glVertex2i(x,y)
glVertex2i(x+width,y)
glVertex2i(x+width,y-height)
glVertex2i(x,y-height)
glEnd()

def rectFill(x,y,width,height):
glBegin(GL_POLYGON)
glVertex2i(x,y)
glVertex2i(x+width,y)
glVertex2i(x+width,y-height)
glVertex2i(x,y-height)
glEnd()

Draw.Register(draw, event, button_event)

#########################################
# GUI helpers... #
#########################################

def Get3DWindowCount():

scrInfoList = Blender.Window.GetScreenInfo(Blender.Window.Types.VIEW3D,'win','')
diag3DWindowCount = 0
for scrDict in scrInfoList:
diag3DWindowCount = diag3DWindowCount + 1

return diag3DWindowCount

def GetAnimName():
try:
return Blender.Scene.GetCurrent().getChildren()[0].getAction().getName()
except:
return ""

def CheckRequest():
global expMeshCount, expArmCount, expMeshChildren, anim
global expOkay, expWarning

expOkay = 1
expWarning = ""

if anim==1 and expMeshCount>1:
expOkay = 0
expWarning = "Can't export animation and multiple meshes."
elif anim==1 and expMeshCount>0 and expArmCount>0:
expOkay = 0
expWarning = "Can't export animation and multiple hierarchies."
elif anim==1 and expArmCount>1:
expOkay = 0
expWarning = "Can't export animation and multiple hierarchies."
elif expMeshCount==0 and expArmCount==0:
expOkay = 0
expWarning = "Nothing to export."
elif expMeshChildren>0:
expOkay = 0
expWarning = "Can't export meshes with child meshes."

#***********************************************
#Select Scene objects
#***********************************************
def analyzeScene():
global expMeshCount, expArmCount, expMeshChildren
expMeshCount = 0
expArmCount = 0
parent_list = []
for obj in Blender.Scene.GetCurrent().getChildren(): #Object.Get():
mesh = obj.getData()
if type(mesh) == Types.ArmatureType or type(mesh) == Types.NMeshType or obj.getType() == "Empty":
pare = obj.getParent()
if pare == None :
parent_list.append(obj)
AccumExpTypes(mesh)
CountMeshesChildrenOfMeshes(parent_list)
return parent_list

def analyzeSceneSel():
global expMeshCount, expArmCount, expMeshChildren
global exclude_list

expMeshCount = 0
expArmCount = 0
parent_list = []
exclude_list = []

obj_list = Object.GetSelected()
for obj in obj_list:
child_list = getChildren(obj)
GenExclusionList(child_list)
for obj in obj_list:
mesh = obj.getData()
if type(mesh) == Types.ArmatureType or type(mesh) == Types.NMeshType or obj.getType() == "Empty":
pare = obj.getParent()
if not obj in exclude_list:
parent_list.append(obj)
AccumExpTypes(mesh)

CountMeshesChildrenOfMeshes(parent_list)
return parent_list

def CountMeshesChildrenOfMeshes(obj_list):
global expMeshChildren
expMeshChildren = 0
for obj in obj_list:
CountMeshesChildrenOfMesh(obj)

def CountMeshesChildrenOfMesh(obj):
global expMeshChildren
mesh = obj.getData()
if type(mesh) ==Types.ArmatureType or type(mesh) == Types.NMeshType:
for cobj in getChildren(obj):
cmesh = cobj.getData()
if type(mesh) == Types.NMeshType and type(cmesh) ==Types.NMeshType:
expMeshChildren += 1
CountMeshesChildrenOfMesh(cobj)

def AccumExpTypes(item):
global expMeshCount, expArmCount
if type(item) == Types.ArmatureType:
expArmCount += 1
elif type(item) == Types.NMeshType:
expMeshCount += 1

def GenExclusionList(obj_list):
global exclude_list
for obj in obj_list:
if not obj in exclude_list:
exclude_list.append(obj)
GenExclusionList(getChildren(obj))

def getChildren(obj):
children_list = []
for object in Blender.Scene.GetCurrent().getChildren(): #Object.Get():
pare = object.parent
if pare == obj :
children_list.append(object)
return children_list

#***********************************************
#***********************************************
# EXPORTER
#***********************************************
#***********************************************

class xExport:
def __init__(self, filename):
self.file = open(filename, "w")

#*********************************************************************************************************************************************
#*********************************************************************************************************************************************
#** start with one of the following routines... *****
#*********************************************************************************************************************************************
#*********************************************************************************************************************************************

def ExportScene(self, obj_list):
global space,chld_obj,ch_list,flip_z,swap_yz,speed
#print "exporting..."
in_editmode = Blender.Window.EditMode()
if in_editmode: Blender.Window.EditMode(0)
self.writeHeader()
self.writeRootFrame()
#obj_list = self.analyzeScene()
space += 1
ch_list = []
for obj in obj_list:
self.writeObjFrames(obj)
ch_l = getChildren(obj)
for ch in ch_l:
if ch and ch.getType() == "Armature":
ch_list.append(ch)
self.writeObjFrames(ch)
else :
self.writeChildObj(ch_l)
if obj.getType() != "Armature":
self.file.write(" } // SI End of the Object %s \n" % (obj.name))

self.file.write("} // End of the Root Frame\n")

if anim :
self.ExportAnimation(obj_list)

self.writeEnd()
Blender.Window.EditMode(in_editmode)
print "Export finished."

def ExportAnimation(self,obj_list):
for actionName, actionObj in Blender.Armature.NLA.GetActions().iteritems():
gotOne = "N"
for obj in obj_list:
mesh = obj.getData()
if type(mesh) == Types.NMeshType or obj.getType() == "Empty":
ip_list = obj.getIpo()
if ip_list != None :
if gotOne=="N":
gotOne="Y"
self.file.write("AnimationSet %s {\n" % actionName)
self.writeAnimationObj(obj)
elif type(mesh) == Types.ArmatureType :
if gotOne=="N":
gotOne="Y"
self.file.write("AnimationSet %s {\n" % actionName)
self.writeAnimation(obj,actionObj)

if gotOne=="Y":
self.file.write("} // End of Animation Set\n")

#*********************************************************************************************************************************************
#*********************************************************************************************************************************************
#*********************************************************************************************************************************************
#*********************************************************************************************************************************************
#*********************************************************************************************************************************************
#*********************************************************************************************************************************************

def getArmChildren(self,obj):
for object in Blender.Scene.GetCurrent().getChildren():
pare = object.parent
if pare == obj :
return object

def getLocMat(self, obj):
pare = obj.getParent()
mat = obj.matrixWorld
mat_id = Matrix([1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1])
if pare:
mat_p = pare.matrixWorld
mat_c = Matrix(mat_p)
mat_c.invert()
mat_f = mat * mat_c
else :
mat_id.invert()
mat_f = mat * mat_id
return mat_f

def writeObjFrames(self,obj):
global space,chld_obj,ch_list
mesh = obj.getData()
if obj.getType() == "Empty" :
mat = self.getLocMat(obj)
mat_c = Matrix(mat)
name = obj.name
name_f = name.replace(".","")
self.writeArmFrames(mat_c, name_f)
if type(mesh) == Types.ArmatureType :
Child_obj = self.getArmChildren(obj)
chk = Child_obj.getData()
chld_obj = obj
ch_list.append(Child_obj)
self.writeRootBone(obj, Child_obj)
if type(mesh) == Types.NMeshType and obj not in ch_list:
self.exportMesh(obj)

def writeChildObj(self,obj):
global space,ch_list
space += 1
if obj :
for ob in obj:
if ob not in ch_list:
self.writeObjFrames(ob)
ch_list.append(ob)
ch_ob = getChildren(ob)
self.writeChildObj(ch_ob)
self.closeBrackets()
self.file.write(" // End of the Object %s \n" % (ob.name))

def writeRootFrame(self):
global flip_z,swap_yz,speed
if speed:
self.writeAnimTicks()
if flip_z:
mat_flip = Matrix([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, -1, 0], [0, 0, 0, 1])
else :
mat_flip = Matrix([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1])
if swap_yz :
mat_rot = RotationMatrix(-90, 4, 'x')
mat_flip = mat_rot * mat_flip
self.writeArmFrames(mat_flip, "RootFrame")

def writeAnimTicks(self):
global ticks
self.file.write("AnimTicksPerSecond {\n")
self.file.write("%d; \n" % (ticks))
self.file.write("}\n")

#***********************************************
#Export Mesh without Armature
#***********************************************
def exportMesh(self, obj):
tex = []
mesh = obj.getData()
self.writeTextures(obj, tex)
self.writeMeshcoordArm(obj, arm_ob = None)
self.writeMeshMaterialList(obj, mesh, tex)
self.writeMeshNormals(obj, mesh)
self.writeMeshTextureCoords(obj, mesh)
self.file.write(" } // End of the Frame %s \n" % (obj.name))

#***********************************************
#Export Mesh with Armature
#***********************************************
def exportMeshArm(self,arm,arm_ob,ch_obj):
tex = []
mesh = ch_obj.getData()
self.writeTextures(ch_obj, tex)
self.writeMeshcoordArm(ch_obj ,arm_ob)
self.writeMeshMaterialList(ch_obj, mesh, tex)
self.writeMeshNormals(ch_obj, mesh)
self.writeMeshTextureCoords(ch_obj, mesh)
self.writeSkinWeights(arm,mesh)
#self.file.write(" } // End of the Frame %s \n" % (ch_obj.name))
self.file.write(" } // End of the Object %s \n" % (ch_obj.name))

#***********************************************
#Export Root Bone
#***********************************************
def writeRootBone(self, chld_obj, child_obj):
global space,root_bon
arms = chld_obj.getData()
mat_arm = self.getLocMat(chld_obj)
for bon in arms.bones.values():
if bon.hasParent():
pass
else:
root_bon = bon
space += 1
mat_r = self.GetAnimCombineMatrix(chld_obj,root_bon,1)
name_r = root_bon.name
name_f = name_r.replace(".","")
self.writeArmFrames(mat_r, name_f)
bon_c = root_bon.children
#print "Bone has %d children" % len(root_bon.children)
self.writeChildren(chld_obj, bon_c)
self.file.write(" } // End of the Bone %s \n" % (root_bon.name))
self.exportMeshArm(arms, chld_obj ,child_obj)

#***********************************************
#Create Children structure
#***********************************************
def writeBon(self,chld_obj,bon):
global space
mat_r = self.GetAnimCombineMatrix(chld_obj,bon,1)
name_r = bon.name
name_f = name_r.replace(".","")
self.writeArmFrames(mat_r, name_f)

def writeChildren(self,chld_obj,bon_c):
global space,bone_list
space += 1
if len(bon_c)>0:
for bo in bon_c:
if 1==1: #bo.name not in bone_list:
self.writeBon(chld_obj, bo)
bone_list.append(bo.name)
if bo.hasChildren():
bo_c = bo.children
self.writeChildren(chld_obj,bo_c)
self.closeBrackets()

def closeBrackets(self):
global space
space = space-1
tab = " "
self.file.write("%s" % (tab * space))
self.file.write("}\n")

#***********************************************
#Offset Matrix
#***********************************************
def writeMatrixOffset(self,bon):
global chld_obj
Blender.Set('curframe', 1)
pose = chld_obj.getPose()
pos_b = pose.bones[bon.name]
mat_b = pos_b.poseMatrix
mat_c = Matrix(mat_b)
mat_c.invert()
return mat_c

#***********************************************
#Combine Matrix
#***********************************************
def writeCombineMatrix(self,bon):
global chld_obj

Blender.Set('curframe', 1)
pose = chld_obj.getPose()
pos_b = pose.bones[bon.name]
mat_b = pos_b.poseMatrix
if bon.hasParent():
pare = bon.parent
pos_p = pose.bones[pare.name]
mat_p = pos_p.poseMatrix

else:
mat_p = Matrix([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1])
mat_c = Matrix(mat_p)
mat_c.invert()
mat_f = mat_b * mat_c

return mat_f
#*********************************************************************************************************************************************
#***********************************************
#Write SkinWeights
#***********************************************
def writeSkinWeights(self, arm, mesh):
global index_list
v_dict = {}
Blender.Set('curframe',1)
self.file.write(" XSkinMeshHeader {\n")
max_infl = 0
for bo in arm.bones.values() :
name = bo.name
try :
vertx_list = mesh.getVertsFromGroup(name,1)
for inde in vertx_list :
vert_infl = mesh.getVertexInfluences(inde[0])
ln_infl = len(vert_infl)
if ln_infl > max_infl :
max_infl = ln_infl

except:
pass

self.file.write(" %d; \n" % (max_infl))
self.file.write(" %d; \n" % (max_infl * 3))
self.file.write(" %d; \n" % (len(mesh.getVertGroupNames()))) #(len(arm.bones.values())))
self.file.write(" }\n")

for bo in arm.bones.values() :
bo_list = []
weight_list = []
name = bo.name
f_name = name.replace(".","")
try :
vert_list = mesh.getVertsFromGroup(name,1)
le = 0
for indx in vert_list:
ver_infl = mesh.getVertexInfluences(indx[0])
infl = 0.0
if len(ver_infl) != 0:
sum = 0.0
for bone_n, weight in ver_infl:
if bone_n == name:
infl = weight
sum += weight
infl /= sum

i = -1
for el in index_list :
i += 1
if el == indx[0] :
le +=1
bo_list.append(i)
weight_list.append(infl)

self.file.write(" SkinWeights {\n")
self.file.write(' "%s"; \n' % (f_name))
self.file.write(' %d; \n' % (le))
count = 0
for ind in bo_list :
count += 1
if count == len(bo_list):
self.file.write(" %d; \n" % (ind))
else :
self.file.write(" %d, \n" % (ind))
cou = 0
for wegh in weight_list :
cou += 1

if cou == len(weight_list):
self.file.write(" %f; \n" % (round(wegh,6)))
else :
self.file.write(" %f, \n" % (round(wegh,6)))

matx = self.writeMatrixOffset(bo)
self.writeOffsFrames(matx, name)
except :
pass
self.file.write(" } // End of XSkinMeshHeader\n")

#***********************************************
# Write Matrices
#***********************************************
def writeArmFrames(self, matx, name):
global space
tab = " "
self.file.write("%s" % (tab * space))
self.file.write("Frame ")
self.file.write("%s {\n\n" % (name))
self.file.write("%s" % (tab * space))
self.file.write(" FrameTransformMatrix {\n")
#self.writeFrame(matx)
self.WriteMatrix(matx,space)
self.file.write(" }\n")

#***********************************************
# Write Frames
#***********************************************
def writeOffsFrames(self, matx, name):
space = 1
#self.writeFrame(matx)
self.WriteMatrix(matx,space)
self.file.write(" }\n")

#*********************************************************************************************************************************************

#***********************************************
#HEADER
#***********************************************
def writeHeader(self):
self.file.write("xof 0303txt 0032\n\n\n")
self.file.write("template VertexDuplicationIndices { \n\
<b8d65549-d7c9-4995-89cf-53a9a8b031e3>\n\
DWORD nIndices;\n\
DWORD nOriginalVertices;\n\
array DWORD indices[nIndices];\n\
}\n\
template XSkinMeshHeader {\n\
<3cf169ce-ff7c-44ab-93c0-f78f62d172e2>\n\
WORD nMaxSkinWeightsPerVertex;\n\
WORD nMaxSkinWeightsPerFace;\n\
WORD nBones;\n\
}\n\
template SkinWeights {\n\
<6f0d123b-bad2-4167-a0d0-80224f25fabb>\n\
STRING transformNodeName;\n\
DWORD nWeights;\n\
array DWORD vertexIndices[nWeights];\n\
array float weights[nWeights];\n\
Matrix4x4 matrixOffset;\n\
}\n\n")

#***********************************************
#CLOSE FILE
#***********************************************
def writeEnd(self):
self.file.close()
print "File closed."

#***********************************************
#EXPORT TEXTURES
#***********************************************
def writeTextures(self,name, tex):
mesh = name.data
for face in mesh.faces:
if face.image and face.image.name not in tex:
tex.append(face.image.name)

#***********************************************
#EXPORT MESH DATA with Armature
#***********************************************
def writeMeshcoordArm(self, obj ,arm_ob):
global index_list,flip_z
index_list=[]
#TransformMatrix
mat = self.getLocMat(obj)
name_f = obj.name.replace(".","")
name_f = name_f.replace(" ","")
self.writeArmFrames(mat, name_f)
mesh = NMesh.GetRawFromObject(obj.name)
self.file.write("Mesh {\n")
numface=len(mesh.faces)
#VERTICES NUMBER
numvert = 0
for face in mesh.faces:
numvert = numvert + len(face.v)
#print "Diag: numvert=%d " % numvert
#print "Diag: mesh.verts=%d" % len(mesh.verts)
#print "Diag: idx check: %d" % mesh.verts[0].index
self.file.write("%d;\n" % (numvert))
if numvert == 0:
print "Mesh named",mesh.name,"has no vertices.Problems may occur using the .x file"
#VERTICES COORDINATES
counter = 0
for face in mesh.faces:
counter += 1
for n in range(len(face.v)):
index_list.append(face.v[n].index)
vec_vert = Vector([(face.v[n].co[0]), face.v[n].co[1], face.v[n].co[2], 1])
if arm_ob :
f_vec_vert = vec_vert * mat
else :
f_vec_vert = vec_vert
self.file.write("%f; %f; %f;" % (round(f_vec_vert[0],4), round(f_vec_vert[1],4), round(f_vec_vert[2],4)))
if counter == numface :
if n == len(face.v)-1 :
self.file.write(";\n")
else :
self.file.write(",\n")
else :
self.file.write(",\n")
if flip_z:
a3 = 0;b3 = 2;c3 = 1
a4 = 0;b4 = 3;c4 = 2;d4 = 1
else:
a3 = 0;b3 = 1;c3 = 2
a4 = 0;b4 = 1;c4 = 2;d4 = 3

#FACES NUMBER
self.file.write("%s;\n" % (numface))
coun,counter = 0, 0
for face in mesh.faces :
coun += 1
if coun == numface:
if len(face.v) == 3:
self.file.write("3; %d, %d, %d;;\n" % (counter + a3, counter + b3, counter + c3))
counter += 3
elif len(face.v) == 4:
self.file.write("4; %d, %d, %d, %d;;\n" % (counter + a4, counter + b4, counter + c4, counter + d4))
counter += 4
elif len(face.v) < 3:
print "WARNING:the mesh has faces with less then 3 vertices"
print " It my be not exported correctly."
else:

if len(face.v) == 3:
self.file.write("3; %d, %d, %d;,\n" % (counter + a3, counter + b3, counter + c3))
counter += 3
elif len(face.v) == 4:
self.file.write("4; %d, %d, %d, %d;,\n" % (counter + a4, counter + b4, counter + c4, counter + d4))
counter += 4
elif len(face.v) < 3:
print "WARNING:the mesh has faces with less then 3 vertices"
print " It my be not exported correctly."

#***********************************************
#MESH MATERIAL LIST
#***********************************************
def writeMeshMaterialList(self, obj, mesh, tex):
self.file.write(" MeshMaterialList {\n")
#HOW MANY MATERIALS ARE USED
count = 0
for mat in mesh.getMaterials():
count+=1
self.file.write(" %d;\n" % (len(tex) + count))
#HOW MANY FACES IT HAS
numfaces=len(mesh.faces)
self.file.write(" %d;\n" % (numfaces))
##MATERIALS INDEX FOR EVERY FACE
counter = 0
for face in mesh.faces :
counter += 1
mater = face.materialIndex
if counter == numfaces:
if face.image and face.image.name in tex :
self.file.write(" %d;;\n" % (tex.index(face.image.name) + count))
else :
self.file.write(" %d;;\n" % (mater))
else :
if face.image and face.image.name in tex :
self.file.write(" %d,\n" % (tex.index(face.image.name) + count))
else :
self.file.write(" %d,\n" % (mater))

##MATERIAL NAME
for mat in mesh.getMaterials():
self.file.write(" Material")
name_m = mat.name
name_f = name_m.replace(".","")
self.file.write(" %s "% (name_f))
self.file.write("{\n")
self.file.write(" %f; %f; %f;" % (mat.R, mat.G, mat.B))
self.file.write("%s;;\n" % (mat.alpha))
self.file.write(" %f;\n" % (mat.spec))
self.file.write(" %f; %f; %f;;\n" % (mat.specR, mat.specG, mat.specB))
self.file.write(" 0.0; 0.0; 0.0;;\n")
self.file.write(" } //End of Material\n")

for mat in tex:
self.file.write(" Material Mat")
self.file.write("%s "% (len(tex)))
self.file.write("{\n")
self.file.write(" 1.0; 1.0; 1.0; 1.0;;\n")
self.file.write(" 1.0;\n")
self.file.write(" 1.0; 1.0; 1.0;;\n")
self.file.write(" 0.0; 0.0; 0.0;;\n")
self.file.write(" TextureFilename {")
self.file.write(' "%s";'% (mat))
self.file.write(" }\n")
self.file.write(" } // End of Material\n")
self.file.write(" } //End of MeshMaterialList\n")

#***********************************************
#MESH NORMALS
#***********************************************
def writeMeshNormals(self,name,mesh):
global flip_norm,flip_z,no_light,recalc_norm,Bl_norm

self.file.write(" MeshNormals {\n")
#VERTICES NUMBER
numvert = 0
for face in mesh.faces:
numvert = numvert + len(face.v)
self.file.write("%d;\n" % (numvert))
numfaces=len(mesh.faces)
if flip_norm :
fl = -1
else :
fl = 1
#VERTICES NORMAL
if Bl_norm:
self.writeBlenderNormals(mesh,fl)
if recalc_norm:
self.writeRecalcNormals(mesh,fl)
if no_light:
self.writeNoSmothing(mesh,fl)

if flip_z:
a3 = 0;b3 = 2;c3 = 1
a4 = 0;b4 = 3;c4 = 2;d4 = 1
else:
a3 = 0;b3 = 1;c3 = 2
a4 = 0;b4 = 1;c4 = 2;d4 = 3

#FACES NUMBER
self.file.write("%s;\n" % (numfaces))
coun,counter = 0, 0
for face in mesh.faces :
coun += 1
if coun == numfaces:
if len(face.v) == 3:
self.file.write("3; %d, %d, %d;;\n" % (counter + a3, counter + b3, counter + c3))
counter += 3
else :
self.file.write("4; %d, %d, %d, %d;;\n" % (counter + a4, counter + b4, counter + c4, counter + d4))
counter += 4
else:

if len(face.v) == 3:
self.file.write("3; %d, %d, %d;,\n" % (counter + a3, counter + b3, counter + c3))
counter += 3
else :
self.file.write("4; %d, %d, %d, %d;,\n" % (counter + a4, counter + b4, counter + c4, counter + d4))
counter += 4
self.file.write("} //End of MeshNormals\n")

def writeBlenderNormals(self,mesh,fl):
numfaces=len(mesh.faces)
#VERTICES NORMAL
counter = 0
for face in mesh.faces:
counter += 1
for n in range(len(face.v)):
self.file.write(" %f; %f; %f;" % (
(round(face.v[n].no[0],6)*fl),(round(face.v[n].no[1],6)*fl),(round(face.v[n].no[2],6)*fl)))
if counter == numfaces :
if n == len(face.v)-1 :
self.file.write(";\n")
else :
self.file.write(",\n")
else :
self.file.write(",\n")

def writeRecalcNormals(self,mesh,fl):
numfaces=len(mesh.faces)
normal_list = {}
idx = 0
for vertex in mesh.verts:
v_norm = Vector([0, 0, 0])
normal_list[idx] = v_norm
idx += 1
for face in mesh.faces:
for verts in face.v:
if verts.index == vertex.index :
v_norm[0] += face.no[0]
v_norm[1] += face.no[1]
v_norm[2] += face.no[2]

v_norm.normalize()

counter = 0
for face in mesh.faces:
counter += 1
n = 0
for vert in face.v:
n += 1
norm = normal_list[vert.index]

self.file.write(" %f; %f; %f;" % (
(round(norm[0],6)*fl),(round(norm[1],6)*fl),(round(norm[2],6)*fl)))
if counter == numfaces :
if n == len(face.v) :
self.file.write(";\n")
else :
self.file.write(",\n")
else :
self.file.write(",\n")

def writeNoSmothing(self,mesh,fl):
numfaces=len(mesh.faces)
counter = 0
for face in mesh.faces:
counter += 1
n = 0
for n in range(len(face.v)):
n += 1
self.file.write(" %f; %f; %f;" % (
(round(face.no[0],6)*fl),(round(face.no[1],6)*fl),(round(face.no[2],6)*fl)))

if counter == numfaces :
if n == len(face.v) :
self.file.write(";\n")
else :
self.file.write(",\n")
else :
self.file.write(",\n")
#***********************************************
#MESH TEXTURE COORDS
#***********************************************
def writeMeshTextureCoords(self, name, mesh):
if mesh.hasFaceUV():
self.file.write("MeshTextureCoords {\n")
#VERTICES NUMBER
numvert = 0
for face in mesh.faces:
numvert += len(face.v)
self.file.write("%d;\n" % (numvert))
#UV COORDS
numfaces = len(mesh.faces)
counter = -1
co = 0
for face in mesh.faces:
counter += 1
co += 1
for n in range(len(face.v)):
self.file.write("%f;%f;" % (mesh.faces[counter].uv[n][0], -mesh.faces[counter].uv[n][1]))
if co == numfaces :
if n == len(face.v) - 1 :
self.file.write(";\n")
else :
self.file.write(",\n")
else :
self.file.write(",\n")

self.file.write("} //End of MeshTextureCoords\n")
#***********************************************#***********************************************#***********************************************

#***********************************************
#WRITE ANIMATION KEYS
#***********************************************
def writeAnimation(self,arm_ob,act_list):
global mat_dict, root_bon
print "Diag: Writing Animation Keys - Method 1"
act_list.setActive(arm_ob)
arm = arm_ob.getData()
print "Diag: Current Action: " + act_list.getName()
ip = act_list.getAllChannelIpos()
for bon in arm.bones.values() :
name = bon.name
print "Diag: Exporting Bone: "+name
name_f = name.replace(".", "")

point_list = self.getKeyFramePoints(act_list, bon)

if len(point_list)>0: #ip.has_key(bon.name):
self.file.write(" Animation { \n")
self.file.write(" { %s }\n" %(name_f))
self.file.write(" AnimationKey { \n")
self.file.write(" 4;\n")
self.file.write(" %d; \n" % (len(point_list)))

for fr in point_list:
#print "Diag: Point: %d" % fr

if name == root_bon.name :

#print "Diag: Root Bone."
mat_b = self.GetAnimCombineMatrix(arm_ob,bon,fr)
mat_arm = self.getLocMat(arm_ob)
mat = mat_b * mat_arm
else:
#print "Diag: Child Bone."
mat = self.GetAnimCombineMatrix(arm_ob,bon,fr)

self.file.write(" %d;" % (fr))
self.file.write("16;")

#self.writeFrames(mat)
self.WriteMatrixWide(mat,0)

if fr == point_list[len(point_list)-1]:
self.file.write(";\n")
else:
self.file.write(",\n")
self.file.write(" }\n")
self.file.write(" }\n")
self.file.write("\n")

#***********************************************
#Combine Matrix
#***********************************************
def GetAnimCombineMatrix(self,arm_ob,bon,fre):
global chld_obj
arm_ob.evaluatePose(fre)
pose = chld_obj.getPose()
#print "Diag: BoneMatrix of? " + bon.name
pos_b = pose.bones[bon.name]
mat_b = pos_b.poseMatrix
if bon.hasParent():
pare = bon.parent
pos_p = pose.bones[pare.name]
mat_p = pos_p.poseMatrix

else:
mat_p = Matrix([1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1])
mat_c = Matrix(mat_p)
mat_c.invert()
mat_f = mat_b * mat_c

return mat_f

#***********************************************
#WRITE ANIMATION KEYS
#***********************************************
def writeAnimationObj(self, obj):
print "Diag: Writing Animation Keys - Method 2"
point_list = []
ip = obj.getIpo()
poi = ip.getCurves()
for po in poi[0].getPoints():
a = po.getPoints()
point_list.append(int(a[0]))

name = obj.name
name_f = name.replace(".", "")
self.file.write(" Animation {\n")
self.file.write(" { ")
self.file.write("%s }\n" % (name_f))
self.file.write(" AnimationKey { \n")
self.file.write(" 4;\n")
self.file.write(" %d; \n" % (len(point_list)))
for fr in point_list:
self.file.write(" %d;" % (fr))
self.file.write("16;")
Blender.Set('curframe',fr)

mat_new = obj.matrixLocal
self.WriteMatrixWide(mat_new,0)

if fr == point_list[len(point_list)-1]:
self.file.write(";\n")
else:
self.file.write(",\n")
self.file.write(" }\n")
self.file.write(" }\n")

#***********************************************
# Blender Utility...
#***********************************************

#***********************************************
# Get Keyframe Points
# (for a specific action and bone)
#***********************************************
def getKeyFramePoints(self,action, bon):
point_list = []
ip = action.getAllChannelIpos()
if ip.has_key(bon.name):
ip_bon_channel = ip[bon.name]
ip_bon_name = ip_bon_channel.getName()
print "Diag: Extracting Keyframe Points IP Bone Name: "+ ip_bon_name
ip_bon = Blender.Ipo.Get(ip_bon_name)
poi = ip_bon.getCurves()
for po in poi[3].getPoints():
a = po.getPoints()
print "Diag: Keyframe Points: %d" % int(a[0])
point_list.append(int(a[0]))
return point_list

#***********************************************
# File Utility...
#***********************************************

#***********************************************
# Write Matrix Wide
#***********************************************
def WriteMatrixWide(self, matx, space):

tab = " "
self.file.write("%s" % (tab * space))
self.file.write("%f,%f,%f,%f," %
(round(matx[0][0],4),round(matx[0][1],4),round(matx[0][2],4),round(matx[0][3],4)))
self.file.write("%f,%f,%f,%f," %
(round(matx[1][0],4),round(matx[1][1],4),round(matx[1][2],4),round(matx[1][3],4)))
self.file.write("%f,%f,%f,%f," %
(round(matx[2][0],4),round(matx[2][1],4),round(matx[2][2],4),round(matx[2][3],4)))
self.file.write("%f,%f,%f,%f;;" %
(round(matx[3][0],4),round(matx[3][1],4),round(matx[3][2],4),round(matx[3][3],4)))

#***********************************************
# Write Matrix
#***********************************************
#def writeFrame(self, matx):
def WriteMatrix(self, matx, space):

tab = " "
self.file.write("%s" % (tab * space))
self.file.write(" %f,%f,%f,%f,\n" %
(round(matx[0][0],4),round(matx[0][1],4),round(matx[0][2],4),round(matx[0][3],4)))
self.file.write("%s" % (tab * space))
self.file.write(" %f,%f,%f,%f,\n" %
(round(matx[1][0],4),round(matx[1][1],4),round(matx[1][2],4),round(matx[1][3],4)))
self.file.write("%s" % (tab * space))
self.file.write(" %f,%f,%f,%f,\n" %
(round(matx[2][0],4),round(matx[2][1],4),round(matx[2][2],4),round(matx[2][3],4)))
self.file.write("%s" % (tab * space))
self.file.write(" %f,%f,%f,%f;;\n" %
(round(matx[3][0],4),round(matx[3][1],4),round(matx[3][2],4),round(matx[3][3],4)))
self.file.write("%s" % (tab * space))
#self.file.write(" }\n")

#***********************************************
# Write Vector (3)
#***********************************************
def WriteVector3(self, norm, fl, space):

tab = " "
self.file.write("%s" % (tab * space))
self.file.write(" %f; %f; %f;" % (
(round(norm[0],6)*fl),(round(norm[1],6)*fl),(round(norm[2],6)*fl)))

#***********************************************#***********************************************#***********************************************

Wenn ihr den Fehler in diesem Script gefunden habt dann berichtigt ihn bitte und gibt ihn dann hier richtig an.
Ich denke nemlich das es bestimt noch andere Blitz Basic 3D Programmirer gibt die genau das selbe Problem haben.

DaKine · Verfasst am: Fr Dez 01, 2006 11:32 pm Titel: Spam

... was soll das denn ...

Hier geht es in keinster weise um Probleme dieser art ... also bitte unterlasse doch bitte foreneinträge dieser art oder machs wenigstens per link zu dem text woanders ... damit man sich aussuchen kann ob man das liest oder gleich den kopf schüttelt...

schau doch bitte auf foren für blitz3d o.ä. dort wird dir vieleicht geholfen

moritz · Spieler Anmeldedatum: 20.10.2006 Beiträge: 12

Entschuldigung aber ich weiß nicht wie man eine verlinkung zu den Text macht, auserdem hab ich keine Seite oder so wo ich den Text speichern kann.
Was meinst du da mit hier geht es nicht um Foreneinträge dieser Art?
Du meinst ich sollte mich an ein Forum für Blitz Basic 3D wenden.
Mein Problem hat aber mehr mit diesen Fehler im Phytoscript zu tun als mit Blitz Basic 3D.
Also sollte ich mich an ein Forum für Pythonprogrammirer wenden. Kennst du zufälig eins?

Unsichtbarer · Spieler Anmeldedatum: 24.08.2006 Beiträge: 48

wie wärs mit http://www.python-forum.de ?
das war der erste treffer, als ich eine namhafte Suchmaschine benutzt hab.

DaKine · Verfasst am: So Dez 03, 2006 12:15 am Titel:

Thx @ Unsichtbarer ...

moritz · Spieler Anmeldedatum: 20.10.2006 Beiträge: 12

Wasa meinstz du mit Thx @ Unsichtbarer ...?