# coding: utf-8
import sys
import os
-import Blender
-from Blender import Mathutils
-import bpy
+try:
+ import Blender
+ from Blender import Mathutils
+ import bpy
+except:
+ pass
# ファイルシステムの文字コード
# 改造版との共用のため
else:
INTERNAL_ENCODING=FS_ENCODING
+SCENE=None
+def initialize(name, scene):
+ global SCENE
+ SCENE=scene
+ progress_start(name)
+ # set object mode
+ mode_edit = Blender.Window.EditMode()
+ if mode_edit:
+ Blender.Window.EditMode(0)
+
+def finalize():
+ scene.update(SCENE)
+ progress_finish()
+ # restore edit mode
+ #if mode_edit:
+ # Blender.Window.EditMode(1)
+
+def message(msg):
+ res=Blender.Draw.PupMenu(msg + "%t|OK")
+ print(res)
+
+def enterEditMode():
+ Blender.Window.EditMode(1)
+
+def exitEditMode():
+ Blender.Window.EditMode(0)
+
+def createVector(x, y, z):
+ return Mathutils.Vector(x, y, z)
+
-###############################################################################
-# Writer
-###############################################################################
class Writer(object):
+ '''
+ io wrapper
+ '''
+ __slots__=[
+ 'io', 'encoding',
+ ]
def __init__(self, path, encoding):
+ '''
+ path: file path to open
+ encoding: text encoding to write
+
+ '''
self.io=open(path, "wb")
self.encoding=encoding
self.io.close()
-###############################################################################
-# ProgressBar
-###############################################################################
class ProgressBar(object):
+ '''
+ progress bar wrapper
+ '''
+ __slots__=['base', 'start', 'progress',]
def __init__(self, base):
print("#### %s ####" % base)
self.base=base
self.start=Blender.sys.time()
self.set('<start>', 0)
+ Blender.Window.WaitCursor(1)
def advance(self, message, progress):
self.progress+=float(progress)
self.progress=1.0
message='finished in %.2f sec' % (Blender.sys.time()-self.start)
self.set(message, 1.0)
-
+ Blender.Window.WaitCursor(0)
+ Blender.Redraw()
def progress_start(base):
global progressBar
progressBar.set(message, progress)
-###############################################################################
-def createEmptyObject(scene, name):
- empty=scene.objects.new("Empty")
- empty.setName(name)
- return empty
-
-def createMaterial(name):
- material = Blender.Material.New(name)
- return material
-
-def createMqoMaterial(m):
- material = Blender.Material.New(m.getName().encode(INTERNAL_ENCODING))
- material.mode |= Blender.Material.Modes.SHADELESS
- material.rgbCol = [m.color.r, m.color.g, m.color.b]
- material.alpha = m.color.a
- material.amb = m.ambient
- material.spec = m.specular
- material.hard = int(255 * m.power)
- return material
-
-def createPmdMaterial(m):
- material=Blender.Material.New()
- material.setDiffuseShader(Blender.Material.Shaders.DIFFUSE_TOON)
- material.setRef(1)
- material.diffuseSize = 3.14/2
- material.setDiffuseSmooth(0)
- material.setSpecShader(Blender.Material.Shaders.SPEC_TOON)
- material.setSpecSize(0)
- material.setSpec(0)
- material.setRGBCol([m.diffuse.r, m.diffuse.g, m.diffuse.b])
- material.setAlpha(m.diffuse.a)
- material.setSpec(m.shinness*0.1)
- material.setSpecCol([m.specular.r, m.specular.g, m.specular.b])
- material.setMirCol([m.ambient.r, m.ambient.g, m.ambient.b])
- material.enableSSS=True if m.flag==1 else False
- return material
-
-def createTexture(path):
- image = Blender.Image.Load(path.encode(INTERNAL_ENCODING))
- texture = Blender.Texture.New(path.encode(INTERNAL_ENCODING))
- texture.type = Blender.Texture.Types.IMAGE
- texture.image = image
- texture.tex.imageFlags|=Blender.Texture.ImageFlags.USEALPHA
- return texture, image
-
-def materialAddTexture(material, texture):
- material.mode = material.mode | Blender.Material.Modes.TEXFACE
- material.setTexture(0, texture, Blender.Texture.TexCo.UV)
-
-def materialHasTexture(material):
- return len(material.getTextures())>0
-
-def createMesh(scene, name):
- mesh = Blender.Mesh.New()
- mesh_object=scene.objects.new(mesh, name.encode(INTERNAL_ENCODING))
- return mesh, mesh_object
-
-
-def objectMakeParent(parent, child):
- parent.makeParent([child])
-
-
-def meshAddMaterial(mesh, material):
- mesh.materials+=[material]
-
-
-def meshAddGeometry(mesh, vertices, faces):
- mesh.verts.extend(vertices)
- new_faces=mesh.faces.extend(faces,
- #ignoreDups=True,
- indexList=True)
- mesh.update()
-
-def objectAddMirrorModifier(mesh_object):
- return mesh_object.modifiers.append(Blender.Modifier.Types.MIRROR)
-
-def faceSetNormal(face, normal):
- face.no=normal
-
-def getTexture(m, dirname):
- tex=""
- aplane=""
- # texture
- for texture in m.getTextures():
- if texture and texture.tex and texture.tex.getImage():
- image=texture.tex.getImage()
- if not image:
- continue
- imagePath=Blender.sys.expandpath(image.getFilename())
- if len(dirname)>0 and imagePath.startswith(dirname):
- # 相対パスに変換する
- imagePath=imagePath[len(dirname)+1:len(imagePath)]
- if texture.mtCol>0:
- tex=" tex(\"%s\")" % imagePath
- elif texture.mtAlpha>0:
- aplane=" aplane(\"%s\")" % imagePath
- return tex, aplane
-
-def objectDuplicate(scene, obj):
- mesh, dumy=createMesh(scene, obj.name.decode(INTERNAL_ENCODING))
- # not apply modifiers
- mesh.getFromObject(obj.name, 1)
- # apply matrix
- dumy.setMatrix(obj.matrixWorld)
- return mesh, dumy
-
-def objectDelete(scene, obj):
- scene.objects.unlink(obj)
-
-def faceVertexCount(face):
- return len(face.v)
-
-def faceVertices(face):
- # flip
- return [v.index for v in reversed(face.v)]
-
-def meshHasUV(mesh):
- return mesh.faceUV
-
-def faceHasUV(mesh, i, face):
- return len(face.uv)>0
-
-def faceGetUV(mesh, i, face, count):
- # flip
- return reversed(face.uv)
-
-def faceSetMaterial(face, material_index):
- face.mat=material_index
-
-def faceSetSmooth(face, isSmooth):
- face.smooth=1 if isSmooth else 0
-
-def faceSetUv(face, uv_array):
- face.uv=uv_array
-
-def materialToMqo(m):
- return "\"%s\" shader(3) col(%f %f %f %f)" % (
- m.name, m.rgbCol[0], m.rgbCol[1], m.rgbCol[2], m.alpha)
-
-def faceMaterialIndex(face):
- return face.mat
-
-def objectGetData(o):
- return o.getData(mesh=True)
-
-def objectAddArmatureModifier(o, armature_object):
- mod=o.modifiers.append(Blender.Modifier.Types.ARMATURE)
- mod[Blender.Modifier.Settings.OBJECT] = armature_object
- mod[Blender.Modifier.Settings.ENVELOPES] = False
-
-def objectSelect(o):
- o.select(True)
-
-def objectGetPose(o):
- return o.getPose()
-
-def poseBoneLimit(n, b):
- if n.endswith("_t"):
- return
- if n.startswith("knee_"):
- b.lockYRot=True
- b.lockZRot=True
- b.limitX=True
- b.limitMin=[0, 0, 0]
- b.limitMax=[180, 0, 0]
- elif n.startswith("ankle_"):
- b.lockYRot=True
-
-def enterEditMode():
- Blender.Window.EditMode(1)
-
-def exitEditMode():
- Blender.Window.EditMode(0)
-
-def objectDeselectAll():
- for o in bpy.data.scenes.active.objects:
- o.select(False)
-
-def objectActivate(scene, o):
- o.select(True )
- scene.objects.active=o
-
-def objectGetActive(scene):
- return scene.objects.active
-
-def meshAddVertexGroup(meshObject, name):
- meshObject.getData(mesh=True).addVertGroup(name)
-
-def meshUseVertexUv(mesh):
- mesh.vertexUV = 1
-
-def vertexSetNormal(mvert, normal):
- mvert.no=Mathutils.Vector(*normal)
-
-def vertexSetUv(mvert, uv):
- mvert.uvco=uv
-
-def meshAssignVertexGroup(meshObject, name, index, weight):
- meshObject.getData(mesh=True).assignVertsToGroup(name,
- [index], weight, Blender.Mesh.AssignModes.ADD)
-
-def meshAddUV(mesh):
- mesh.addUVLayer('NewUV')
-
-def meshVertsDelete(mesh, remove_vertices):
- mesh.verts.delete(remove_vertices)
-
-def createArmature(scene):
- armature = Blender.Armature.New()
- armature_object = scene.objects.new(armature)
-
- # set XRAY
- armature_object.drawMode = (
- armature_object.drawMode | Blender.Object.DrawModes.XRAY)
- # armature settings
- armature.drawType = Blender.Armature.OCTAHEDRON
- armature.drawNames=True
- armature.envelopes = False
- armature.vertexGroups = True
- armature.mirrorEdit = True
-
- return armature, armature_object
-
-def armatureMakeEditable(scene, armature_object):
- # create armature
- armature_object.getData().makeEditable()
-
-def createIkConstraint(armature_object, p_bone, effector_name, ik):
- cSetting = Blender.Constraint.Settings
- # IK solver
- constraint = p_bone.constraints.append(Blender.Constraint.Type.IKSOLVER)
- constraint[cSetting.CHAINLEN]=len(ik.children)
- constraint[cSetting.TARGET]=armature_object
- constraint[cSetting.USETIP]=False
- constraint[cSetting.BONE]=effector_name
- # not used. place folder when export.
- constraint[cSetting.ROTWEIGHT]=ik.weight
- constraint[cSetting.ITERATIONS]=ik.iterations * 10
- return constraint
-
-def createArmatureBone(armature, name):
- bone=Blender.Armature.Editbone()
- bone.name=name.encode(INTERNAL_ENCODING)
- armature.bones[name]=bone
- return bone
-
-def boneSetConnected(bone):
- bone.options+=[Blender.Armature.CONNECTED]
-
-def createVector(x, y, z):
- return Mathutils.Vector(x, y, z)
-
-def armatureUpdate(armature):
- armature.update()
-
-def boneLayerMask(bone, layers):
- mask=0
- for i, enable in enumerate(layers):
- if enable!=0:
- mask+=(1<<i)
- bone.layerMask=mask
-
-def objectLayerMask(object, layers):
- mask=0
- for i, enable in enumerate(layers):
- if enable!=0:
- mask+=(1<<i)
- object.Layers=mask
-
-def objectPinShape(o):
- o.pinShape=True
-
-def objectAddShapeKey(o, name):
- mesh=o.getData(mesh=True)
- mesh.insertKey()
- block=mesh.key.blocks[-1]
- block.name=name.encode(INTERNAL_ENCODING)
- return block
-
-def objectActivateShapeKey(o, index):
- o.activeShape=index
-
-def shapeKeyAssign(shapeKey, index, pos):
- shapeKey.data[index]=pos
-
-def objectIsVisible(obj):
- return obj.restrictDisplay
-
-def meshVertexGroupNames(meshObject):
- return meshObject.getData(mesh=True).getVertGroupNames()
-
-def faceNormal(face):
- return face.no
-
-def meshGetFaceUv(mesh, i, face):
- return face.uv
-
-def meshSetFaceUv(mesh, i, face, uv_array, image):
- face.uv=[Mathutils.Vector(uv[0], uv[1]) for uv in uv_array]
- if image:
- face.image=image
-
-
-def armatureModifierGetObject(m):
- return m[Blender.Modifier.Settings.OBJECT]
-
-def objectHasShapeKey(o):
- return o.getData(mesh=True).key
-
-def objectShapeKeys(o):
- return o.getData(mesh=True).key.blocks
-
-def meshVertexGroup(meshObject, name):
- indices=[]
- for index in meshObject.getData(mesh=True).getVertsFromGroup(name):
- indices.append(index)
- return indices
-
-def materialGet(scene, material_name):
- return Blender.Material.Get(material_name)
-
-def modifierIsArmature(m):
- return m.name=="Armature"
-
-def boneHeadLocal(b):
- return b.head['ARMATURESPACE'][0:3]
-
-def boneTailLocal(b):
- return b.tail['ARMATURESPACE'][0:3]
-
-def boneIsConnected(b):
- return Blender.Armature.CONNECTED in b.options
-
-def constraintIsIKSolver(c):
- return c.type==Blender.Constraint.Type.IKSOLVER
-
-def ikChainLen(c):
- return c[Blender.Constraint.Settings.CHAINLEN]
-
-def ikTarget(c):
- return c[Blender.Constraint.Settings.BONE]
-
-def ikItration(c):
- return c[Blender.Constraint.Settings.ITERATIONS]
-
-def ikRotationWeight(c):
- return c[Blender.Constraint.Settings.ROTWEIGHT]
-
-def shapeKeyGet(b, index):
- return b.data[index]
-
-def shapeKeys(b):
- return b.data
-
-def meshSetSmooth(mesh, smoothing):
- mesh.mode |= Blender.Mesh.Modes.AUTOSMOOTH
- mesh.degr=int(smoothing)
- #mesh.smooth()
-
-def meshRecalcNormals(mesh_object):
- mesh=mesh_object.getData(mesh=True)
- mesh.calcNormals()
-
-def meshFlipNormals(mesh):
- mesh.flipNormals()
-
-def faceGetIndices(face):
- return [face.verts[0].index, face.verts[1].index, face.verts[2].index]
+class scene:
+ @staticmethod
+ def update(scene):
+ scene.update(0)
+
+
+class object:
+ @staticmethod
+ def createEmpty(name):
+ global SCENE
+ empty=SCENE.objects.new("Empty")
+ empty.setName(name)
+ return empty
+
+ @staticmethod
+ def makeParent(parent, child):
+ parent.makeParent([child])
+
+ @staticmethod
+ def duplicate(o):
+ new_mesh, new_object=mesh.create(o.name.decode(INTERNAL_ENCODING))
+ # not apply modifiers
+ new_mesh.getFromObject(o.name, 1)
+ # apply matrix
+ #o.setMatrix(o.matrixWorld)
+ return new_mesh, new_object
+
+ @staticmethod
+ def delete(o):
+ global SCENE
+ SCENE.objects.unlink(o)
+
+ @staticmethod
+ def getData(o):
+ return o.getData(mesh=True)
+
+ @staticmethod
+ def select(o):
+ o.select(True)
+
+ @staticmethod
+ def activate(o):
+ global SCENE
+ o.select(True )
+ SCENE.objects.active=o
+
+ @staticmethod
+ def getActive():
+ global SCENE
+ return SCENE.objects.active
+
+ @staticmethod
+ def deselectAll():
+ for o in bpy.data.scenes.active.objects:
+ o.select(False)
+
+ @staticmethod
+ def setLayerMask(o, layers):
+ mask=0
+ for i, enable in enumerate(layers):
+ if enable!=0:
+ mask+=(1<<i)
+ o.Layers=mask
+
+ @staticmethod
+ def isVisible(o):
+ return o.restrictDisplay
+
+ @staticmethod
+ def getShapeKeys(o):
+ return o.getData(mesh=True).key.blocks
+
+ @staticmethod
+ def addShapeKey(o, name):
+ mesh=o.getData(mesh=True)
+ mesh.insertKey()
+ block=mesh.key.blocks[-1]
+ block.name=name.encode(INTERNAL_ENCODING)
+ return block
+
+ @staticmethod
+ def hasShapeKey(o):
+ return o.getData(mesh=True).key
+
+ @staticmethod
+ def pinShape(o, enable):
+ o.pinShape=enable
+
+ @staticmethod
+ def setActivateShapeKey(o, index):
+ o.activeShape=index
+
+ @staticmethod
+ def getPose(o):
+ return o.getPose()
+
+ @staticmethod
+ def addVertexGroup(o, name):
+ o.getData(mesh=True).addVertGroup(name)
+
+ @staticmethod
+ def assignVertexGroup(o, name, index, weight):
+ o.getData(mesh=True).assignVertsToGroup(name,
+ [index], weight, Blender.Mesh.AssignModes.ADD)
+
+ @staticmethod
+ def getVertexGroupNames(o):
+ return o.getData(mesh=True).getVertGroupNames()
+
+ @staticmethod
+ def getVertexGroup(o, name):
+ indices=[]
+ for index in o.getData(mesh=True).getVertsFromGroup(name):
+ indices.append(index)
+ return indices
+
+
+class modifier:
+ @staticmethod
+ def addMirror(mesh_object):
+ return mesh_object.modifiers.append(Blender.Modifier.Types.MIRROR)
+
+ @staticmethod
+ def addArmature(mesh_object, armature_object):
+ mod=mesh_object.modifiers.append(Blender.Modifier.Types.ARMATURE)
+ mod[Blender.Modifier.Settings.OBJECT] = armature_object
+ mod[Blender.Modifier.Settings.ENVELOPES] = False
+
+ @staticmethod
+ def hasType(mesh_object, type_name):
+ for mod in mesh_object.modifiers:
+ if mod.name.upper()==type_name.upper():
+ return True
+
+ @staticmethod
+ def isType(m, type_name):
+ return m.name.upper()==type_name.upper()
+
+ @staticmethod
+ def getArmatureObject(m):
+ return m[Blender.Modifier.Settings.OBJECT]
+
+
+class shapekey:
+ @staticmethod
+ def assign(b, index, pos):
+ b.data[index]=pos
+
+ @staticmethod
+ def getByIndex(b, index):
+ return b.data[index]
+
+ @staticmethod
+ def get(b):
+ return b.data
+
+
+class texture:
+ @staticmethod
+ def create(path):
+ image = Blender.Image.Load(path.encode(INTERNAL_ENCODING))
+ texture = Blender.Texture.New(path.encode(INTERNAL_ENCODING))
+ texture.type = Blender.Texture.Types.IMAGE
+ texture.image = image
+ texture.imageFlags|=Blender.Texture.ImageFlags.USEALPHA
+ return texture, image
+
+
+class material:
+ @staticmethod
+ def create(name):
+ m = Blender.Material.New(name)
+ return m
+
+ @staticmethod
+ def get(material_name):
+ return Blender.Material.Get(material_name)
+
+ @staticmethod
+ def addTexture(material, texture):
+ material.mode = material.mode | Blender.Material.Modes.TEXFACE
+ material.setTexture(0, texture, Blender.Texture.TexCo.UV)
+
+ @staticmethod
+ def hasTexture(material):
+ return len(material.getTextures())>0
+
+ @staticmethod
+ def getTexturePath(m, dirname):
+ tex=""
+ aplane=""
+ # texture
+ for texture in m.getTextures():
+ if texture and texture.tex and texture.tex.getImage():
+ image=texture.tex.getImage()
+ if not image:
+ continue
+ imagePath=Blender.sys.expandpath(image.getFilename())
+ if len(dirname)>0 and imagePath.startswith(dirname):
+ # 相対パスに変換する
+ imagePath=imagePath[len(dirname)+1:len(imagePath)]
+ if texture.mtCol>0:
+ tex=" tex(\"%s\")" % imagePath
+ elif texture.mtAlpha>0:
+ aplane=" aplane(\"%s\")" % imagePath
+ return tex, aplane
+
+
+class mesh:
+ @staticmethod
+ def create(name):
+ global SCENE
+ m=Blender.Mesh.New()
+ o=SCENE.objects.new(m, name.encode(INTERNAL_ENCODING))
+ return m, o
+
+ @staticmethod
+ def addGeometry(m, vertices, faces):
+ m.verts.extend(vertices)
+ new_faces=m.faces.extend(faces,
+ #ignoreDups=True,
+ indexList=True)
+ m.update()
+
+ @staticmethod
+ def hasUV(m):
+ return m.faceUV
+
+ @staticmethod
+ def useVertexUV(m):
+ m.vertexUV = 1
+
+ @staticmethod
+ def addUV(m):
+ m.addUVLayer('NewUV')
+
+ @staticmethod
+ def hasFaceUV(m, i, face):
+ return len(face.uv)>0
+
+ @staticmethod
+ def getFaceUV(m, i, face, count=3):
+ return face.uv
+
+ @staticmethod
+ def setFaceUV(m, i, face, uv_array, image):
+ face.uv=[Mathutils.Vector(uv[0], uv[1]) for uv in uv_array]
+ if image:
+ face.image=image
+
+ @staticmethod
+ def vertsDelete(m, remove_vertices):
+ m.verts.delete(remove_vertices)
+
+ @staticmethod
+ def setSmooth(m, smoothing):
+ m.mode |= Blender.Mesh.Modes.AUTOSMOOTH
+ m.degr=int(smoothing)
+ #m.smooth()
+
+ @staticmethod
+ def recalcNormals(mesh_object):
+ m=mesh_object.getData(mesh=True)
+ m.calcNormals()
+
+ @staticmethod
+ def flipNormals(m):
+ m.flipNormals()
+
+ @staticmethod
+ def addMaterial(m, material):
+ m.materials+=[material]
+
+
+class vertex:
+ @staticmethod
+ def setNormal(mvert, normal):
+ mvert.no=Mathutils.Vector(*normal)
+
+ @staticmethod
+ def setUv(mvert, uv):
+ mvert.uvco=uv
+
+
+class face:
+ @staticmethod
+ def getVertexCount(face):
+ return len(face.v)
+
+ @staticmethod
+ def getVertices(face):
+ return [v.index for v in face.v]
+
+ @staticmethod
+ def getIndices(face):
+ return [face.verts[0].index, face.verts[1].index, face.verts[2].index]
+
+ @staticmethod
+ def setMaterial(face, material_index):
+ face.mat=material_index
+
+ @staticmethod
+ def getMaterialIndex(face):
+ return face.mat
+
+ @staticmethod
+ def setNormal(face, normal):
+ face.no=normal
+
+ @staticmethod
+ def getNormal(face):
+ return face.no
+
+ @staticmethod
+ def setSmooth(face, isSmooth):
+ face.smooth=1 if isSmooth else 0
+
+
+class armature:
+ @staticmethod
+ def create():
+ global SCENE
+ armature = Blender.Armature.New()
+ armature_object = SCENE.objects.new(armature)
+
+ # set XRAY
+ armature_object.drawMode = (
+ armature_object.drawMode | Blender.Object.DrawModes.XRAY)
+ # armature settings
+ armature.drawType = Blender.Armature.OCTAHEDRON
+ armature.drawNames=True
+ armature.envelopes = False
+ armature.vertexGroups = True
+ armature.mirrorEdit = True
+
+ return armature, armature_object
+
+ @staticmethod
+ def makeEditable(armature_object):
+ # create armature
+ armature_object.getData().makeEditable()
+
+ @staticmethod
+ def createIkConstraint(armature_object, p_bone, effector_name, ik):
+ cSetting = Blender.Constraint.Settings
+ # IK solver
+ constraint = p_bone.constraints.append(Blender.Constraint.Type.IKSOLVER)
+ constraint[cSetting.CHAINLEN]=len(ik.children)
+ constraint[cSetting.TARGET]=armature_object
+ constraint[cSetting.USETIP]=False
+ constraint[cSetting.BONE]=effector_name
+ # not used. place folder when export.
+ constraint[cSetting.ROTWEIGHT]=ik.weight
+ constraint[cSetting.ITERATIONS]=ik.iterations * 10
+ return constraint
+
+ @staticmethod
+ def createBone(armature_object, name):
+ bone=Blender.Armature.Editbone()
+ bone.name=name.encode(INTERNAL_ENCODING)
+ armature_object.bones[name]=bone
+ return bone
+
+ @staticmethod
+ def update(armature):
+ armature.update()
+
+
+class bone:
+ @staticmethod
+ def setConnected(bone):
+ bone.options+=[Blender.Armature.CONNECTED]
+
+ @staticmethod
+ def isConnected(b):
+ return Blender.Armature.CONNECTED in b.options
+
+ @staticmethod
+ def setLayerMask(bone, layers):
+ mask=0
+ for i, enable in enumerate(layers):
+ if enable!=0:
+ mask+=(1<<i)
+ bone.layerMask=mask
+
+ @staticmethod
+ def getHeadLocal(b):
+ return b.head['ARMATURESPACE'][0:3]
+
+ @staticmethod
+ def getTailLocal(b):
+ return b.tail['ARMATURESPACE'][0:3]
+
+
+class constraint:
+ @staticmethod
+ def ikChainLen(c):
+ return c[Blender.Constraint.Settings.CHAINLEN]
+
+ @staticmethod
+ def ikTarget(c):
+ return c[Blender.Constraint.Settings.BONE]
+
+ @staticmethod
+ def ikItration(c):
+ return c[Blender.Constraint.Settings.ITERATIONS]
+
+ @staticmethod
+ def ikRotationWeight(c):
+ return c[Blender.Constraint.Settings.ROTWEIGHT]
+
+ @staticmethod
+ def isIKSolver(c):
+ return c.type==Blender.Constraint.Type.IKSOLVER
-def internalToCp932(s):
- return s.decode(INTERNAL_ENCODING).encode('cp932')
# coding: utf-8
-import bpy
-import mathutils
-
import os
import sys
import time
import functools
+try:
+ import bpy
+ import mathutils
+except:
+ pass
+
# \e$B%U%!%$%k%7%9%F%`$NJ8;z%3!<%I\e(B
# \e$B2~B$HG$H$N6&MQ$N$?$a\e(B
FS_ENCODING=sys.getfilesystemencoding()
else:
INTERNAL_ENCODING=FS_ENCODING
+SCENE=None
+def initialize(name, scene):
+ global SCENE
+ SCENE=scene
+ progress_start(name)
+
+def finalize():
+ scene.update(SCENE)
+ progress_finish()
+
+def message(msg):
+ pass
+
+def enterEditMode():
+ bpy.ops.object.mode_set(mode='EDIT', toggle=False)
+
+def exitEditMode():
+ bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+def createVector(x, y, z):
+ return mathutils.Vector([x, y, z])
+
+
+class Writer(object):
+ '''
+ io wrapper
+ '''
+ def __init__(self, path, encoding):
+ self.io=open(path, "wb")
+ self.encoding=encoding
+
+ def write(self, s):
+ self.io.write(s.encode(self.encoding))
+
+ def flush(self):
+ self.io.flush()
+
+ def close(self):
+ self.io.close()
+
-###############################################################################
-# ProgressBar
-###############################################################################
class ProgressBar(object):
+ '''
+ progress bar wrapper
+ '''
def __init__(self, base):
print("#### %s ####" % base)
self.base=base
progressBar.set(message, progress)
-###############################################################################
-class Writer(object):
- def __init__(self, path, encoding):
- self.io=open(path, "wb")
- self.encoding=encoding
-
- def write(self, s):
- self.io.write(s.encode(self.encoding))
-
- def flush(self):
- self.io.flush()
-
- def close(self):
- self.io.close()
-
-###############################################################################
-def createEmptyObject(scene, name):
- empty=bpy.data.objects.new(name, None)
- scene.objects.link(empty)
- return empty
-
-def createMaterial(name):
- material = bpy.data.materials.new(name)
- return material
-
-def createMqoMaterial(m):
- material = bpy.data.materials.new(m.getName())
- material.diffuse_color=[m.color.r, m.color.g, m.color.b]
- material.alpha=m.color.a
- material.diffuse_intensity=m.diffuse
- return material
-
-def createPmdMaterial(m):
- material = bpy.data.materials.new("Material")
- material.diffuse_shader='FRESNEL'
- material.specular_shader='TOON'
- material.diffuse_color=([m.diffuse.r, m.diffuse.g, m.diffuse.b])
- material.alpha=m.diffuse.a
- material.specular_hardness=int(m.shinness)
- material.specular_color=([m.specular.r, m.specular.g, m.specular.b])
- material.mirror_color=([m.ambient.r, m.ambient.g, m.ambient.b])
- material.subsurface_scattering.enabled=True if m.flag==1 else False
- return material
-
-def createTexture(path):
- texture=bpy.data.textures.new(os.path.basename(path))
- texture.type='IMAGE'
- texture=texture.recast_type()
- image=bpy.data.images.load(path)
- texture.image=image
- texture.mipmap = True
- texture.interpolation = True
- texture.use_alpha = True
- return texture, image
-
-
-def materialAddTexture(material, texture):
- #material.add_texture(texture, "UV", {"COLOR", "ALPHA"})
- material.add_texture(texture, "UV", "COLOR")
-
-
-def meshAddMaterial(mesh, material):
- mesh.add_material(material)
-
-
-def createMesh(scene, name):
- mesh=bpy.data.meshes.new("Mesh")
- mesh_object= bpy.data.objects.new(name, mesh)
- scene.objects.link(mesh_object)
- return mesh, mesh_object
-
-
-def objectMakeParent(parent, child):
- child.parent=parent
-
-def objectAddMirrorModifier(mesh_object):
- return mesh_object.modifiers.new("Modifier", "MIRROR")
-
-def meshAddGeometry(mesh, vertices, faces):
- mesh.from_pydata(vertices, [], faces)
- """
- mesh.add_geometry(len(vertices), 0, len(faces))
- # add vertex
- unpackedVertices=[]
- for v in vertices:
- unpackedVertices.extend(v)
- mesh.verts.foreach_set("co", unpackedVertices)
- # add face
- unpackedFaces = []
- for face in faces:
- if len(face) == 4:
- if face[3] == 0:
- # rotate indices if the 4th is 0
- face = [face[3], face[0], face[1], face[2]]
- elif len(face) == 3:
- if face[2] == 0:
- # rotate indices if the 3rd is 0
- face = [face[2], face[0], face[1], 0]
- else:
- face.append(0)
- unpackedFaces.extend(face)
- mesh.faces.foreach_set("verts_raw", unpackedFaces)
- """
- assert(len(vertices)==len(mesh.verts))
- assert(len(faces)==len(mesh.faces))
-
-def meshSetFaceUv(mesh, i, face, uv_array, image):
- uv_face=mesh.uv_textures[0].data[i]
- uv_face.uv=uv_array
- if image:
- uv_face.image=image
- uv_face.tex=True
-
-def faceSetMaterial(face, material_index):
- face.material_index=material_index
-
-def faceSetSmooth(face, isSmooth):
- face.smooth=True if isSmooth else False
-
-def getTexture(m, dirname):
- tex=""
- aplane=""
- # texture
- for slot in m.texture_slots:
- if slot and slot.texture:
- texture=slot.texture
- if texture.type=="IMAGE":
- image=texture.image
- if not image:
- continue
- imagePath=image.filename
- if len(dirname)>0 and imagePath.startswith(dirname):
- # \e$BAjBP%Q%9$KJQ49$9$k\e(B
- imagePath=imagePath[len(dirname)+1:len(imagePath)]
- #imagePath=Blender.sys.expandpath(
- # imagePath).replace("\\", '/')
- if slot.map_colordiff:
- tex=" tex(\"%s\")" % imagePath
- elif slot.map_alpha:
- aplane=" aplane(\"%s\")" % imagePath
- return tex, aplane
-
-def objectDuplicate(scene, obj):
- bpy.ops.object.select_all(action='DESELECT')
- obj.selected=True
- scene.objects.active=obj
- bpy.ops.object.duplicate()
- dumy=scene.objects.active
- bpy.ops.object.rotation_apply()
- bpy.ops.object.scale_apply()
- bpy.ops.object.location_apply()
- return dumy.data, dumy
-
-def objectDelete(scene, obj):
- scene.objects.unlink(obj)
-
-def faceVertexCount(face):
- return len(face.verts)
-
-def faceVertices(face):
- return face.verts[:]
-
-def meshHasUV(mesh):
- return mesh.active_uv_texture
-
-def faceHasUV(mesh, i, face):
- return mesh.active_uv_texture.data[i]
-
-def faceGetUV(mesh, i, faces, count):
- uvFace=mesh.active_uv_texture.data[i]
- if count==3:
- return (uvFace.uv1, uvFace.uv2, uvFace.uv3)
- elif count==4:
- return (uvFace.uv1, uvFace.uv2, uvFace.uv3, uvFace.uv4)
- else:
- print(count)
- assert(False)
-
-def materialToMqo(m):
- return "\"%s\" shader(3) col(%f %f %f %f)" % (
- m.name,
- m.diffuse_color[0], m.diffuse_color[1], m.diffuse_color[2],
- m.alpha)
-
-def faceMaterialIndex(face):
- return face.material_index
-
-def objectGetData(o):
- return o.data
-
-def objectAddArmatureModifier(o, armature_object):
- mod=o.modifiers.new("Modifier", "ARMATURE")
- mod.object = armature_object
- mod.use_bone_envelopes=False
-
-def objectSelect(o):
- o.selected=True
-
-def objectGetPose(o):
- return o.pose
-
-def poseBoneLimit(n, b):
- if n.endswith("_t"):
- return
- if n.startswith("knee_"):
- b.ik_dof_y=False
- b.ik_dof_z=False
- b.ik_dof_x=True
- b.ik_limit_x=True
- b.ik_min_x=0
- b.ik_max_x=180
- elif n.startswith("ankle_"):
- #b.ik_dof_y=False
+class scene:
+ @staticmethod
+ def update(scene):
+ scene.update()
+
+
+class object:
+ @staticmethod
+ def createEmpty(name):
+ global SCENE
+ empty=bpy.data.objects.new(name, None)
+ SCENE.objects.link(empty)
+ return empty
+
+ @staticmethod
+ def makeParent(parent, child):
+ child.parent=parent
+
+ @staticmethod
+ def duplicate(o):
+ global SCENE
+ bpy.ops.object.select_all(action='DESELECT')
+ o.selected=True
+ SCENE.objects.active=o
+ bpy.ops.object.duplicate()
+ dumy=SCENE.objects.active
+ #bpy.ops.object.rotation_apply()
+ #bpy.ops.object.scale_apply()
+ #bpy.ops.object.location_apply()
+ return dumy.data, dumy
+
+ @staticmethod
+ def delete(o):
+ global SCENE
+ SCENE.objects.unlink(o)
+
+ @staticmethod
+ def getData(o):
+ return o.data
+
+ @staticmethod
+ def select(o):
+ o.selected=True
+
+ @staticmethod
+ def activate(o):
+ global SCENE
+ o.selected=True
+ SCENE.objects.active=o
+
+ @staticmethod
+ def getActive():
+ global SCENE
+ return SCENE.objects.active
+
+ @staticmethod
+ def deselectAll():
+ bpy.ops.object.select_all(action='DESELECT')
+
+ @staticmethod
+ def setLayerMask(object, layers):
+ layer=[]
+ for i in range(20):
+ try:
+ layer.append(True if layers[i]!=0 else False)
+ except IndexError:
+ layer.append(False)
+ object.layers=layer
+
+ @staticmethod
+ def isVisible(o):
+ return o.restrict_view
+
+ @staticmethod
+ def getShapeKeys(o):
+ return o.data.shape_keys.keys
+
+ @staticmethod
+ def addShapeKey(o, name):
+ return o.add_shape_key(name)
+
+ @staticmethod
+ def hasShapeKey(o):
+ return o.data.shape_keys
+
+ @staticmethod
+ def pinShape(o, enable):
+ o.shape_key_lock=enable
+
+ @staticmethod
+ def setActivateShapeKey(o, index):
+ o.active_shape_key_index=index
+
+ @staticmethod
+ def getPose(o):
+ return o.pose
+
+ @staticmethod
+ def getVertexGroup(o, name):
+ indices=[]
+ for i, v in enumerate(o.data.verts):
+ for g in v.groups:
+ if o.vertex_groups[g.group].name==name:
+ indices.append(i)
+ return indices
+
+ @staticmethod
+ def getVertexGroupNames(o):
+ for g in o.vertex_groups:
+ yield g.name
+
+ @staticmethod
+ def addVertexGroup(o, name):
+ o.add_vertex_group(name)
+
+ @staticmethod
+ def assignVertexGroup(o, name, index, weight):
+ o.add_vertex_to_group(index,
+ o.vertex_groups[name], weight, 'ADD')
+
+
+class modifier:
+ @staticmethod
+ def addMirror(mesh_object):
+ return mesh_object.modifiers.new("Modifier", "MIRROR")
+
+ @staticmethod
+ def addArmature(mesh_object, armature_object):
+ mod=mesh_object.modifiers.new("Modifier", "ARMATURE")
+ mod.object = armature_object
+ mod.use_bone_envelopes=False
+
+ @staticmethod
+ def hasType(mesh_object, type_name):
+ for mod in mesh_object.modifiers:
+ if mod.type==type_name.upper():
+ return True
+
+ @staticmethod
+ def isType(m, type_name):
+ return m.type==type_name.upper()
+
+ @staticmethod
+ def getArmatureObject(m):
+ return m.object
+
+
+class shapekey:
+ @staticmethod
+ def assign(shapeKey, index, pos):
+ shapeKey.data[index].co=pos
+
+ @staticmethod
+ def getByIndex(b, index):
+ return b.data[index].co
+
+ @staticmethod
+ def get(b):
+ for k in b.data:
+ yield k.co
+
+
+class texture:
+ @staticmethod
+ def create(path):
+ texture=bpy.data.textures.new(os.path.basename(path))
+ texture.type='IMAGE'
+ texture=texture.recast_type()
+ image=bpy.data.images.load(path)
+ texture.image=image
+ texture.mipmap = True
+ texture.interpolation = True
+ texture.use_alpha = True
+ return texture, image
+
+
+class material:
+ @staticmethod
+ def create(name):
+ return bpy.data.materials.new(name)
+
+ @staticmethod
+ def get(material_name):
+ return bpy.data.materials[material_name]
+
+ @staticmethod
+ def addTexture(material, texture):
+ #material.add_texture(texture, "UV", {"COLOR", "ALPHA"})
+ material.add_texture(texture, "UV", "COLOR")
+
+ @staticmethod
+ def hasTexture(material):
+ return material.texture_slots[0]
+
+ @staticmethod
+ def getTexturePath(m, dirname):
+ tex=""
+ aplane=""
+ # texture
+ for slot in m.texture_slots:
+ if slot and slot.texture:
+ texture=slot.texture
+ if texture.type=="IMAGE":
+ image=texture.image
+ if not image:
+ continue
+ imagePath=image.filename
+ if len(dirname)>0 and imagePath.startswith(dirname):
+ # \e$BAjBP%Q%9$KJQ49$9$k\e(B
+ imagePath=imagePath[len(dirname)+1:len(imagePath)]
+ #imagePath=Blender.sys.expandpath(
+ # imagePath).replace("\\", '/')
+ if slot.map_colordiff:
+ tex=" tex(\"%s\")" % imagePath
+ elif slot.map_alpha:
+ aplane=" aplane(\"%s\")" % imagePath
+ return tex, aplane
+
+
+class mesh:
+ @staticmethod
+ def create(name):
+ global SCENE
+ mesh=bpy.data.meshes.new("Mesh")
+ mesh_object= bpy.data.objects.new(name, mesh)
+ SCENE.objects.link(mesh_object)
+ return mesh, mesh_object
+
+ @staticmethod
+ def addGeometry(mesh, vertices, faces):
+ mesh.from_pydata(vertices, [], faces)
+ """
+ mesh.add_geometry(len(vertices), 0, len(faces))
+ # add vertex
+ unpackedVertices=[]
+ for v in vertices:
+ unpackedVertices.extend(v)
+ mesh.verts.foreach_set("co", unpackedVertices)
+ # add face
+ unpackedFaces = []
+ for face in faces:
+ if len(face) == 4:
+ if face[3] == 0:
+ # rotate indices if the 4th is 0
+ face = [face[3], face[0], face[1], face[2]]
+ elif len(face) == 3:
+ if face[2] == 0:
+ # rotate indices if the 3rd is 0
+ face = [face[2], face[0], face[1], 0]
+ else:
+ face.append(0)
+ unpackedFaces.extend(face)
+ mesh.faces.foreach_set("verts_raw", unpackedFaces)
+ """
+ assert(len(vertices)==len(mesh.verts))
+ assert(len(faces)==len(mesh.faces))
+
+ @staticmethod
+ def hasUV(mesh):
+ return mesh.active_uv_texture
+
+ @staticmethod
+ def useVertexUV(mesh):
pass
-def enterEditMode():
- bpy.ops.object.mode_set(mode='EDIT', toggle=False)
-
-def exitEditMode():
- bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
-
-def objectDeselectAll():
- bpy.ops.object.select_all(action='DESELECT')
-
-def objectActivate(scene, o):
- o.selected=True
- scene.objects.active=o
-
-def objectGetActive(scene):
- return scene.objects.active
-
-def meshAddVertexGroup(meshObject, name):
- meshObject.add_vertex_group(name)
-
-def vertexSetNormal(mvert, normal):
- mvert.normal=mathutils.Vector(normal)
-
-def faceSetNormal(face, normal):
- face.normal=normal
-
-def meshUseVertexUv(mesh):
- pass
-
-def vertexSetUv(mvert, uv):
- pass
-
-def meshAssignVertexGroup(meshObject, name, index, weight):
- meshObject.add_vertex_to_group(index,
- meshObject.vertex_groups[name], weight, 'ADD')
-
-def meshAddUV(mesh):
- mesh.add_uv_texture()
-
-def meshVertsDelete(mesh, remove_vertices):
- enterEditMode()
- bpy.ops.mesh.select_all(action='DESELECT')
- exitEditMode()
-
- for i in remove_vertices:
- mesh.verts[i].selected=True
-
- enterEditMode()
- bpy.ops.mesh.delete(type='VERT')
- exitEditMode()
-
-def createArmature(scene):
- armature = bpy.data.armatures.new('Armature')
- armature_object=bpy.data.objects.new('Armature', armature)
- scene.objects.link(armature_object)
-
- armature_object.x_ray=True
- armature.draw_names=True
- armature.drawtype='OCTAHEDRAL'
- armature.deform_envelope=False
- armature.deform_vertexgroups=True
- armature.x_axis_mirror=True
-
- return armature, armature_object
-
-def armatureMakeEditable(scene, armature_object):
- # select only armature object and set edit mode
- scene.objects.active=armature_object
- bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
- bpy.ops.object.mode_set(mode='EDIT', toggle=False)
-
-def createIkConstraint(armature_object, p_bone, effector_name, ik):
- constraint = p_bone.constraints.new('IK')
- constraint.chain_length=len(ik.children)
- constraint.target=armature_object
- constraint.subtarget=effector_name
- constraint.use_tail=False
- # not used. place folder when export.
- constraint.weight=ik.weight
- constraint.iterations=ik.iterations * 10
- return constraint
-
-def createArmatureBone(armature, name):
- return armature.edit_bones.new(name)
-
-def boneSetConnected(bone):
- bone.connected=True
-
-def createVector(x, y, z):
- return mathutils.Vector([x, y, z])
-
-def armatureUpdate(armature):
- pass
-
-def boneLayerMask(bone, layers):
- layer=[]
- for i in range(32):
- try:
- layer.append(True if layers[i]!=0 else False)
- except IndexError:
- layer.append(False)
- bone.layer=layer
-
-def objectLayerMask(object, layers):
- layer=[]
- for i in range(20):
- try:
- layer.append(True if layers[i]!=0 else False)
- except IndexError:
- layer.append(False)
- object.layers=layer
-
-def objectPinShape(o):
- o.shape_key_lock=True
-
-def objectAddShapeKey(o, name):
- return o.add_shape_key(name)
-
-def objectActivateShapeKey(o, index):
- o.active_shape_key_index=index
-
-def shapeKeyAssign(shapeKey, index, pos):
- shapeKey.data[index].co=pos
-
-def objectIsVisible(obj):
- return obj.restrict_view
-
-def meshVertexGroupNames(meshObject):
- for g in meshObject.vertex_groups:
- yield g.name
-
-def faceNormal(face):
- return face.normal
-
-def meshFaceUv(mesh, i, face):
- return mesh.uv_textures[0].data[i].uv
-
-def armatureModifierGetObject(m):
- return m.object
-
-def objectHasShapeKey(o):
- return o.data.shape_keys
-
-def objectShapeKeys(o):
- return o.data.shape_keys.keys
-
-def meshVertexGroup(meshObject, name):
- indices=[]
- for i, v in enumerate(meshObject.data.verts):
- for g in v.groups:
- if meshObject.vertex_groups[g.group].name==name:
- indices.append(i)
- return indices
-
-def materialGet(scene, material_name):
- return bpy.data.materials[material_name]
-
-def modifierIsArmature(m):
- return m.type=="ARMATURE"
-
-def boneHeadLocal(b):
- return b.head_local[0:3]
-
-def boneTailLocal(b):
- return b.tail_local[0:3]
+ @staticmethod
+ def addUV(mesh):
+ mesh.add_uv_texture()
+
+ @staticmethod
+ def hasFaceUV(mesh, i, face):
+ return mesh.active_uv_texture.data[i]
+
+ @staticmethod
+ def getFaceUV(mesh, i, faces, count=3):
+ uvFace=mesh.active_uv_texture.data[i]
+ if count==3:
+ return (uvFace.uv1, uvFace.uv2, uvFace.uv3)
+ elif count==4:
+ return (uvFace.uv1, uvFace.uv2, uvFace.uv3, uvFace.uv4)
+ else:
+ print(count)
+ assert(False)
+
+ @staticmethod
+ def setFaceUV(mesh, i, face, uv_array, image):
+ uv_face=mesh.uv_textures[0].data[i]
+ uv_face.uv=uv_array
+ if image:
+ uv_face.image=image
+ uv_face.tex=True
+
+ @staticmethod
+ def vertsDelete(mesh, remove_vertices):
+ enterEditMode()
+ bpy.ops.mesh.select_all(action='DESELECT')
+ exitEditMode()
+
+ for i in remove_vertices:
+ mesh.verts[i].selected=True
+
+ enterEditMode()
+ bpy.ops.mesh.delete(type='VERT')
+ exitEditMode()
+
+ @staticmethod
+ def setSmooth(mesh, smoothing):
+ mesh.autosmooth_angle=int(smoothing)
+ mesh.autosmooth=True
+
+ @staticmethod
+ def recalcNormals(mesh_object):
+ bpy.ops.object.select_all(action='DESELECT')
+ object.activate(mesh_object)
+ enterEditMode()
+ bpy.ops.mesh.normals_make_consistent()
+ exitEditMode()
+
+ @staticmethod
+ def flipNormals(mesh):
+ mesh.flipNormals()
+
+ @staticmethod
+ def addMaterial(mesh, material):
+ mesh.add_material(material)
+
+
+class vertex:
+ @staticmethod
+ def setNormal(mvert, normal):
+ mvert.normal=mathutils.Vector(normal)
+
+ @staticmethod
+ def setUv(mvert, uv):
+ pass
-def boneIsConnected(b):
- return b.connected
-def constraintIsIKSolver(c):
- return c.type=='IK'
+class face:
+ @staticmethod
+ def getVertexCount(face):
+ return len(face.verts)
+
+ @staticmethod
+ def getVertices(face):
+ return face.verts[:]
+
+ @staticmethod
+ def getIndices(face):
+ return [face.verts[0], face.verts[1], face.verts[2]]
+
+ @staticmethod
+ def setMaterial(face, material_index):
+ face.material_index=material_index
+
+ @staticmethod
+ def getMaterialIndex(face):
+ return face.material_index
+
+ @staticmethod
+ def setNormal(face, normal):
+ face.normal=normal
+
+ @staticmethod
+ def getNormal(face):
+ return face.normal
+
+ @staticmethod
+ def setSmooth(face, isSmooth):
+ face.smooth=True if isSmooth else False
+
+
+class armature:
+ @staticmethod
+ def create():
+ global SCENE
+ armature = bpy.data.armatures.new('Armature')
+ armature_object=bpy.data.objects.new('Armature', armature)
+ SCENE.objects.link(armature_object)
+
+ armature_object.x_ray=True
+ armature.draw_names=True
+ armature.drawtype='OCTAHEDRAL'
+ armature.deform_envelope=False
+ armature.deform_vertexgroups=True
+ armature.x_axis_mirror=True
+
+ return armature, armature_object
+
+ @staticmethod
+ def makeEditable(armature_object):
+ global SCENE
+ # select only armature object and set edit mode
+ SCENE.objects.active=armature_object
+ bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+ bpy.ops.object.mode_set(mode='EDIT', toggle=False)
+
+ @staticmethod
+ def createIkConstraint(armature_object, p_bone, effector_name, ik):
+ constraint = p_bone.constraints.new('IK')
+ constraint.chain_length=len(ik.children)
+ constraint.target=armature_object
+ constraint.subtarget=effector_name
+ constraint.use_tail=False
+ # not used. place folder when export.
+ constraint.weight=ik.weight
+ constraint.iterations=ik.iterations * 10
+ return constraint
+
+ @staticmethod
+ def createBone(armature, name):
+ return armature.edit_bones.new(name)
+
+ @staticmethod
+ def update(armature):
+ pass
-def ikChainLen(c):
- return c.chain_length
-def ikTarget(c):
- return c.subtarget
+class bone:
+ @staticmethod
+ def setConnected(bone):
+ bone.connected=True
-def ikItration(c):
- return c.iterations
+ @staticmethod
+ def isConnected(b):
+ return b.connected
-def ikRotationWeight(c):
- return c.weight
+ @staticmethod
+ def setLayerMask(bone, layers):
+ layer=[]
+ for i in range(32):
+ try:
+ layer.append(True if layers[i]!=0 else False)
+ except IndexError:
+ layer.append(False)
+ bone.layer=layer
-def shapeKeyGet(b, index):
- return b.data[index].co
+ @staticmethod
+ def getHeadLocal(b):
+ return b.head_local[0:3]
-def shapeKeys(b):
- for k in b.data:
- yield k.co
+ @staticmethod
+ def getTailLocal(b):
+ return b.tail_local[0:3]
-def VtoV(v):
- return mathutils.Vector([v.x, v.y, v.z])
-def meshSetSmooth(mesh, smoothing):
- mesh.autosmooth_angle=int(smoothing)
- mesh.autosmooth=True
+class constraint:
+ @staticmethod
+ def ikChainLen(c):
+ return c.chain_length
-def meshRecalcNormals(mesh_object):
- bpy.ops.object.select_all(action='DESELECT')
- objectActivate(bpy.context.scene, mesh_object)
- enterEditMode()
- bpy.ops.mesh.normals_make_consistent()
- exitEditMode()
+ @staticmethod
+ def ikTarget(c):
+ return c.subtarget
-def meshFlipNormals(mesh):
- mesh.flipNormals()
+ @staticmethod
+ def ikItration(c):
+ return c.iterations
-def materialHasTexture(material):
- return material.texture_slots[0]
+ @staticmethod
+ def ikRotationWeight(c):
+ return c.weight
-def faceGetIndices(face):
- return [face.verts[0], face.verts[1], face.verts[2]]
+ @staticmethod
+ def isIKSolver(c):
+ return c.type=='IK'
-def internalToCp932(s):
- return s.encode('cp932')
0.1 20080128:\r
0.2 20100518: refactoring.\r
0.3 20100606: integrate 2.4 and 2.5.\r
+0.4 20100626: refactoring.\r
"""\r
\r
-\r
-###############################################################################\r
-# import\r
-###############################################################################\r
import os\r
import sys\r
\r
# wrapper\r
import bl24 as bl\r
\r
+ def materialToMqo(m):\r
+ return "\"%s\" shader(3) col(%f %f %f %f)" % (\r
+ m.name, m.rgbCol[0], m.rgbCol[1], m.rgbCol[2], m.alpha)\r
+\r
else:\r
# for 2.5\r
import bpy\r
# wrapper\r
import bl25 as bl\r
\r
+ def materialToMqo(m):\r
+ return "\"%s\" shader(3) col(%f %f %f %f)" % (\r
+ m.name, \r
+ m.diffuse_color[0], m.diffuse_color[1], m.diffuse_color[2], \r
+ m.alpha)\r
+\r
def apply_transform(vec, matrix):\r
x, y, z = vec\r
xloc, yloc, zloc = matrix[3][0], matrix[3][1], matrix[3][2]\r
self.objects=[]\r
self.materials=[]\r
self.scale=scale\r
- print('scaling', self.scale)\r
\r
def setup(self, scene):\r
# 木構造を構築する\r
self.materials.append(material)\r
return index\r
\r
- def write(self, path, scene):\r
+ def write(self, path):\r
io=bl.Writer(path, 'cp932')\r
self.__write_header(io)\r
self.__write_scene(io)\r
self.__write_materials(io, os.path.dirname(path))\r
print("Writing ObjectChunk")\r
for info in self.objects:\r
- self.__write_object(io, info, scene)\r
+ self.__write_object(io, info)\r
io.write("Eof\r\n")\r
io.flush()\r
io.close()\r
# each material \r
io.write("Material %d {\r\n" % (len(self.materials)))\r
for m in self.materials:\r
- tex, aplane=bl.getTexture(m, dirname)\r
+ tex, aplane=bl.material.getTexturePath(m, dirname)\r
if len(tex):\r
# textureがある場合は下地を白に\r
io.write("\"%s\" shader(3) col(1 1 1 1)" % m.name)\r
else:\r
# 無い場合はそのまま\r
- io.write(bl.materialToMqo(m))\r
+ io.write(materialToMqo(m))\r
io.write(tex)\r
io.write(aplane)\r
io.write("\r\n") \r
# end of chunk\r
io.write("}\r\n") \r
\r
- def __write_object(self, io, info, scene):\r
+ def __write_object(self, io, info):\r
print(info)\r
\r
obj=info.object\r
# depth\r
io.write("\tdepth %d\r\n" % info.depth)\r
\r
- # mirroring \r
- isMirrorring=False\r
- for mod in obj.modifiers:\r
- if mod.name.upper()=="MIRROR":\r
- isMirrorring=True\r
- break\r
- if isMirrorring:\r
+ if bl.modifier.hasType(obj, 'MIRROR'):\r
io.write("\tmirror 1\r\n")\r
io.write("\tmirror_axis 1\r\n")\r
\r
if obj.type.upper()=='MESH':\r
# duplicate and applyMatrix\r
- mesh, dumy=bl.objectDuplicate(scene, obj)\r
+ mesh, dumy=bl.object.duplicate(obj)\r
\r
# vertices\r
io.write("\tvertex %d {\r\n" % len(mesh.verts))\r
# faces\r
io.write("\tface %d {\r\n" % len(mesh.faces))\r
for i, face in enumerate(mesh.faces):\r
- count=bl.faceVertexCount(face)\r
+ count=bl.face.getVertexCount(face)\r
# V\r
io.write("\t\t%d V(" % count)\r
- face_list=[]\r
- for j in bl.faceVertices(face):\r
- face_list.insert(0, j)\r
- # flip face\r
- for j in face_list:\r
+ for j in reversed(bl.face.getVertices(face)):\r
io.write("%d " % j)\r
io.write(")")\r
# mat\r
if len(mesh.materials):\r
io.write(" M(%d)" % \r
- info.material_map[bl.faceMaterialIndex(face)])\r
+ info.material_map[bl.face.getMaterialIndex(face)])\r
# UV\r
- if bl.meshHasUV(mesh) and bl.faceHasUV(mesh, i, face):\r
+ if bl.mesh.hasUV(mesh) and bl.mesh.hasFaceUV(mesh, i, face):\r
io.write(" UV(")\r
- uv_list=[]\r
- for uv in bl.faceGetUV(mesh, i, face, count):\r
+ for uv in reversed(bl.mesh.getFaceUV(mesh, i, face, count)):\r
# reverse vertical value\r
- uv_list.insert(0, uv)\r
- # flip face\r
- for uv in uv_list:\r
io.write("%f %f " % (uv[0], 1.0-uv[1])) \r
io.write(")")\r
io.write("\r\n")\r
io.write("\t}\r\n") # end of faces\r
\r
# 削除する\r
- scene.objects.unlink(dumy)\r
+ bl.object.delete(dumy)\r
\r
io.write("}\r\n") # end of object\r
\r
\r
def __execute(filename, scene, scale=10):\r
+ if not scene.objects.active:\r
+ bl.message('no active object !')\r
+ return\r
+\r
exporter=MqoExporter(scale)\r
exporter.setup(scene)\r
- exporter.write(filename, scene)\r
+ exporter.write(filename)\r
\r
\r
if isBlender24():\r
# for 2.4\r
def execute_24(filename):\r
- """\r
- export mqo.\r
- """\r
- filename=filename.decode(bl.INTERNAL_ENCODING)\r
- print("mqo exporter: %s" % filename)\r
-\r
- Blender.Window.WaitCursor(1) \r
- t = Blender.sys.time() \r
-\r
- __execute(filename, Blender.Scene.GetCurrent())\r
-\r
- print('finished in %.2f seconds' % (Blender.sys.time()-t) )\r
- Blender.Redraw()\r
- Blender.Window.WaitCursor(0) \r
+ scene=Blender.Scene.GetCurrent()\r
+ bl.initialize('mqo_export', scene)\r
+ __execute(\r
+ filename.decode(bl.INTERNAL_ENCODING), \r
+ scene)\r
+ bl.finalize()\r
\r
# execute\r
Blender.Window.FileSelector(\r
\r
else:\r
# for 2.5\r
- def execute_25(*args):\r
- __execute(*args)\r
+ def execute_25(path, scene, scale):\r
+ bl.initialize('mqo_export', scene)\r
+ __execute(path, scene, scale)\r
+ bl.finalize()\r
\r
# operator\r
class EXPORT_OT_mqo(bpy.types.Operator):\r
name="Scale", \r
description="Scale the MQO by this value", \r
min=0.0001, max=1000000.0, \r
- soft_min=0.001, soft_max=100.0, default=100.0)\r
+ soft_min=0.001, soft_max=100.0, default=10.0)\r
\r
check_existing = BoolProperty(\r
name="Check Existing",\r
0.6 20100505: C extension.\r
0.7 20100606: integrate 2.4 and 2.5.\r
0.8 20100619: fix multibyte object name.\r
+0.9 20100626: refactoring.\r
'''\r
\r
-\r
-###############################################################################\r
-# import\r
-###############################################################################\r
import os\r
import sys\r
\r
\r
# wrapper\r
import bl24 as bl\r
+\r
+ def createMqoMaterial(m):\r
+ material = Blender.Material.New(\r
+ m.getName().encode(bl.INTERNAL_ENCODING))\r
+ material.mode |= Blender.Material.Modes.SHADELESS\r
+ material.rgbCol = [m.color.r, m.color.g, m.color.b]\r
+ material.alpha = m.color.a\r
+ material.amb = m.ambient\r
+ material.spec = m.specular\r
+ material.hard = int(255 * m.power)\r
+ return material\r
+\r
else:\r
# for 2.5\r
import bpy\r
# wrapper\r
import bl25 as bl\r
\r
+ def createMqoMaterial(m):\r
+ material = bpy.data.materials.new(m.getName())\r
+ material.diffuse_color=[m.color.r, m.color.g, m.color.b]\r
+ material.alpha=m.color.a\r
+ material.diffuse_intensity=m.diffuse\r
+ return material\r
+\r
\r
def has_mikoto(mqo):\r
#for o in mqo.objects:\r
return False\r
\r
\r
-def __createMaterials(scene, mqo, directory):\r
+def __createMaterials(mqo, directory):\r
"""\r
create blender materials and renturn material list.\r
"""\r
if len(mqo.materials)>0:\r
for material_index, m in enumerate(mqo.materials):\r
# material\r
- material=bl.createMqoMaterial(m)\r
+ material=createMqoMaterial(m)\r
materials.append(material)\r
# texture\r
texture_name=m.getTexture()\r
# texture\r
if os.path.exists(path):\r
print("create texture:", path)\r
- texture, image=bl.createTexture(path)\r
+ texture, image=bl.texture.create(path)\r
textureMap[texture_name]=texture\r
imageMap[material_index]=image\r
else:\r
print("%s not exits" % path)\r
continue\r
- bl.materialAddTexture(material, texture)\r
+ bl.material.addTexture(material, texture)\r
else:\r
# default material\r
pass\r
return materials, imageMap\r
\r
\r
-def __createObjects(scene, mqo, root, materials, imageMap, scale):\r
+def __createObjects(mqo, root, materials, imageMap, scale):\r
"""\r
create blender mesh objects.\r
"""\r
stack=[root] \r
objects=[]\r
for o in mqo.objects:\r
- mesh, mesh_object=bl.createMesh(scene, o.getName())\r
+ mesh, mesh_object=bl.mesh.create(o.getName())\r
\r
# add hierarchy\r
stack_depth=len(stack)-1\r
if o.depth<stack_depth:\r
for i in range(stack_depth-o.depth):\r
stack.pop()\r
- bl.objectMakeParent(stack[-1], mesh_object)\r
+ bl.object.makeParent(stack[-1], mesh_object)\r
stack.append(mesh_object)\r
\r
if o.getName().startswith('sdef'):\r
objects.append(mesh_object)\r
elif o.getName().startswith('anchor'):\r
- bl.objectLayerMask(mesh_object, [0, 1])\r
+ bl.object.layerMask(mesh_object, [0, 1])\r
elif o.getName().startswith('bone'):\r
- bl.objectLayerMask(mesh_object, [0, 1])\r
+ bl.object.layerMask(mesh_object, [0, 1])\r
\r
# geometry\r
vertices=[(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices]\r
face_indices.append(f.getIndex(i))\r
faces.append(face_indices)\r
materialMap[f.material_index]=True\r
- bl.meshAddGeometry(mesh, vertices, faces)\r
+ bl.mesh.addGeometry(mesh, vertices, faces)\r
\r
# blender limits 16 materials per mesh\r
for i, material_index in enumerate(materialMap.keys()):\r
# split a mesh ?\r
print("over 16 materials!")\r
break\r
- bl.meshAddMaterial(mesh, materials[material_index])\r
+ bl.mesh.addMaterial(mesh, materials[material_index])\r
materialMap[material_index]=i\r
\r
# set face params\r
assert(len(o.faces)==len(mesh.faces))\r
- bl.meshAddUV(mesh)\r
+ bl.mesh.addUV(mesh)\r
for i, (f, face) in enumerate(zip(o.faces, mesh.faces)):\r
uv_array=[]\r
# flip face\r
for j in reversed(range(f.index_count)):\r
uv_array.append((f.getUV(j).x, 1.0-f.getUV(j).y))\r
- bl.meshSetFaceUv(mesh, i, face, uv_array, \r
+ bl.mesh.setFaceUV(mesh, i, face, uv_array, \r
imageMap.get(f.material_index, None))\r
if f.material_index in materialMap:\r
- bl.faceSetMaterial(face, materialMap[f.material_index])\r
- bl.faceSetSmooth(face, True)\r
+ bl.face.setMaterial(face, materialMap[f.material_index])\r
+ bl.face.setSmooth(face, True)\r
\r
# mirror modifier\r
if o.mirror:\r
- bl.objectAddMirrorModifier(mesh_object)\r
+ bl.object.addMirrorModifier(mesh_object)\r
\r
# set smoothing\r
- bl.meshSetSmooth(mesh, o.smoothing)\r
+ bl.mesh.setSmooth(mesh, o.smoothing)\r
\r
# calc normal\r
- #bl.meshRecalcNormals(mesh_object)\r
+ bl.mesh.recalcNormals(mesh_object)\r
\r
return objects\r
\r
build_armature(armature, child, bone)\r
\r
\r
-def create_armature(scene, mqo):\r
+def create_armature(mqo):\r
"""\r
create armature\r
"""\r
# parse file\r
io=mqo.IO()\r
if not io.read(filename):\r
- print("fail to load",filename)\r
+ bl.message("fail to load %s" % filename)\r
return\r
\r
# create materials\r
- materials, imageMap=__createMaterials(scene, io, os.path.dirname(filename))\r
+ materials, imageMap=__createMaterials(io, os.path.dirname(filename))\r
if len(materials)==0:\r
- materials.append(bl.createMaterial('default'))\r
+ materials.append(bl.material.create('default'))\r
\r
# create objects\r
- root=bl.createEmptyObject(scene, os.path.basename(filename))\r
- objects=__createObjects(scene, io, root, materials, imageMap, scale)\r
+ root=bl.object.createEmpty(os.path.basename(filename))\r
+ objects=__createObjects(io, root, materials, imageMap, scale)\r
\r
if has_mikoto(io):\r
# create mikoto bone\r
- armature_object=create_armature(scene, io)\r
+ armature_object=create_armature(io)\r
if armature_object:\r
root.makeParent([armature_object])\r
\r
# create bone weight\r
- create_bone_weight(scene, io, armature_object, objects)\r
+ create_bone_weight(io, armature_object, objects)\r
\r
\r
###############################################################################\r
if isBlender24():\r
# for 2.4\r
def execute_24(filename):\r
- """\r
- import a mqo file.\r
- """\r
- filename=filename.decode(bl.INTERNAL_ENCODING)\r
- print("##start mqo_import.py##")\r
- print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)\r
- print("parse mqo file: %s" % (filename))\r
-\r
- Blender.Window.WaitCursor(1) \r
- t = Blender.sys.time() \r
-\r
- # execute\r
- scene = Blender.Scene.GetCurrent()\r
- __execute(filename, scene)\r
- scene.update(0)\r
-\r
- print('finished in %.2f seconds' % (Blender.sys.time()-t))\r
- print('')\r
- Blender.Redraw()\r
- Blender.Window.WaitCursor(0) \r
+ scene=Blender.Scene.GetCurrent()\r
+ bl.initialize('mqo_import', scene)\r
+ __execute(\r
+ filename.decode(bl.INTERNAL_ENCODING), \r
+ scene)\r
+ bl.finalize()\r
\r
# execute\r
Blender.Window.FileSelector(execute_24, 'Import MQO', '*.mqo')\r
+\r
else:\r
# for 2.5\r
- def execute_25(*args):\r
- __execute(*args)\r
+ def execute_25(filename, scene, scale):\r
+ bl.initialize('mqo_import', scene)\r
+ __execute(filename, scene, scale)\r
+ bl.finalize()\r
\r
# operator\r
class IMPORT_OT_mqo(bpy.types.Operator):\r
name="Scale", \r
description="Scale the MQO by this value", \r
min=0.0001, max=1000000.0, \r
- soft_min=0.001, soft_max=100.0, default=0.01)\r
+ soft_min=0.001, soft_max=100.0, default=0.1)\r
\r
def execute(self, context):\r
execute_25(\r
1.1 20100612: integrate 2.4 and 2.5.
1.2 20100616: implement rigid body.
1.3 20100619: fix rigid body, bone weight.
+1.4 20100626: refactoring.
"""
MMD_SHAPE_GROUP_NAME='_MMD_SHAPE'
len(self.morphList))
def addMesh(self, obj):
- if bl.objectIsVisible(obj):
+ if bl.object.isVisible(obj):
# 非表示
return
self.__mesh(obj)
return
print("export", obj.name)
- mesh=bl.objectGetData(obj)
+ mesh=bl.object.getData(obj)
weightMap={}
secondWeightMap={}
def setWeight(i, name, w):
weightMap[i]=(name, w)
if isBlender24():
- for name in bl.meshVertexGroupNames(obj):
+ for name in bl.object.getVertexGroupNames(obj):
for i, w in mesh.getVertsFromGroup(name, 1):
setWeight(i, name, w)
else:
secondWeightMap[i]=("", 0)
# メッシュのコピーを生成してオブジェクトの行列を適用する
- copyMesh, copyObj=bl.objectDuplicate(self.scene, obj)
+ copyMesh, copyObj=bl.object.duplicate(obj)
if len(copyMesh.verts)==0:
return
for i, face in enumerate(copyMesh.faces):
- faceVertexCount=bl.faceVertexCount(face)
- material=copyMesh.materials[bl.faceMaterialIndex(face)]
- v=[copyMesh.verts[index] for index in bl.faceVertices(face)]
- uv=bl.meshFaceUv(copyMesh, i, face)
+ faceVertexCount=bl.face.getVertexCount(face)
+ material=copyMesh.materials[bl.face.getMaterialIndex(face)]
+ v=[copyMesh.verts[index] for index in bl.face.getVertices(face)]
+ uv=bl.mesh.getFaceUV(copyMesh, i, face)
+ # flip triangle
if faceVertexCount==3:
# triangle
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[0].index, v[1].index, v[2].index,
- v[0].co, v[1].co, v[2].co,
+ v[2].index,
+ v[1].index,
+ v[0].index,
+ v[2].co,
+ v[1].co,
+ v[0].co,
# ToDo vertex normal
#v0.no, v1.no, v2.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[0], uv[1], uv[2],
- weightMap[v[0].index][0],
- weightMap[v[1].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[2],
+ uv[1],
+ uv[0],
weightMap[v[2].index][0],
- secondWeightMap[v[0].index][0],
- secondWeightMap[v[1].index][0],
+ weightMap[v[1].index][0],
+ weightMap[v[0].index][0],
secondWeightMap[v[2].index][0],
- weightMap[v[0].index][1],
+ secondWeightMap[v[1].index][0],
+ secondWeightMap[v[0].index][0],
+ weightMap[v[2].index][1],
weightMap[v[1].index][1],
- weightMap[v[2].index][1]
+ weightMap[v[0].index][1]
)
elif faceVertexCount==4:
# quadrangle
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[0].index, v[1].index, v[2].index,
- v[0].co, v[1].co, v[2].co,
+ v[2].index,
+ v[1].index,
+ v[0].index,
+ v[2].co,
+ v[1].co,
+ v[0].co,
#v0.no, v1.no, v2.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[0], uv[1], uv[2],
- weightMap[v[0].index][0],
- weightMap[v[1].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[2],
+ uv[1],
+ uv[0],
weightMap[v[2].index][0],
- secondWeightMap[v[0].index][0],
- secondWeightMap[v[1].index][0],
+ weightMap[v[1].index][0],
+ weightMap[v[0].index][0],
secondWeightMap[v[2].index][0],
- weightMap[v[0].index][1],
+ secondWeightMap[v[1].index][0],
+ secondWeightMap[v[0].index][0],
+ weightMap[v[2].index][1],
weightMap[v[1].index][1],
- weightMap[v[2].index][1]
+ weightMap[v[0].index][1]
)
self.vertexArray.addTriangle(
self.obj_index, material.name,
- v[2].index, v[3].index, v[0].index,
- v[2].co, v[3].co, v[0].co,
+ v[0].index,
+ v[3].index,
+ v[2].index,
+ v[0].co,
+ v[3].co,
+ v[2].co,
#v2.no, v3.no, v0.no,
- bl.faceNormal(face),
- bl.faceNormal(face),
- bl.faceNormal(face),
- uv[2], uv[3], uv[0],
- weightMap[v[2].index][0],
- weightMap[v[3].index][0],
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ bl.face.getNormal(face),
+ uv[0],
+ uv[3],
+ uv[2],
weightMap[v[0].index][0],
- secondWeightMap[v[2].index][0],
- secondWeightMap[v[3].index][0],
+ weightMap[v[3].index][0],
+ weightMap[v[2].index][0],
secondWeightMap[v[0].index][0],
- weightMap[v[2].index][1],
+ secondWeightMap[v[3].index][0],
+ secondWeightMap[v[2].index][0],
+ weightMap[v[0].index][1],
weightMap[v[3].index][1],
- weightMap[v[0].index][1]
+ weightMap[v[2].index][1]
)
- bl.objectDelete(self.scene, copyObj)
+ bl.object.delete(copyObj)
self.obj_index+=1
def __skin(self, obj):
- if not bl.objectHasShapeKey(obj):
+ if not bl.object.hasShapeKey(obj):
return
indexRelativeMap={}
- blenderMesh=bl.objectGetData(obj)
+ blenderMesh=bl.object.getData(obj)
baseMorph=None
# shape keys
- vg=bl.meshVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
+ vg=bl.object.getVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
# base
used=set()
- for b in bl.objectShapeKeys(obj):
+ for b in bl.object.getShapeKeys(obj):
if b.name==BASE_SHAPE_NAME:
baseMorph=self.__getOrCreateMorph('base', 0)
basis=b
relativeIndex=0
for index in vg:
- v=bl.shapeKeyGet(b, index)
+ v=bl.shapekey.getByIndex(b, index)
pos=[v[0], v[1], v[2]]
indices=self.vertexArray.getMappedIndices(index)
for i in indices:
return
# shape keys
- for b in bl.objectShapeKeys(obj):
+ for b in bl.object.getShapeKeys(obj):
if b.name==BASE_SHAPE_NAME:
continue
used=set()
for index, src, dst in zip(
xrange(len(blenderMesh.verts)),
- bl.shapeKeys(basis),
- bl.shapeKeys(b)):
+ bl.shapekey.get(basis),
+ bl.shapekey.get(b)):
offset=[dst[0]-src[0], dst[1]-src[1], dst[2]-src[2]]
if offset[0]==0 and offset[1]==0 and offset[2]==0:
continue
return
print("gather bones")
- armature=bl.objectGetData(armatureObj)
+ armature=bl.object.getData(armatureObj)
for b in armature.bones.values():
if b.name=='center':
# root bone
bone=Bone(b.name,
- bl.boneHeadLocal(b),
- bl.boneTailLocal(b))
+ bl.bone.getHeadLocal(b),
+ bl.bone.getTailLocal(b))
self.__addBone(bone)
self.__getBone(bone, b)
if not b.parent and b.name!='center':
# root bone
bone=Bone(b.name,
- bl.boneHeadLocal(b),
- bl.boneTailLocal(b))
+ bl.bone.getHeadLocal(b),
+ bl.bone.getTailLocal(b))
self.__addBone(bone)
self.__getBone(bone, b)
self.__checkConnection(b, None)
print("gather ik")
- pose = bl.objectGetPose(armatureObj)
+ pose = bl.object.getPose(armatureObj)
for b in pose.bones.values():
for c in b.constraints:
- if bl.constraintIsIKSolver(c):
+ if bl.constraint.isIKSolver(c):
####################
# IK target
####################
- target=self.__boneByName(bl.ikTarget(c))
+ target=self.__boneByName(bl.constraint.ikTarget(c))
target.type=2
####################
# IK chain
e=b.parent
- chainLength=bl.ikChainLen(c)
+ chainLength=bl.constraint.ikChainLen(c)
for i in range(chainLength):
# IK影響下
chainBone=self.__boneByName(e.name)
e=e.parent
self.ik_list.append(
IKSolver(target, link, chainLength,
- int(bl.ikItration(c) * 0.1),
- bl.ikRotationWeight(c)
+ int(bl.constraint.ikItration(c) * 0.1),
+ bl.constraint.ikRotationWeight(c)
))
# boneのsort
self.ik_list.sort(key=getIndex)
def __checkConnection(self, b, p):
- if bl.boneIsConnected(b):
+ if bl.bone.isConnected(b):
parent=self.__boneByName(p.name)
parent.isConnect=True
for i, c in enumerate(b.children):
bone=Bone(c.name,
- bl.boneHeadLocal(c),
- bl.boneTailLocal(c))
+ bl.bone.getHeadLocal(c),
+ bl.bone.getTailLocal(c))
self.__addBone(bone)
if parent:
bone.parent_index=parent.index
# search armature modifier
############################################################
for m in node.o.modifiers:
- if bl.modifierIsArmature(m):
- armatureObj=bl.armatureModifierGetObject(m)
+ if bl.modifier.isType(m, 'ARMATURE'):
+ armatureObj=bl.modifier.getArmatureObject(m)
if not self.armatureObj:
self.armatureObj=armatureObj
elif self.armatureObj!=armatureObj:
# 面とマテリアル
vertexCount=self.oneSkinMesh.getVertexCount()
for material_name, indices in self.oneSkinMesh.vertexArray.indexArrays.items():
- m=bl.materialGet(self.scene, material_name)
+ m=bl.material.get(material_name)
# マテリアル
material=io.addMaterial()
if isBlender24():
print("abort. no active object.")
return
- bl.progress_start('pmd_export')
- active=bl.objectGetActive(scene)
+ active=bl.object.getActive()
exporter=PmdExporter()
exporter.setup(scene)
exporter.write(filename)
- bl.objectActivate(scene, active)
- bl.progress_finish()
+ bl.object.activate(active)
if isBlender24():
# for 2.4
def execute_24(filename):
- filename=filename.decode(bl.INTERNAL_ENCODING)
- print("pmd exporter: %s" % filename)
-
- Blender.Window.WaitCursor(1)
- t = Blender.sys.time()
-
scene = bpy.data.scenes.active
- __execute(filename, scene)
-
- print('finished in %.2f seconds' % (Blender.sys.time()-t))
- Blender.Redraw()
- Blender.Window.WaitCursor(0)
+ bl.initialize('pmd_export', scene)
+ __execute(filename.decode(bl.INTERNAL_ENCODING), scene)
+ bl.finalize()
Blender.Window.FileSelector(
execute_24,
else:
# for 2.5
- def execute_25(*args):
- __execute(*args)
+ def execute_25(filename, scene):
+ bl.initialize('pmd_export', scene)
+ __execute(filename, scene)
+ bl.finalize()
# operator
class EXPORT_OT_pmd(bpy.types.Operator):
1.1: 20100608: integrate 2.4 and 2.5.
1.2: 20100616: implement rigid body.
1.3: 20100619: fix for various models.
+1.4: 20100623: fix constraint name.
+1.5: 20100626: refactoring.
"""
MMD_SHAPE_GROUP_NAME='_MMD_SHAPE'
# wrapper
import bl24 as bl
+
+ def createPmdMaterial(m):
+ material=Blender.Material.New()
+ material.setDiffuseShader(Blender.Material.Shaders.DIFFUSE_TOON)
+ material.setRef(1)
+ material.diffuseSize = 3.14/2
+ material.setDiffuseSmooth(0)
+ material.setSpecShader(Blender.Material.Shaders.SPEC_TOON)
+ material.setSpecSize(0)
+ material.setSpec(0)
+ material.setRGBCol([m.diffuse.r, m.diffuse.g, m.diffuse.b])
+ material.setAlpha(m.diffuse.a)
+ material.setSpec(m.shinness*0.1)
+ material.setSpecCol([m.specular.r, m.specular.g, m.specular.b])
+ material.setMirCol([m.ambient.r, m.ambient.g, m.ambient.b])
+ material.enableSSS=True if m.flag==1 else False
+ return material
+
+ def poseBoneLimit(n, b):
+ if n.endswith("_t"):
+ return
+ if n.startswith("knee_"):
+ b.lockYRot=True
+ b.lockZRot=True
+ b.limitX=True
+ b.limitMin=[0, 0, 0]
+ b.limitMax=[180, 0, 0]
+ elif n.startswith("ankle_"):
+ b.lockYRot=True
+
else:
# for 2.5
import bpy
xrange=range
+ def createPmdMaterial(m):
+ material = bpy.data.materials.new("Material")
+ material.diffuse_shader='FRESNEL'
+ material.specular_shader='TOON'
+ material.diffuse_color=([m.diffuse.r, m.diffuse.g, m.diffuse.b])
+ material.alpha=m.diffuse.a
+ material.specular_hardness=int(m.shinness)
+ material.specular_color=([m.specular.r, m.specular.g, m.specular.b])
+ material.mirror_color=([m.ambient.r, m.ambient.g, m.ambient.b])
+ material.subsurface_scattering.enabled=True if m.flag==1 else False
+ return material
+
+ def poseBoneLimit(n, b):
+ if n.endswith("_t"):
+ return
+ if n.startswith("knee_"):
+ b.ik_dof_y=False
+ b.ik_dof_z=False
+ b.ik_dof_x=True
+ b.ik_limit_x=True
+ b.ik_min_x=0
+ b.ik_max_x=180
+ elif n.startswith("ankle_"):
+ #b.ik_dof_y=False
+ pass
+
+
###############################################################################
+def VtoV(v):
+ return bl.createVector(v.x, v.y, v.z)
+
def convert_coord(pos):
"""
Left handed y-up to Right handed z-up
return
# set shape_key pin
- bl.objectPinShape(obj)
+ bl.object.pinShape(obj, True)
# find base
base=None
base=s
# create vertex group
- bl.meshAddVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
+ bl.object.addVertexGroup(obj, MMD_SHAPE_GROUP_NAME)
hasShape=False
for i in s.indices:
if i in vertex_map:
hasShape=True
- bl.meshAssignVertexGroup(
+ bl.object.assignVertexGroup(
obj, MMD_SHAPE_GROUP_NAME, vertex_map[i], 0)
if not hasShape:
return
assert(base)
# create base key
- baseShapeBlock=bl.objectAddShapeKey(obj, BASE_SHAPE_NAME)
+ baseShapeBlock=bl.object.addShapeKey(obj, BASE_SHAPE_NAME)
# mesh
- mesh=bl.objectGetData(obj)
+ mesh=bl.object.getData(obj)
mesh.update()
# each skin
break
# create shapekey block
- new_shape_key=bl.objectAddShapeKey(obj, name)
+ new_shape_key=bl.object.addShapeKey(obj, name)
# copy vertex to shape key
mesh.update()
else:
# 25
- new_shape_key=bl.objectAddShapeKey(obj, name)
+ new_shape_key=bl.object.addShapeKey(obj, name)
for index, offset in zip(s.indices, s.pos_list):
try:
vertex_index=vertex_map[base.indices[index]]
- bl.shapeKeyAssign(new_shape_key, vertex_index,
+ bl.shapekey.assign(new_shape_key, vertex_index,
mesh.verts[vertex_index].co+
bl.createVector(*convert_coord(offset)))
except IndexError as msg:
break
# select base shape
- bl.objectActivateShapeKey(obj, 0)
+ bl.object.setActivateShapeKey(obj, 0)
def __build(armature, b, p, parent):
if not name:
name=b.getName()
- bone=bl.createArmatureBone(armature, name)
+ bone=bl.armature.createBone(armature, name)
if parent and (b.tail_index==0 or b.type==6 or b.type==7 or b.type==9):
bone.head = bl.createVector(*convert_coord(b.pos))
else:
print('diffurence with parent.tail and head', name)
- bl.boneSetConnected(bone)
+ bl.bone.setConnected(bone)
# armature layer 2
- bl.boneLayerMask(bone, [0, 1])
+ bl.bone.setLayerMask(bone, [0, 1])
else:
# 通常ボーン
bone.head = bl.createVector(*convert_coord(b.pos))
if parent:
bone.parent=parent
if parent.tail==bone.head:
- bl.boneSetConnected(bone)
+ bl.bone.setConnected(bone)
if bone.head==bone.tail:
bone.tail=bone.head+bl.createVector(0, 1, 0)
def __importArmature(scene, l):
# build bone
- armature, armature_object=bl.createArmature(scene)
- bl.armatureMakeEditable(scene, armature_object)
+ armature, armature_object=bl.armature.create()
+ bl.armature.makeEditable(armature_object)
for b in l.bones:
if not b.parent:
__build(armature, b, None, None)
- bl.armatureUpdate(armature)
+ bl.armature.update(armature)
bl.exitEditMode()
# IK constraint
- pose = bl.objectGetPose(armature_object)
+ pose = bl.object.getPose(armature_object)
for ik in l.ik_list:
target=l.bones[ik.target]
name = englishmap.getEnglishBoneName(target.getName())
if not effector_name:
effector_name=l.bones[ik.index].getName()
- constraint=bl.createIkConstraint(armature_object,
+ constraint=bl.armature.createIkConstraint(armature_object,
p_bone, effector_name, ik)
- bl.armatureMakeEditable(scene, armature_object)
- bl.armatureUpdate(armature)
+ bl.armature.makeEditable(armature_object)
+ bl.armature.update(armature)
bl.exitEditMode()
return armature_object
def __import16MaerialAndMesh(meshObject, l,
material_order, face_map, tex_dir):
- mesh=bl.objectGetData(meshObject)
+ mesh=bl.object.getData(meshObject)
############################################################
# material
############################################################
except KeyError:
break
- material=bl.createPmdMaterial(m)
+ material=createPmdMaterial(m)
texture_name=m.getTexture()
if texture_name!='':
texture=textureMap[texture_name]
else:
try:
- texture, image=bl.createTexture(
+ texture, image=bl.texture.create(
os.path.join(tex_dir, texture_name))
textureMap[texture_name]=texture
imageMap[material_index]=image
except:
continue
- bl.materialAddTexture(material, texture)
- bl.meshAddMaterial(mesh, material)
+ bl.material.addTexture(material, texture)
+ bl.mesh.addMaterial(mesh, material)
index+=1
############################################################
############################################################
# create vertices & faces
############################################################
- bl.meshAddGeometry(mesh, vertices, mesh_face_indices)
+ bl.mesh.addGeometry(mesh, vertices, mesh_face_indices)
############################################################
# vertex bone weight
vertex_groups[v.bone0]=True
vertex_groups[v.bone1]=True
for i in vertex_groups.keys():
- bl.meshAddVertexGroup(meshObject, get_bone_name(l, i))
+ bl.object.addVertexGroup(meshObject, get_bone_name(l, i))
# vertex params
- bl.meshUseVertexUv(mesh)
+ bl.mesh.useVertexUV(mesh)
for i, v, mvert in zip(xrange(len(l.vertices)),
l.each_vertex(), mesh.verts):
# normal, uv
- bl.vertexSetNormal(mvert, convert_coord(v.normal))
- #bl.vertexSetUv(mvert, convert_uv(v.uv))
+ bl.vertex.setNormal(mvert, convert_coord(v.normal))
# bone weight
w1=float(v.weight0)/100.0
w2=1.0-w1
- bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone0),
+ bl.object.assignVertexGroup(meshObject, get_bone_name(l, v.bone0),
i, w1)
- bl.meshAssignVertexGroup(meshObject, get_bone_name(l, v.bone1),
+ bl.object.assignVertexGroup(meshObject, get_bone_name(l, v.bone1),
i, w2)
############################################################
# face params
############################################################
used_map={}
- bl.meshAddUV(mesh)
+ bl.mesh.addUV(mesh)
for i, (face, material_index) in enumerate(
zip(mesh.faces, mesh_face_materials)):
try:
except KeyError as message:
print(message, mesh_material_map, m)
assert(False)
- bl.faceSetMaterial(face, index)
+ bl.face.setMaterial(face, index)
material=mesh.materials[index]
used_map[index]=True
- if bl.materialHasTexture(material):
- uv_array=[l.getUV(i) for i in bl.faceGetIndices(face)]
- bl.meshSetFaceUv(mesh, i, face,
+ if bl.material.hasTexture(material):
+ uv_array=[l.getUV(i) for i in bl.face.getIndices(face)]
+ bl.mesh.setFaceUV(mesh, i, face,
# fix uv
[(uv.x, 1.0-uv.y) for uv in uv_array],
imageMap.get(index, None))
else:
remove_vertices.append(i)
- bl.meshVertsDelete(mesh, remove_vertices)
+ bl.mesh.vertsDelete(mesh, remove_vertices)
bl.progress_print('%s created' % mesh.name)
return vertex_map
material_offset=0
mesh_objects=[]
while material_offset<len(io.materials):
- mesh, meshObject=bl.createMesh(scene, 'mesh')
+ mesh, meshObject=bl.mesh.create('mesh')
# create object
mesh_objects.append(meshObject)
# activate object
- bl.objectDeselectAll()
- bl.objectActivate(scene, meshObject)
+ bl.object.deselectAll()
+ bl.object.activate(meshObject)
# shapeキーで使われる順に並べなおしたマテリアル16個分の
# メッシュを作成する
material_order[material_offset:material_offset+16],
face_map, tex_dir)
- # enter Edit Mode
- #bl.enterEditMode()
-
# crete shape key
__importShape(meshObject, io, vertex_map)
- # exit Edit Mode
- #bl.exitEditMode()
-
mesh.update()
material_offset+=16
def __importConstraints(scene, io):
if isBlender24():
return
- print("create constrains")
- container=bl.createEmptyObject(scene, 'Constraints')
+ print("create constraint")
+ container=bl.object.createEmpty('Constraints')
layer=[
True, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
]
- material=bl.createMaterial('constraint')
+ material=bl.material.create('constraint')
material.diffuse_color=(1, 0, 0)
constraintMeshes=[]
for i, c in enumerate(io.constraints):
)
meshObject=scene.objects.active
constraintMeshes.append(meshObject)
- mesh=bl.objectGetData(meshObject)
- bl.meshAddMaterial(mesh, material)
+ mesh=bl.object.getData(meshObject)
+ bl.mesh.addMaterial(mesh, material)
meshObject.name='c_%d' % i
#meshObject.draw_transparent=True
#meshObject.draw_wire=True
meshObject[CONSTRAINT_NAME]=c.getName()
meshObject[CONSTRAINT_A]=io.rigidbodies[c.rigidA].getName()
meshObject[CONSTRAINT_B]=io.rigidbodies[c.rigidB].getName()
- meshObject[CONSTRAINT_POS_MIN]=bl.VtoV(c.constraintPosMin)
- meshObject[CONSTRAINT_POS_MAX]=bl.VtoV(c.constraintPosMax)
- meshObject[CONSTRAINT_ROT_MIN]=bl.VtoV(c.constraintRotMin)
- meshObject[CONSTRAINT_ROT_MAX]=bl.VtoV(c.constraintRotMax)
- meshObject[CONSTRAINT_SPRING_POS]=bl.VtoV(c.springPos)
- meshObject[CONSTRAINT_SPRING_ROT]=bl.VtoV(c.springRot)
+ meshObject[CONSTRAINT_POS_MIN]=VtoV(c.constraintPosMin)
+ meshObject[CONSTRAINT_POS_MAX]=VtoV(c.constraintPosMax)
+ meshObject[CONSTRAINT_ROT_MIN]=VtoV(c.constraintRotMin)
+ meshObject[CONSTRAINT_ROT_MAX]=VtoV(c.constraintRotMax)
+ meshObject[CONSTRAINT_SPRING_POS]=VtoV(c.springPos)
+ meshObject[CONSTRAINT_SPRING_ROT]=VtoV(c.springRot)
for meshObject in reversed(constraintMeshes):
- bl.objectMakeParent(container, meshObject)
+ bl.object.makeParent(container, meshObject)
return container
return
print("create rigid bodies")
- container=bl.createEmptyObject(scene, 'RigidBodies')
+ container=bl.object.createEmpty('RigidBodies')
layer=[
True, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
False, False, False, False, False, False, False, False,
]
- material=bl.createMaterial('rigidBody')
+ material=bl.material.create('rigidBody')
rigidMeshes=[]
for rigid in io.rigidbodies:
if rigid.boneIndex==0xFFFF:
assert(False)
meshObject=scene.objects.active
- mesh=bl.objectGetData(meshObject)
+ mesh=bl.object.getData(meshObject)
rigidMeshes.append(meshObject)
- bl.meshAddMaterial(mesh, material)
+ bl.mesh.addMaterial(mesh, material)
meshObject.name=rigid.getName()
#meshObject.draw_transparent=True
#meshObject.draw_wire=True
bone_name=bone.getName()
meshObject[RIGID_BONE_NAME]=bone_name
- #meshObject[RIGID_LOCATION]=bl.VtoV(rigid.location)
meshObject[RIGID_GROUP]=rigid.group
meshObject[RIGID_INTERSECTION_GROUP]=rigid.target
meshObject[RIGID_WEIGHT]=rigid.weight
meshObject[RIGID_FRICTION]=rigid.friction
for meshObject in reversed(rigidMeshes):
- bl.objectMakeParent(container, meshObject)
+ bl.object.makeParent(container, meshObject)
return container
"""
load pmd file to context.
"""
- bl.progress_start('pmd_import')
-
+
# load pmd
bl.progress_set('load %s' % filename, 0.0)
io=pmd.IO()
if not io.read(filename):
- print("fail to load %s" % filename)
+ bl.message("fail to load %s" % filename)
return
bl.progress_set('loaded %s' % filename, 0.1)
model_name=io.getEnglishName()
if len(model_name)==0:
model_name=io.getName()
- root=bl.createEmptyObject(scene, model_name)
+ root=bl.object.createEmpty(model_name)
# import mesh
mesh_objects=__importMesh(scene, io, os.path.dirname(filename))
for o in mesh_objects:
- bl.objectMakeParent(root, o)
+ bl.object.makeParent(root, o)
# import armature
armature_object=__importArmature(scene, io)
if armature_object:
- bl.objectMakeParent(root, armature_object)
- armature = bl.objectGetData(armature_object)
+ bl.object.makeParent(root, armature_object)
+ armature = bl.object.getData(armature_object)
# add armature modifier
for o in mesh_objects:
- bl.objectAddArmatureModifier(o, armature_object)
+ bl.modifier.addArmature(o, armature_object)
# Limitation
- for n, b in bl.objectGetPose(armature_object).bones.items():
- bl.poseBoneLimit(n, b)
+ for n, b in bl.object.getPose(armature_object).bones.items():
+ poseBoneLimit(n, b)
# import rigid bodies
rigidBodies=__importRigidBodies(scene, io)
if rigidBodies:
- bl.objectMakeParent(root, rigidBodies)
+ bl.object.makeParent(root, rigidBodies)
# import constraints
constraints=__importConstraints(scene, io)
if constraints:
- bl.objectMakeParent(root, constraints)
+ bl.object.makeParent(root, constraints)
+
+ bl.object.activate(root)
- bl.objectActivate(scene, root)
- bl.progress_finish()
if isBlender24():
# for 2.4
def execute_24(filename):
- """
- @param filename
- """
- filename=filename.decode(bl.INTERNAL_ENCODING)
- print(bl.INTERNAL_ENCODING, bl.FS_ENCODING)
-
- # set object mode
- mode_edit = Blender.Window.EditMode()
- if mode_edit:
- Blender.Window.EditMode(0)
-
- scene = bpy.data.scenes.active
- __execute(filename, scene)
- scene.update(0)
-
- # restore edit mode
- if mode_edit:
- Blender.Window.EditMode(1)
- Blender.Window.RedrawAll()
+ scene=bpy.data.scenes.active
+ bl.initialize('pmd_import', scene)
+ __execute(
+ filename.decode(bl.INTERNAL_ENCODING),
+ scene)
+ bl.finalize()
Blender.Window.FileSelector(
execute_24,
else:
# for 2.5
- def execute_25(*args):
- __execute(*args)
+ def execute_25(filename, scene):
+ bl.initialize('pmd_import', scene)
+ __execute(filename, scene)
+ bl.finalize()
# import operator
class IMPORT_OT_pmd(bpy.types.Operator):
for i in range(len(ext_modules)+1):
try:
setup(name="meshio",
- version='0.10',
+ version='0.11',
description='polygon mesh io utilities',
author='ousttrue',
author_email='ousttrue@gmail.com',
OSDN Git Service
