integrate pmd_import for blender25.

[meshio/meshio.git] / swig / blender / bl24.py

diff --git a/swig/blender/bl24.py b/swig/blender/bl24.py
index 5d79475..1442b10 100644 (file)
--- a/swig/blender/bl24.py
+++ b/swig/blender/bl24.py
@@ -466,6 +466,22 @@ def createMqoMaterial(m):
     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))
@@ -474,7 +490,6 @@ def createTexture(path):
     texture.image = image
     return texture, image
 
-
 def materialAddTexture(material, texture):
     material.mode = material.mode | Blender.Material.Modes.TEXFACE
     material.setTexture(0, texture, Blender.Texture.TexCo.UV)
@@ -490,6 +505,10 @@ def objectMakeParent(parent, child):
     parent.makeParent([child])
 
 
+def meshAddMaterial(mesh, material):
+    mesh.materials+=[material]
+
+
 def meshAddMqoGeometry(mesh, o, materials, imageMap, scale):
     # add vertices
     mesh.verts.extend(Mathutils.Vector(0, 0, 0)) # dummy
@@ -589,6 +608,9 @@ def objectDuplicate(scene, obj):
     dumy.setMatrix(obj.matrixWorld)
     return mesh, dumy
 
+def objectDelete(scene, obj):
+    scene.objects.unlink(obj)
+
 def faceVertexCount(face):
     return len(face.v)
 
@@ -653,3 +675,129 @@ def objectActivate(scene, o):
     o.select(True )
     scene.objects.active=o
 
+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 meshCreateVerteicesAndFaces(mesh, vertices, faces):
+    mesh.verts.extend(vertices)
+    mesh.faces.extend(faces, ignoreDups=True)
+
+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
+    #ik_solver.influence=ik.weight
+    # 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 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 meshFaceUv(mesh, i, face):
+    return face.uv
+
+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):
+    for index in meshObject.getData(mesh=True).getVertsFromGroup(name):
+        yield index
+
+def materialGet(scene, material_name):
+    return Blender.Material.Get(material_name)
+