Last active
July 19, 2023 07:17
-
-
Save liyonghelpme/04e9b6e0e148a29d7d0d to your computer and use it in GitHub Desktop.
ogre mesh skeleton导入到blender中，同时导入一个Animation的骨骼位置,并且将animation设置为一个pose
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| #!BPY | |
| """ Registration info for Blender menus: | |
| Name: 'OGRE (.mesh.xml)...' | |
| Blender: 236 | |
| Group: 'Import' | |
| Tip: 'Import an Ogre-Mesh (.mesh.xml) file.' | |
| """ | |
| ''' | |
| __author__ = "Daniel Wickert" | |
| __version__ = "0.4 05/11/05" | |
| __bpydoc__ = """\ | |
| This script imports Ogre-Mesh models into Blender. | |
| Supported:<br> | |
| * multiple submeshes (triangle list) | |
| * uvs | |
| * materials (textures only) | |
| * vertex colours | |
| Missing:<br> | |
| * submeshes provided as triangle strips and triangle fans | |
| * materials (diffuse, ambient, specular, alpha mode, etc.) | |
| * skeletons | |
| * animations | |
| Known issues:<br> | |
| * blender only supports a single uv set, always the first is taken | |
| and only the first texture unit in a material, even if it is not for | |
| the first uv set. | |
| * code is a bit hacky in parts. | |
| """ | |
| ''' | |
| # Copyright (c) 2005 Daniel Wickert | |
| # | |
| # Permission is hereby granted, free of charge, to any person obtaining a | |
| # copy of this software and associated documentation files (the "Software"), | |
| # to deal in the Software without restriction, including without limitation | |
| # the rights to use, copy, modify, merge, publish, distribute, sublicense, | |
| # and/or sell copies of the Software, and to permit persons to whom the | |
| # Software is furnished to do so, subject to the following conditions: | |
| # | |
| # The above copyright notice and this permission notice shall be included in | |
| # all copies or substantial portions of the Software. | |
| # | |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
| # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS | |
| # IN THE SOFTWARE. | |
| # HISTORY: | |
| # 0.1 04/02/05 | |
| # ------------ | |
| # * initial implementation. single submesh as triangle list, no uvs | |
| # | |
| # 0.2 04/03/05 | |
| # ------------ | |
| # * uv support added | |
| # * texture loading added | |
| # | |
| # 0.3 04/09/05 | |
| # ------------ | |
| # * multiple submeshes added | |
| # * scaling added | |
| # * material parsing (only textures yet) | |
| # * mesh -> mesh.xml conversion if IMPORT_OGREXMLCONVERTER defined | |
| # * vertex colours | |
| # | |
| # 0.3.1 04/11/05 | |
| # -------------- | |
| # * stdout output streamlined | |
| # * missing materials and textures are now handled gracefully | |
| # | |
| # 0.3.1a 04/11/05 | |
| # -------------- | |
| # * Mesh is assigned to a correctly named object and added | |
| # to the current scene | |
| # | |
| # 0.4. 05/11/05 | |
| # -------------- | |
| # * shared vertices support | |
| # * multiple texture coordinates in meshes are handled correctly no, | |
| # but only the first coordinate set is used, since Blender doesn't | |
| # allow multiple uvs. | |
| # * only the first texture_unit's texture is used now. | |
| # | |
| # 0.4.1 06/02/05 | |
| # -------------- | |
| # * fixed bug: pathes invalid under linux | |
| # * fixed bug: shared vertices were duplicated with each submesh | |
| # | |
| # 0.5.0 06/06/05 | |
| # -------------- | |
| # * consistent logging scheme with adjustable log level | |
| # * render materials | |
| # | |
| # 0.5.1 13/07/05 | |
| # -------------- | |
| # * fixed bug: meshes without normals and texture coords cannot be imported | |
| # | |
| # 0.5.2 12/02/06 | |
| # -------------- | |
| # * fixed bug: multiple blender materials created from one ogre material | |
| # | |
| # TODO: implement a consistent naming scheme: | |
| # bxxx for blender classes; oxxx for ogre(well, sorta) classes | |
| bl_info = { | |
| "name": "ogre mesh import", | |
| "author": "Bartek Skorupa, Greg Zaal", | |
| "version": (0, 1, 6), | |
| "blender": (2, 70, 0), | |
| "location": "File > Import > ogre (.mesh)", | |
| "description": "import ogre mesh file", | |
| "warning": "", | |
| "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/" | |
| "Scripts/Nodes/Nodes_Efficiency_Tools", | |
| "category": "Import-Export", | |
| } | |
| __version__ = "1.2.3" | |
| import logging | |
| handle = logging.FileHandler("/Users/liyong/blender.log") | |
| logger = logging.getLogger() | |
| logger.addHandler(handle) | |
| logger.setLevel(logging.INFO) | |
| import bpy | |
| import glob | |
| import os | |
| import re | |
| import xml.sax | |
| import xml.sax.handler | |
| import bmesh | |
| import mathutils | |
| from mathutils import Vector | |
| from mathutils import Matrix | |
| # determines the verbosity of loggin. | |
| # 0 - no logging (fatal errors are still printed) | |
| # 1 - standard logging | |
| # 2 - verbose logging | |
| # 3 - debug level. really boring (stuff like vertex data and verbatim lines) | |
| IMPORT_LOG_LEVEL = 1 | |
| IMPORT_SCALE_FACTOR = 1 | |
| #IMPORT_OGREXMLCONVERTER = "d:\stuff\Torchlight_modding\orge_tools\OgreXmlConverter.exe" | |
| IMPORT_OGREXMLCONVERTER = "/Users/liyong/Downloads/OgreCommandLineToolsMac_1.8.0/OgreXMLConverter" | |
| #IMPORT_OGREXMLCONVERTER = "F:\\Projekte\\rastullah\checkout\\rl\\branches\python\dependencies\ogre\Tools\Common\\bin\\release\\OgreXmlConverter.exe" | |
| def log(msg): | |
| logger.info(msg) | |
| #if IMPORT_LOG_LEVEL >= 1: print(msg) | |
| def vlog(msg): | |
| if IMPORT_LOG_LEVEL >= 2: print(msg) | |
| def dlog(msg): | |
| if IMPORT_LOG_LEVEL >= 3: print(msg) | |
| class Mesh: | |
| def __init__(self): | |
| self.submeshes = [] | |
| self.vertices = [] | |
| self.vertexcolours = [] | |
| self.normals = [] | |
| self.uvs = [] | |
| class Submesh: | |
| def __init__(self): | |
| self.vertices = [] | |
| self.vertexcolours = [] | |
| self.normals = [] | |
| self.faces = [] | |
| self.uvs = [] | |
| self.indextype = "" | |
| self.materialname = "" | |
| self.sharedvertices = 0 | |
| self.vertexGroup = {} | |
| class Material: | |
| def __init__(self, name): | |
| self.name = name | |
| self.texname = "" | |
| self.diffuse = (1.0, 1.0, 1.0, 1.0) | |
| self.ambient = (1.0, 1.0, 1.0, 1.0) | |
| self.specular = (0.0, 0.0, 0.0, 0.0) | |
| self.blenderimage = 0 | |
| self.loading_failed = 0 | |
| def getTexture(self): | |
| if self.blenderimage == 0 and not self.loading_failed: | |
| try: | |
| #f = file(self.texname, 'r') | |
| #f.close() | |
| #self.blenderimage = Blender.Image.Load(self.texname) | |
| if not os.path.exists(self.texname): | |
| self.texname = self.texname.replace('.png', '.dds') | |
| self.blenderimage = bpy.data.images.load(self.texname) | |
| except IOError as err: | |
| errmsg = "Couldn't open %s #%s" \ | |
| % (self.texname, err) | |
| log(errmsg) | |
| self.loading_failed = 1; | |
| return self.blenderimage | |
| class OgreMeshSaxHandler(xml.sax.handler.ContentHandler): | |
| global IMPORT_SCALE_FACTOR | |
| def __init__(self): | |
| self.mesh = 0 | |
| self.submesh = 0 | |
| self.ignore_input = 0 | |
| self.load_next_texture_coords = 0 | |
| self.skeleton = 0 | |
| self.animationlink = 0 | |
| #self.boneassignments = 0 | |
| #保存player.Skeleton 里面存储的骨骼信息 | |
| self.restPose = 0 | |
| def startDocument(self): | |
| self.mesh = Mesh() | |
| def startElement(self, name, attrs): | |
| if name == 'boneassignments': | |
| #self.boneassignments = {} | |
| pass | |
| if name == 'vertexboneassignment': | |
| vind = int(attrs.get("vertexindex", "")) | |
| bind = int(attrs.get("boneindex", "")) | |
| weight = float(attrs.get("weight", "")) | |
| if bind not in self.submesh.vertexGroup: | |
| self.submesh.vertexGroup[bind] = [] | |
| self.submesh.vertexGroup[bind].append({"vertexIndex":vind, | |
| "boneIndex" :bind, "weight":weight }) | |
| if name == 'skeletonlink': | |
| self.skeleton = attrs.get("name", '') | |
| if name == "animationlink": | |
| self.animationlink = attrs.get("name", '') | |
| if name == 'sharedgeometry': | |
| self.submesh = self.mesh | |
| if name == 'submesh': | |
| self.submesh = Submesh() | |
| self.submesh.materialname = attrs.get('material', "") | |
| self.submesh.indextype = attrs.get('operationtype', "") | |
| if attrs.get('usesharedvertices') == 'true': | |
| self.submesh.sharedvertices = 1 | |
| if name == 'vertex': | |
| self.load_next_texture_coords = 1 | |
| if name == 'face' and self.submesh: | |
| face = ( | |
| int(attrs.get('v1',"")), | |
| int(attrs.get('v2',"")), | |
| int(attrs.get('v3',"")) | |
| ) | |
| self.submesh.faces.append(face) | |
| if name == 'position': | |
| vertex = ( | |
| #Ogre x/y/z --> Blender x/-z/y | |
| float(attrs.get('x', "")) * IMPORT_SCALE_FACTOR, | |
| -float(attrs.get('z', "")) * IMPORT_SCALE_FACTOR, | |
| float(attrs.get('y', "")) * IMPORT_SCALE_FACTOR | |
| ) | |
| self.submesh.vertices.append(vertex) | |
| if name == 'normal': | |
| normal = ( | |
| #Ogre x/y/z --> Blender x/-z/y | |
| float(attrs.get('x', "")), | |
| -float(attrs.get('z', "")), | |
| float(attrs.get('y', "")) | |
| ) | |
| self.submesh.normals.append(normal) | |
| if name == 'texcoord' and self.load_next_texture_coords: | |
| uv = ( | |
| float(attrs.get('u', "")), | |
| # flip vertical value, Blender's 0/0 is lower left | |
| # whereas Ogre's 0/0 is upper left | |
| 1.0 - float(attrs.get('v', "")) | |
| ) | |
| self.submesh.uvs.append(uv) | |
| self.load_next_texture_coords = 0 | |
| if name == 'colour_diffuse': | |
| self.submesh.vertexcolours.append(attrs.get('value', "").split()) | |
| def endElement(self, name): | |
| if name == 'submesh': | |
| self.mesh.submeshes.append(self.submesh) | |
| self.submesh = 0 | |
| def setMaterial(ob, mat): | |
| me = ob.data | |
| me.materials.append(mat) | |
| from xml.dom import minidom | |
| def OpenFile(filename): | |
| if filename.find('.xml') == -1: | |
| convert_meshfile(filename) | |
| filename += '.xml' | |
| xml_file = open(filename, 'r') | |
| xml_doc = minidom.parse(xml_file) | |
| xml_file.close() | |
| return xml_doc | |
| #创建人物的 restpose的骨骼信息 | |
| def CreateSkeleton(skeleton, handler): | |
| global dirname | |
| if skeleton != 0: | |
| #scene = bpy.context.scene | |
| filename = os.path.join(dirname, skeleton) | |
| xml_doc = OpenFile(filename) | |
| return CreateBindSkeleton(xml_doc, handler) | |
| #CreateRestPoseAction(xml_doc) | |
| #OGREBoneIDsDic(xml_doc) | |
| def OGREBonesDic(xmldoc): | |
| OGRE_Bones = {} | |
| OGRE_Bone_List = [] | |
| OGRE_Bone_ID = {} | |
| for bones in xmldoc.getElementsByTagName('bones'): | |
| for bone in bones.childNodes: | |
| OGRE_Bone = {} | |
| if bone.localName == 'bone': | |
| BoneName = str(bone.getAttributeNode('name').value) | |
| BoneId = int(bone.getAttributeNode('id').value) | |
| OGRE_Bone['name'] = BoneName | |
| OGRE_Bone['id'] = BoneId | |
| for b in bone.childNodes: | |
| if b.localName == 'position': | |
| x = float(b.getAttributeNode('x').value) | |
| y = -float(b.getAttributeNode('z').value) | |
| z = float(b.getAttributeNode('y').value) | |
| OGRE_Bone['position'] = [x,y,z] | |
| if b.localName == 'rotation': | |
| angle = float(b.getAttributeNode('angle').value) | |
| axis = b.childNodes[1] | |
| axisx = float(axis.getAttributeNode('x').value) | |
| axisy = float(axis.getAttributeNode('y').value) | |
| axisz = float(axis.getAttributeNode('z').value) | |
| #convert ogre coordinate to blender coordinate | |
| OGRE_Bone['rotation'] = [axisx, -axisz, axisy] | |
| OGRE_Bone['angle'] = angle | |
| OGRE_Bones[BoneName] = OGRE_Bone | |
| OGRE_Bone_List.append(OGRE_Bone) | |
| OGRE_Bone_ID[OGRE_Bone["id"]] = OGRE_Bone | |
| for bonehierarchy in xmldoc.getElementsByTagName('bonehierarchy'): | |
| for boneparent in bonehierarchy.childNodes: | |
| if boneparent.localName == 'boneparent': | |
| Bone = str(boneparent.getAttributeNode('bone').value) | |
| Parent = str(boneparent.getAttributeNode('parent').value) | |
| OGRE_Bones[Bone]['parent'] = Parent | |
| #return OGRE_Bone_List | |
| return OGRE_Bones, OGRE_Bone_List, OGRE_Bone_ID | |
| #骨骼的孩子节点 | |
| def ChildList(BonesData): | |
| for bone in BonesData.keys(): | |
| childlist = [] | |
| for key in BonesData.keys(): | |
| if BonesData[key].get('parent'): | |
| parent = BonesData[key]['parent'] | |
| if parent == bone: | |
| if key.find('tag') != -1: | |
| childlist.append(BonesData[key]) | |
| else: | |
| childlist.insert(0, BonesData[key]) | |
| BonesData[bone]['children'] = childlist | |
| #获取所有骨骼的孩子列表缓存起来 | |
| #没有孩子节点 或者 有超过1个的孩子节点 的骨骼增加一个Helper骨骼 设置父亲为bone | |
| def HelperBones(BonesData): | |
| ChildList(BonesData) | |
| count = 0 | |
| for bone in BonesData.keys(): | |
| if (len(BonesData[bone]['children']) == 0) or (len(BonesData[bone]['children']) > 1): | |
| HelperBone = {} | |
| HelperBone['position'] = [0.2,0.0,0.0] | |
| HelperBone['parent'] = bone | |
| HelperBone['rotation'] = [1.0,0.0,0.0,0.0] | |
| HelperBone['flag'] = 'helper' | |
| BonesData['Helper'+str(count)] = HelperBone | |
| count+=1 | |
| #### 在 0 0 0 位置的骨骼 增加辅助的 0 骨骼到 parent上面 | |
| def ZeroBones(BonesData): | |
| for bone in BonesData.keys(): | |
| pos = BonesData[bone]['position'] | |
| if (math.sqrt(pos[0]**2+pos[1]**2+pos[2]**2)) == 0: | |
| ZeroBone = {} | |
| ZeroBone['position'] = [0.2,0.0,0.0] | |
| ZeroBone['rotation'] = [1.0,0.0,0.0,0.0] | |
| if (BonesData[bone].get('parent')): | |
| ZeroBone['parent'] = BonesData[bone]['parent'] | |
| ZeroBone['flag'] = 'zerobone' | |
| BonesData['Zero'+bone] = ZeroBone | |
| if (BonesData[bone].get('parent')): | |
| BonesData[BonesData[bone]['parent']]['children'].append('Zero'+bone) | |
| #计算骨骼长度 | |
| def CalcBoneLength(vec): | |
| return math.sqrt(vec[0]**2+vec[1]**2+vec[2]**2) | |
| #计算每个joint的旋转矩阵 世界坐标中的旋转矩阵 | |
| #创建空物体 来摆出pose 接着计算每个骨骼的相对位置 | |
| def CreateEmptys(BonesDic, delete=True): | |
| if bpy.context.object != None: | |
| bpy.ops.object.mode_set(mode="OBJECT") | |
| bpy.ops.object.select_all(action="DESELECT") | |
| if bpy.data.objects.get("Cube"): | |
| modelCube = bpy.data.objects["Cube"] | |
| else: | |
| bpy.ops.mesh.primitive_cube_add() | |
| modelCube = bpy.data.objects["Cube"] | |
| for k in modelCube.data.vertices.values(): | |
| k.co *= 0.1 | |
| modelCube.location = (4, 0, 0) | |
| modelCube.select = True | |
| modelCube.name = "Cube" | |
| bpy.context.scene.update() | |
| for bone in BonesDic.keys(): | |
| #bpy.ops.mesh.primitive_cube_add() | |
| bpy.ops.object.select_all(action="DESELECT") | |
| modelCube.select = True | |
| modelCube.name = "Cube" | |
| bpy.ops.object.duplicate() | |
| obj = bpy.data.objects["Cube.001"] | |
| #obj = bpy.data.objects.new(bone, None) | |
| obj.name = bone | |
| #obj.scale = (0.1, 0.1, 0.1) | |
| #bpy.context.scene.objects.link(obj) | |
| log("create Cube: "+obj.name) | |
| for bone in BonesDic.keys(): | |
| if BonesDic[bone].get('parent'): | |
| Parent = bpy.data.objects[BonesDic[bone].get('parent')] | |
| obj = bpy.data.objects[bone] | |
| obj.parent = Parent | |
| for bone in BonesDic.keys(): | |
| obj = bpy.data.objects[bone] | |
| rot = BonesDic[bone]['rotation'] | |
| angle = BonesDic[bone]['angle'] | |
| loc = BonesDic[bone]['position'] | |
| euler = mathutils.Matrix.Rotation(angle, 3, rot).to_euler() | |
| obj.location = loc | |
| obj.rotation_euler = euler | |
| bpy.ops.object.select_all(action="DESELECT") | |
| bpy.context.scene.update() | |
| for bone in BonesDic.keys(): | |
| obj = bpy.data.objects[bone] | |
| #rotmatAS = obj.matrix_world.to_quaternion() | |
| translation = obj.matrix_world.to_translation() | |
| log("obj matrix update "+obj.name+" "+str(translation)) | |
| #BonesDic[bone]['rotmatAS'] = rotmatAS.to_matrix() | |
| BonesDic[bone]["translation"] = translation | |
| BonesDic[bone]["matrix_local"] = obj.matrix_local | |
| #bpy.context.scene.objects.unlink(modelCube) | |
| #del modelCube | |
| if delete: | |
| for bone in BonesDic.keys(): | |
| obj = bpy.data.objects[bone] | |
| obj.name += "_remove" | |
| bpy.context.scene.objects.unlink(obj) | |
| del obj | |
| def SetRestMatrix(BonesDic): | |
| #for key in BonesDic.keys(): | |
| # bone = | |
| pass | |
| #按照骨骼的依赖关系 来排序 保证每个骨骼的依赖都排在其前面 | |
| def SortData(bone, BonesData): | |
| waitToVisit = [bone] | |
| while len(waitToVisit) > 0: | |
| b = waitToVisit.pop(0) | |
| BonesData.append(b) | |
| for c in b['children']: | |
| waitToVisit.append(c) | |
| def FindRoot(BonesList): | |
| for c in BonesList: | |
| if c['name'] == 'root': | |
| return c | |
| def addPos(a, b): | |
| c = [0, 0, 0] | |
| c[0] = a[0]+b[0] | |
| c[1] = a[1]+b[1] | |
| c[2] = a[2]+b[2] | |
| return c | |
| import mathutils | |
| def ParseAnimationSkeleton(xmldoc): | |
| BonesDic, BonesList, BoneID = OGREBonesDic(xmldoc) | |
| #global BoneID2Name | |
| #BoneID2Name = BoneID | |
| def ParseActionAnimation(xmldoc): | |
| Animations = {} | |
| animations = xmldoc.getElementByTagName("animations") | |
| animation = animations.getElementByTagName("animation") | |
| aniname = str(animation.getAttributeNode("name").value) | |
| length = float(animation.getAttributeNode("length").value) | |
| Track = {} | |
| tracks = animation.getElementByTagName("tracks") | |
| for track in tracks: | |
| boneName = str(track.getAttributeNode("bone").value) | |
| Track[boneName] = [] | |
| keyframes = track.getElementByTagName("keyframes") | |
| for keyframe in keyframes: | |
| time = float(keyframe.getAttributeNode("time").value) | |
| translate = keyframe.getElementsByTagName("translate")[0] | |
| x = float(translate.getAttributeNode("x").value) | |
| y = float(translate.getAttributeNode("y").value) | |
| z = float(translate.getAttributeNode("z").value) | |
| translate = [x, y, z] | |
| rotate = keyframe.getElementByTagName("rotate") | |
| angle = float(rotate.getAttributeNode("angle").value) | |
| axis = rotate.getElementByTagName("axis") | |
| x = float(axis.getAttributeNode("x").value) | |
| y = float(axis.getAttributeNode("y").value) | |
| z = float(axis.getAttributeNode("z").value) | |
| rotate = [x, y, z, angle] | |
| Track[boneName].append([time, translate, rotate]) | |
| Animations[aniname] = Track | |
| return Animations | |
| def CreateRestPoseAction(xmldoc, skname): | |
| pass | |
| #当前选择对象的 pose属性 | |
| #创建动画 pose 基本pose 骨骼位置 | |
| #只调整骨骼的head tail 位置 | |
| #记录骨骼的 旋转 和 head 属性 | |
| #得到在 bind 情况下的 pose 数据 | |
| #rest pose的数据在 OGREBonesDic 这个结构体中存储着 rest pose 数据 | |
| #后面是 动画动作数据 例如 attack pose 初始状态 0 frame 设置pose 每个骨骼位置 | |
| #测试： | |
| # 读取一个骨骼数据设置pose状态为这个初始的攻击动作位置 | |
| #流程： 读取rest骨骼 读取mesh 绑定骨骼到mesh上 | |
| #读取 attack数据 读取初始pose 在pose状态设置每个骨骼的位置 | |
| def CreateActions(ActionsDic, armaturename, BonesDic): | |
| armature = bpy.data.armatures[armaturename] | |
| arm_object = bpy.context.object | |
| pose = bpy.context.object.pose | |
| #rest 状态下的骨骼 位置数据 | |
| for Action in ActionsDic.keys(): | |
| newAction = bpy.data.actions.new(name=Action) | |
| arm_object.animation_data_create() | |
| arm_object.animation_data.action = newAction | |
| for track in ActionsDic[Action].keys(): | |
| rpbone = armature.bones[track] | |
| rpbonequat = rpbone.matrix_local.to_quaternion() | |
| rpbonetrans = Vector() | |
| ''' | |
| 建立动画骨骼 基础形态 | |
| ''' | |
| #创建一个动画的初始的 pose状态 调整armature的骨骼位置 | |
| #进入pose mode 调整每一个每个骨骼的head 和 tail位置 | |
| #旋转子骨骼到目标位置 的一个旋转方向 location rotation scale 沿着骨骼的轴方向的 | |
| #head ---> tail 之间的一个旋转方向 变化 从原方向 到新方向之间的旋转变化 | |
| import math | |
| def CreateAnimationPose(animationlink, handler): | |
| global dirname | |
| if animationlink != 0: | |
| #scene = bpy.context.scene | |
| filename = os.path.join(dirname, animationlink) | |
| xml_doc = OpenFile(filename) | |
| #得到动画pose中每个骨骼的变换矩阵 | |
| #分析xml文件得到 攻击动作的初始 骨骼位置 pose | |
| BonesDic, BonesList, BoneID = OGREBonesDic(xml_doc) | |
| BonesData = [] | |
| ChildList(BonesDic) | |
| #创建空物体来 计算骨骼的坐标位置 | |
| CreateEmptys(BonesDic) | |
| #return | |
| root = FindRoot(BonesList) | |
| SortData(root, BonesData) | |
| if bpy.context.object != None: | |
| bpy.ops.object.mode_set(mode="OBJECT") | |
| bpy.context.object.select = False | |
| bpy.ops.object.select_all(action="DESELECT") | |
| amt_obj = bpy.data.objects["Armature"] | |
| amt_data = amt_obj.data | |
| amt_obj.animation_data_create() | |
| action = bpy.data.actions.new(name="Test") | |
| amt_obj.animation_data.action = action | |
| #amt_obj.select = True | |
| #bpy.ops.object.mode_set(mode="POSE") | |
| #提取pose信息 设置初始pose属性 骨骼的location 相对于rest的location 和 rotation数据 | |
| #骨骼的location 增加3条曲线 描述 x y z 每个骨骼的位置变化 | |
| #modify location is relative position | |
| restPoseEdit = handler.restPose | |
| #使用骨骼的 旋转位置 不要使用 空物体的位置 空物体位置和 骨骼位置不对 | |
| restBone = amt_data.bones | |
| #建立一个新的骨架 比较两个骨架的本地旋转信息 Armature2 骨架 | |
| #骨架名称可以相同 | |
| if bpy.context.object != None: | |
| bpy.ops.object.select_all(action="DESELECT") | |
| arm = bpy.ops.object.add(type="ARMATURE", enter_editmode=True) | |
| ob = bpy.context.object | |
| ob.location = bpy.context.scene.cursor_location | |
| ob.show_x_ray = True | |
| ob.name = "Armature2" | |
| amt = ob.data | |
| amt.show_axes = True | |
| arm_obj = ob | |
| log("initial Animation Bone ") | |
| #初始化动画骨骼 | |
| for k in BonesData: | |
| log("joint pos "+k['name']+" : "+str(k['translation'])) | |
| if k.get('parent'): | |
| parent = BonesDic[k['parent']] | |
| if parent.get('parent'): | |
| parentBone = amt.edit_bones[k['parent']] | |
| bpy.ops.armature.select_all(action="DESELECT") | |
| parentBone.select_tail = True | |
| bpy.ops.armature.extrude() | |
| amt.edit_bones[-1].name = k['name'] | |
| selBone = amt.edit_bones[-1] | |
| tp = k["translation"]-selBone.head | |
| bpy.ops.transform.translate(value=tp) | |
| #root--->Bip01 | |
| else: | |
| bone = amt.edit_bones.new(k['name']) | |
| bone.head = parent["translation"] | |
| bone.tail = k["translation"] | |
| bone.use_connect = False | |
| if parent.get('firstBone') != None: | |
| bone.parent = amt.edit_bones[parent['firstBone']] | |
| else: | |
| parent['firstBone'] = bone.name | |
| bpy.ops.armature.select_all(action="DESELECT") | |
| else: | |
| pass | |
| #存储动画骨骼的基本信息 配置状态 | |
| bpy.context.scene.update() | |
| for k in BonesData: | |
| if amt.edit_bones.get(k["name"]): | |
| bone = amt.edit_bones[k["name"]] | |
| k["head"] = bone.head.copy() | |
| k["tail"] = bone.tail.copy() | |
| k["roll"] = bone.roll | |
| k["length"] = bone.length | |
| k["mat"] = bone.matrix.to_3x3().copy() | |
| bone.use_inherit_scale = False | |
| bone.use_inherit_rotation = False | |
| #对比restPose Bone 和 动画 骨骼的 head tail roll 来计算 pose下的rotation | |
| #先制作旋转 再做roll旋转 | |
| #将 目标骨骼方向向量转化到 rest骨骼的空间中 | |
| #计算 (0, 1, 0) 方向和 转化方向之间的旋转四元式 | |
| #设置pose 骨骼的rotation_quaternion旋转数据 | |
| if bpy.context.object != None: | |
| bpy.ops.object.mode_set(mode="OBJECT") | |
| bpy.context.object.select = False | |
| bpy.ops.object.select_all(action="DESELECT") | |
| #调整 基础骨骼 pose骨骼的 位置 缩放 旋转 | |
| amt_obj.select = True | |
| #bpy.ops.object.mode_set(mode="POSE") | |
| for b in BonesData: | |
| if b.get("parent") and restBone.get(b["name"]) != None: | |
| rbData = restPoseEdit[b["name"]] | |
| #rbDir = rbData["tail"]-rbData["head"] | |
| #myDir = b["tail"]-b["head"] | |
| #逆矩阵是将 世界坐标的向量 转化到 骨骼空间里面去的 | |
| #使用edit 模式下的骨骼的 变换矩阵 | |
| normalBoneMat = rbData["mat"].inverted() #restBone[b["name"]].matrix.inverted() | |
| #使用动画的 matrix 变换到世界空间 接着从世界空间变换到 rest pose空间 | |
| nDir = normalBoneMat*b["mat"]*Vector((0, 1, 0)) | |
| rotAxis = Vector.cross(Vector((0, 1, 0)), nDir) | |
| #.normalized() | |
| log("calculate bone data "+b["name"]+" "+str(nDir)) | |
| theta = math.asin(rotAxis.length/nDir.length) | |
| #av = min(max(-1, Vector((0, 1, 0))*nDir), 1) | |
| #angle = math.acos(av) | |
| qua = Matrix.Rotation(theta, 3, rotAxis).to_quaternion() | |
| defaultQua = (1, 0, 0, 0) | |
| #还要计算roll值 | |
| #difRoll = b["roll"]-rbData["roll"] | |
| #rotY = Matrix.Rotation(difRoll, 3, Vector((0, 1, 0))).to_quaternion() | |
| #先旋转 接着 调整roll 方向 | |
| #qua = qua*rotY | |
| for axis_i in range(4): | |
| data_path = 'pose.bones["%s"].rotation_quaternion' % (b['name']) | |
| curve = action.fcurves.new(data_path=data_path, index=axis_i) | |
| keyframe_points = curve.keyframe_points | |
| keyframe_points.add(2) | |
| keyframe_points[0].co = (10, defaultQua[axis_i]) | |
| keyframe_points[0].co = (20, qua[axis_i]) | |
| defaultSca = (1, 1, 1) | |
| scale = b["length"]/restBone[b["name"]].length | |
| modifyScale = (1, scale, 1) | |
| #根据长度缩放骨骼 | |
| data_path = 'pose.bones["%s"].scale' % (b['name']) | |
| for axis_i in range(3): | |
| curve = action.fcurves.new(data_path=data_path, index=axis_i) | |
| keyframe_points = curve.keyframe_points | |
| keyframe_points.add(2) | |
| keyframe_points[0].co = (10, defaultSca[axis_i]) | |
| keyframe_points[0].co = (20, scale) | |
| ''' | |
| for b in BonesData: | |
| #not root | |
| #Pelvis 长度为0的 骨骼不存在所以不用修改状态 | |
| if b.get("parent") and restBone.get(b["name"]) != None: | |
| parent = BonesDic[b["parent"]] | |
| #计算两个的方向向量的旋转值 | |
| #diff = b["translation"]-parent["translation"] | |
| #diffOld = restPose[b["name"]]["translation"] - restPose[parent["name"]]["translation"] | |
| #从B空间 到 A 空间 MA*MB-1 | |
| #matrixA = b["matrix_local"] | |
| #matrixB = restPose[b["name"]]["matrix_local"] | |
| #mat = matrixB.inverted()*matrixA | |
| #qua = mat.to_quaternion() | |
| #qua = matrixA.to_quaternion()-matrixB.to_quaternion() | |
| rpbone = restBone[b["name"]] | |
| rpquat = rpbone.matrix_local.to_quaternion() | |
| sprotAxis = b["rotation"] | |
| sprotAngle = b["angle"] | |
| sprotquat = Matrix.Rotation(sprotAngle, 3, sprotAxis).to_quaternion() | |
| qua = rpquat-sprotquat | |
| #c = Vector.cross(diffOld, diff) | |
| #theta = math.acos(diffOld.normalized()*diff.normalized()) | |
| #math.sin(theta) | |
| #rot = Matrix.Rotation(theta, 3, c) | |
| #qua = rot.to_quaternion() | |
| #w x y z | |
| for axis_i in range(4): | |
| data_path = 'pose.bones["%s"].rotation_quaternion' % (b['name']) | |
| curve = action.fcurves.new(data_path=data_path, index=axis_i) | |
| keyframe_points = curve.keyframe_points | |
| keyframe_points.add(1) | |
| keyframe_points[0].co = (5, qua[axis_i]) | |
| ''' | |
| BoneID2Name = {} | |
| #create blender armature submesh multiple mesh use shared vertex or not share | |
| #convert ogre joint to bones | |
| #建立绑定位置的 骨骼位置信息 pose mode下面可以调整微调 | |
| def CreateBindSkeleton(xmldoc, handler): | |
| BonesDic, BonesList, BoneID = OGREBonesDic(xmldoc) | |
| global BoneID2Name | |
| BoneID2Name = BoneID | |
| #BonesData = BonesDic | |
| BonesData = [] | |
| ChildList(BonesDic) | |
| CreateEmptys(BonesDic) | |
| handler.restPose = BonesDic | |
| #return | |
| root = FindRoot(BonesList) | |
| #root = BonesList[0] | |
| if root == None: | |
| log("not find root bone "+str(BonesList)) | |
| return | |
| #sort from root | |
| SortData(root, BonesData) | |
| if len(BonesData) != len(BonesList): | |
| log("sort bone not equal "+ str(len(BonesList))) | |
| log("data is "+str(len(BonesData))) | |
| log("lost Number is "+str(len(BonesList) - len(BonesData))) | |
| setA = set([k['name'] for k in BonesList]) | |
| setB = set([k['name'] for k in BonesData]) | |
| difSet = setA-setB | |
| for k in difSet: | |
| log('lost '+k) | |
| log(BonesDic[k]) | |
| return | |
| #HelperBones(BonesDic) | |
| #ZeroBones(BonesDic) | |
| #CreateEmptys(BonesDic) | |
| #SetBonesASPositions(BonesDic) | |
| #BonesData = BonesDic | |
| #scn = bpy.context.scene | |
| #obj = bpy.data.objects.new("obj", objmesh) | |
| #obj.location = bpy.context.scene.cursor_location | |
| #bpy.context.scene.objects.link(obj) | |
| arm = bpy.ops.object.add(type="ARMATURE", enter_editmode=True) | |
| ob = bpy.context.object | |
| ob.location = bpy.context.scene.cursor_location | |
| ob.show_x_ray = True | |
| amt = ob.data | |
| amt.show_axes = True | |
| #joint to bone root-> some bone | |
| #root is an empty Bone joint first Bone is parent | |
| bpy.ops.armature.select_all(action="DESELECT") | |
| log("initial Bone") | |
| for k in BonesData: | |
| log("joint pos "+k['name']+" : "+str(k['translation'])) | |
| #posit | |
| #root joint self | |
| if k.get('parent'): | |
| #bpy.context.scene.active = bone | |
| #root ---> Bip01 | |
| #Bip01 ----> Pelvis | |
| #root ---> tag_xxx | |
| #parent joint rotation | |
| parent = BonesDic[k['parent']] | |
| #Bip01 ---> Pelvis | |
| #extrude from parent bone tail | |
| if parent.get('parent'): | |
| parentBone = amt.edit_bones[k['parent']] | |
| bpy.ops.armature.select_all(action="DESELECT") | |
| parentBone.select_tail = True | |
| bpy.ops.armature.extrude() | |
| amt.edit_bones[-1].name = k['name'] | |
| selBone = amt.edit_bones[-1] | |
| #rot = Matrix.Rotation(parent['angle'], 3, parent['rotation']) | |
| #rot = parent["rotmatAS"] | |
| tp = k["translation"]-selBone.head | |
| #tp = rot*Vector(k['position']) | |
| bpy.ops.transform.translate(value=tp) | |
| #selBone.matrix = rot | |
| #new bone | |
| #bone.head = parentBone.tail | |
| #(trans, rotParent, scale) = parentBone.matrix.decompose() | |
| #rot = Matrix.Rotation(parent['angle'], 3, parent['rotation']) | |
| #bone.tail = Vector(k['position'])+parentBone.tail | |
| #addPos(parentBone.tail, k['position']) | |
| #bone.use_connect = False | |
| #bone.parent = parentBone | |
| #bpy.ops.transform.rotate(value=parent['angle'], axis=parent['rotation']) | |
| #root--->Bip01 | |
| else: | |
| bone = amt.edit_bones.new(k['name']) | |
| bone.head = parent["translation"] | |
| #parent['position'] | |
| #rot = Matrix.Rotation(parent['angle'], 3, parent['rotation']) | |
| #rot = parent["rotmatAS"] | |
| bone.tail = k["translation"] | |
| #bone.tail = rot*Vector(k['position'])+bone.head | |
| #bone.matrix = rot | |
| #bone.tail = rot*Vector(k['position'])+bone.head | |
| #bone.tail = addPos(bone.head, k['position']) | |
| bone.use_connect = False | |
| if parent.get('firstBone') != None: | |
| bone.parent = amt.edit_bones[parent['firstBone']] | |
| else: | |
| parent['firstBone'] = bone.name | |
| bpy.ops.armature.select_all(action="DESELECT") | |
| ''' | |
| #first bone from joint root join parent is who? | |
| if k['parent']['firstBone'] == None: | |
| bone.head = k['parent']['position'] | |
| bone.tail = addPos(k['parent']['position'], k['position']) | |
| bone.use_connect = False | |
| k['parent']['firstBone'] = bone | |
| if k['parent'].get('parent'): | |
| bone.parent = amt.edit_bones[k['parent']] | |
| #other bone from joint | |
| else: | |
| bone.head = k['parent']['position'] | |
| bone.tail = addPos(k['parent']['position'], k['position']) | |
| ''' | |
| #parent = amt.edit_bones[k['parent']] | |
| #bone.parent = parent | |
| #bone.head = parent.tail | |
| #bone.use_connect = False | |
| #(trans, rot, scale) = parent.matrix.decompose() | |
| #bone.tail = rot*Vector((0.3, 0, 0))+bone.head | |
| else: | |
| pass | |
| #bone.head = k['position'] | |
| #rot = mathutils.Matrix.Translation((0, 0, 0)) | |
| #rot = Matrix.Rotation(k['rotation'][3], 3, k['rotation'][:3]) | |
| #rot = Matrix.Rotation(k['rotation'][3], 3, k['rotation'][:3]) | |
| #bone.head = k['position'] | |
| bpy.context.scene.update() | |
| for k in BonesData: | |
| if k.get('parent'): | |
| bone = amt.edit_bones[k['name']] | |
| k["head"] = bone.head.copy() | |
| k["tail"] = bone.tail.copy() | |
| k["roll"] = bone.roll | |
| k["length"] = bone.length | |
| k["mat"] = bone.matrix.to_3x3().copy() | |
| bone.use_inherit_scale = False | |
| bone.use_inherit_rotation = False | |
| log("create bone finish "+str(len(BonesList))) | |
| return arm | |
| #从每个submesh 里面抽取出vertexGroup的数据 | |
| #建立一个 vertexGroup | |
| #将对应定点放到group里面 | |
| #group 按照数字名称来分组 | |
| #def CreateVertexGroup(name, mesh): | |
| #分析完一个子mesh的时候 子物体就添加一个顶点group | |
| def CreateBlenderMesh(name, mesh, materials): | |
| #bmesh = Blender.NMesh.GetRaw() | |
| #bmesh = bpy.data.meshes.new("test") | |
| # dict matname:blender material | |
| bmaterials = {} | |
| bmat_idx = -1 | |
| log("Mesh with %d shared vertices." % len(mesh.vertices)) | |
| vertex_count = len(mesh.vertices) | |
| shareVert = mesh.vertices | |
| shareNormal = mesh.normals | |
| shareUV = mesh.uvs | |
| submesh_count = len(mesh.submeshes) | |
| vertex_offset = 0 | |
| faces = [] | |
| #bpy.context.active_object = None | |
| bpy.ops.object.mode_set(mode="OBJECT") | |
| bpy.ops.object.select_all(action="DESELECT") | |
| for j in range(0, submesh_count): | |
| submesh = mesh.submeshes[j] | |
| vert = submesh.vertices | |
| faces = submesh.faces | |
| uvs = submesh.uvs | |
| if submesh.sharedvertices == 1: | |
| vert = shareVert | |
| uvs = shareUV | |
| objmesh = bpy.data.meshes.new("mesh"+str(j)) | |
| obj = bpy.data.objects.new("obj"+str(j), objmesh) | |
| obj.location = bpy.context.scene.cursor_location | |
| bpy.context.scene.objects.link(obj) | |
| objmesh.from_pydata(vert, [], faces) | |
| objmesh.update(calc_edges=True) | |
| obj.select = True | |
| bpy.context.scene.objects.active = obj | |
| bpy.ops.object.mode_set(mode="EDIT") | |
| #if bpy.context.mode == 'EDIT_MESH': | |
| #for f in bm.faces: | |
| obj = bpy.context.active_object | |
| me = obj.data | |
| bm = bmesh.from_edit_mesh(me) | |
| uv_layer = bm.loops.layers.uv.verify() | |
| bm.faces.layers.tex.verify() | |
| #设置loop 循环上面的每个定点的uv 坐标获得定点的编号来索引到对应的uv坐标 | |
| for f in bm.faces: | |
| for l in f.loops: | |
| luv = l[uv_layer] | |
| ind = l.vert.index | |
| luv.uv = Vector(uvs[ind]) | |
| bmesh.update_edit_mesh(me) | |
| me.update() | |
| bpy.ops.object.mode_set(mode="OBJECT") | |
| #检测骨骼编号 和 对应的骨骼名称 | |
| log("skeleton ID") | |
| allID = set(BoneID2Name.keys()) | |
| useID = set(submesh.vertexGroup.keys()) | |
| diffID = useID-allID | |
| for k in diffID: | |
| log("lostID "+str(k)) | |
| log("all Lost ID "+str(len(allID))) | |
| for k in allID: | |
| log("allID "+str(k)+" "+str(BoneID2Name[k])) | |
| if len(diffID) > 0: | |
| return | |
| #初始化顶点组 | |
| #以骨骼快速分析骨骼名称得到实际骨骼名称 | |
| #OGREBonesDic | |
| #尝试将一个 joint 上面的定点权重/2 平分到相邻的两个骨骼上面即可 | |
| #也就是一个joint vertexGroup 对应两个 bone的 vertexGroup | |
| #分别是 tail 和 别的骨骼的head | |
| #如果这个有多个child 则 平分权重到 多个child+parent上面即可 | |
| for k in submesh.vertexGroup: | |
| parentNode = BoneID2Name[k] | |
| allGroups = [parentNode]+parentNode["children"] | |
| num = float(len(allGroups)) | |
| #blenderGroup = [] | |
| #将定点 放到每一个 相邻骨骼的 组中 并且权重平分 | |
| for g in allGroups: | |
| if obj.vertex_groups.get(g["name"]) == None: | |
| group = obj.vertex_groups.new(g["name"]) | |
| else: | |
| group = obj.vertex_groups[g["name"]] | |
| for v in submesh.vertexGroup[k]: | |
| group.add([v["vertexIndex"]], v["weight"]/num, 'ADD') | |
| #blenderGroup.append(group) | |
| #name = realName["name"] | |
| #realName["parent"] | |
| #骨骼是使用 tail joint命名的因此需要 调整为parent 的名称来为 定点group命名 | |
| #group = obj.vertex_groups.new(name) | |
| #for v in submesh.vertexGroup[k]: | |
| # group.add([v["vertexIndex"]], v["weight"], 'REPLACE') | |
| #bmesh.from_pydata(vert, [], faces) | |
| #break | |
| if materials.get(submesh.materialname): | |
| omat = materials[submesh.materialname] | |
| bmat = 0 | |
| if not bmaterials.get(submesh.materialname): | |
| bmat = create_blender_material(omat) | |
| bmaterials[submesh.materialname] = bmat | |
| else: | |
| bmat = bmaterials[submesh.materialname] | |
| setMaterial(obj, bmat) | |
| #设置模型材质 | |
| bpy.ops.object.join() | |
| return bpy.context.object | |
| def convert_meshfile(filename): | |
| log("convert file "+filename) | |
| if IMPORT_OGREXMLCONVERTER != '': | |
| commandline = IMPORT_OGREXMLCONVERTER +' -log /Users/liyong/err.log '+ ' "' + filename + '"' + ' "'+ filename + '.xml' + '"' | |
| log("executing %s" % commandline) | |
| log(os.path.abspath('.')) | |
| status = os.system(commandline) | |
| log('status '+str(status)) | |
| log("done.") | |
| #set ambient diffuse specular emissive color | |
| #def collect_materials(dirname): | |
| # matname_pattern = re.compile('^\s*material\s+(.*?)\s*$') | |
| def collect_materials(dirname): | |
| # preparing some patterns | |
| # to collect the material name | |
| matname_pattern = re.compile('^\s*material\s+(.*?)\s*$') | |
| # to collect the texture name | |
| texname_pattern = re.compile('^\s*texture\s+(.*?)\s*$') | |
| # to collect the diffuse colour | |
| diffuse_alpha_pattern = re.compile(\ | |
| '^\s*diffuse\s+([^\s]+?)\s+([^\s]+?)\s+([^\s]+?)\s+([^\s]+).*$') | |
| diffuse_pattern = re.compile(\ | |
| '^\s*diffuse\s+([^\s]+?)\s+([^\s]+?)\s+([^\s]+).*$') | |
| # to collect the specular colour | |
| specular_pattern = re.compile(\ | |
| '^\s*specular\s+([^\s]+?)\s+([^\s]+?)\s+([^\s]+).*$') | |
| ambient_pattern = re.compile( | |
| '^\s*ambient\s+([^\s]+?)\s+([^\s]+?)\s+([^\s]+).*$') | |
| # the dictionary where to put the materials | |
| materials = {} | |
| # for all lines in all material files.. | |
| material_files = glob.glob(dirname + '/*.material') | |
| material = 0 | |
| for filename in material_files: | |
| f = open(filename, 'r') | |
| line_number = 0 | |
| for line in f: | |
| try: | |
| line_number = line_number + 1 | |
| dlog("line to be matched: %s" % line) | |
| #m = matname_pattern.match(line) | |
| mat_name = matname_pattern.findall(line) | |
| if len(mat_name) > 0: | |
| material = Material(mat_name[0]) | |
| materials[material.name] = material | |
| vlog("parsing material %s" % mat_name[0]) | |
| #m = texname_pattern.match(line) | |
| tex_name = texname_pattern.findall(line) | |
| # load only the first texture unit's texture | |
| # TODO change to use the first one using the first uv set | |
| if len(tex_name) > 0 and not material.texname: | |
| #if m and not material.texname: | |
| material.texname = dirname + '/' + tex_name[0] | |
| m = diffuse_alpha_pattern.match(line) | |
| if not m: | |
| m = diffuse_pattern.match(line) | |
| if m: | |
| vlog(" parsing diffuse..") | |
| groups = m.groups() | |
| r = float(groups[0]) | |
| g = float(groups[1]) | |
| b = float(groups[2]) | |
| #TODO: alpha still untested | |
| if len(groups) > 3: | |
| a = float(groups[3]) | |
| else: | |
| a = 1.0 | |
| material.diffuse = (r, g, b, a) | |
| vlog(" diffuse: %s" % str(material.diffuse)) | |
| m = specular_pattern.match(line) | |
| if m: | |
| vlog(" parsing specular..") | |
| groups = m.groups() | |
| r = float(groups[0]) | |
| g = float(groups[1]) | |
| b = float(groups[2]) | |
| material.specular = (r, g, b, 1.0) | |
| vlog(" specular: %s" % str(material.specular)) | |
| except Exception as e: | |
| log(" error parsing material %s in %s on line % d: " % \ | |
| (material.name, filename, line_number)) | |
| log(" exception: %s" % str(e)) | |
| return materials | |
| def create_blender_material(omat): | |
| mat = bpy.data.materials.new(omat.name) | |
| mat.diffuse_color = omat.diffuse[:3] | |
| mat.diffuse_shader = 'LAMBERT' | |
| mat.diffuse_intensity = 1.0 | |
| mat.specular_color = omat.specular[:3] | |
| mat.specular_shader = 'COOKTORR' | |
| mat.specular_intensity = 1.0 | |
| mat.alpha = omat.diffuse[3] | |
| mat.ambient = 1 | |
| img = omat.getTexture() | |
| if img: | |
| cTex = bpy.data.textures.new(omat.texname, type="IMAGE") | |
| cTex.image = img | |
| mtex = mat.texture_slots.add() | |
| mtex.texture = cTex | |
| mtex.texture_coords = "UV" | |
| mtex.use_map_color_diffuse = True | |
| #mtex.use_map_color_emission = True | |
| #mtex.emission_color_factor = 0.5 | |
| #mtex.use_map_density = True | |
| mtex.mapping = "FLAT" | |
| return mat | |
| dirname = None | |
| basename = None | |
| def fileselection_callback(filename): | |
| log("Reading mesh file %s..." % filename) | |
| filename = os.path.expanduser(filename) | |
| #if fileName: | |
| # (shortName, ext) = os.path.splitext(filename) | |
| # is this a mesh file instead of an xml file? | |
| if (filename.lower().find('.xml') == -1): | |
| # No. Use the xml converter to fix this | |
| log("No mesh.xml file. Trying to convert it from binary mesh format.") | |
| convert_meshfile(filename) | |
| filename += '.xml' | |
| global dirname | |
| global basename | |
| dirname = os.path.dirname(filename) | |
| basename = os.path.basename(filename) | |
| #dirname = sys.dirname(filename) | |
| #basename = Blender.sys.basename(filename) | |
| # parse material files and make up a dictionary: {mat_name:material, ..} | |
| materials = collect_materials(dirname) | |
| #create materials | |
| # prepare the SAX parser and parse the file using our own content handler | |
| parser = xml.sax.make_parser() | |
| handler = OgreMeshSaxHandler() | |
| parser.setContentHandler(handler) | |
| parser.parse(open(filename)) | |
| # create the mesh from the parsed data and link it to a fresh object | |
| #scene = Blender.Scene.GetCurrent() | |
| meshname = basename[0:basename.lower().find('.mesh.xml')] | |
| #生成骨骼 | |
| CreateSkeleton(handler.skeleton, handler) | |
| amt = bpy.data.objects["Armature"] | |
| #生成蒙皮 和 顶点组 | |
| obj = CreateBlenderMesh(meshname, handler.mesh, materials) | |
| #bpy.ops.object.mode_set(mode="OBJECT") | |
| bpy.context.scene.update() | |
| bpy.ops.object.select_all(action="DESELECT") | |
| bpy.context.scene.objects.active = amt | |
| #obj.select = False | |
| #amt.select = False | |
| obj.select = True | |
| amt.select = True | |
| bpy.ops.object.parent_set(type="ARMATURE") | |
| #生成攻击动画基本形态关键帧 | |
| CreateAnimationPose(handler.animationlink, handler) | |
| #scene.link(object) | |
| #object.select = True | |
| log("import completed.") | |
| #Blender.Redraw() | |
| def clearScene(): | |
| #global toggle | |
| scn = bpy.context.scene | |
| log("clearScene ") | |
| for ob in scn.objects: | |
| if ob.type in ["MESH", "CURVE", "TEXT"]: | |
| scn.objects.active = ob | |
| bpy.ops.object.mode_set(mode='OBJECT') | |
| scn.objects.unlink(ob) | |
| del ob | |
| return scn | |
| #Blender.Window.FileSelector(fileselection_callback, "Import OGRE", "*.xml") | |
| from bpy.props import * | |
| class IMPORT_OT_OGRE(bpy.types.Operator): | |
| bl_idname = "import_scene.ogre_mesh" | |
| bl_description = 'Import from mesh file format (.mesh)' | |
| bl_label = "Import mesh" +' v.'+ __version__ | |
| bl_space_type = "PROPERTIES" | |
| bl_region_type = "WINDOW" | |
| bl_options = {'UNDO'} | |
| filepath = StringProperty( | |
| subtype='FILE_PATH', | |
| ) | |
| def draw(self, context): | |
| layout0 = self.layout | |
| #layout0.enabled = False | |
| #col = layout0.column_flow(2,align=True) | |
| layout = layout0.box() | |
| col = layout.column() | |
| #col.prop(self, 'KnotType') waits for more knottypes | |
| #col.label(text="import Parameters") | |
| #col.prop(self, 'replace') | |
| #col.prop(self, 'new_scene') | |
| #row = layout.row(align=True) | |
| #row.prop(self, 'curves') | |
| #row.prop(self, 'circleResolution') | |
| #row = layout.row(align=True) | |
| #row.prop(self, 'merge') | |
| #if self.merge: | |
| # row.prop(self, 'mergeLimit') | |
| #row = layout.row(align=True) | |
| #row.label('na') | |
| #row.prop(self, 'draw_one') | |
| #row.prop(self, 'thic_on') | |
| #col = layout.column() | |
| #col.prop(self, 'codec') | |
| #row = layout.row(align=True) | |
| #ow.prop(self, 'debug') | |
| #if self.debug: | |
| # row.prop(self, 'verbose') | |
| def execute(self, context): | |
| ''' | |
| global toggle, theMergeLimit, theCodec, theCircleRes | |
| O_Merge = T_Merge if self.merge else 0 | |
| #O_Replace = T_Replace if self.replace else 0 | |
| O_NewScene = T_NewScene if self.new_scene else 0 | |
| O_Curves = T_Curves if self.curves else 0 | |
| O_ThicON = T_ThicON if self.thic_on else 0 | |
| O_DrawOne = T_DrawOne if self.draw_one else 0 | |
| O_Debug = T_Debug if self.debug else 0 | |
| O_Verbose = T_Verbose if self.verbose else 0 | |
| toggle = O_Merge | O_DrawOne | O_NewScene | O_Curves | O_ThicON | O_Debug | O_Verbose | |
| theMergeLimit = self.mergeLimit*1e-4 | |
| theCircleRes = self.circleResolution | |
| theCodec = self.codec | |
| ''' | |
| #bpy.ops.wm.read_homefile() | |
| clearScene() | |
| #readAndBuildDxfFile(self.filepath) | |
| fileselection_callback(self.filepath) | |
| return {'FINISHED'} | |
| def invoke(self, context, event): | |
| wm = context.window_manager | |
| wm.fileselect_add(self) | |
| return {'RUNNING_MODAL'} | |
| def menu_func(self, context): | |
| self.layout.operator(IMPORT_OT_OGRE.bl_idname, text="ogre (.mesh)") | |
| def register(): | |
| bpy.utils.register_module(__name__) | |
| bpy.types.INFO_MT_file_import.append(menu_func) | |
| def unregister(): | |
| bpy.utils.unregister_module(__name__) | |
| bpy.types.INFO_MT_file_import.remove(menu_func) | |
| if __name__ == "__main__": | |
| register() | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment