# coding: utf-8
-import bpy
-import mathutils
-
import os
+import sys
import time
import functools
-###############################################################################
-# ProgressBar
-###############################################################################
+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()
+if os.path.exists(os.path.dirname(sys.argv[0])+"/utf8"):
+ INTERNAL_ENCODING='utf-8'
+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 enterObjectMode():
+ bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+def enterPoseMode():
+ bpy.ops.object.mode_set(mode='POSE', 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()
+
+
class ProgressBar(object):
+ '''
+ progress bar wrapper
+ '''
def __init__(self, base):
print("#### %s ####" % base)
self.base=base
message='finished in %.2f sec' % (time.time()-self.start)
self.set(message, 1.0)
-
-###############################################################################
-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 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
- # temporary
- material.emit=1.0
- return material
-
-def createPmdMaterial(m):
- material = bpy.data.materials.new("Material")
- material.diffuse_shader='TOON'
- 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])
- # temporary
- material.emit=1.0
- 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 meshAddMqoGeometry(mesh, o, materials, imageMap, scale):
- # count triangle and quadrangle
- faceCount=0
- for f in o.faces:
- if f.index_count==3 or f.index_count==4:
- faceCount+=1
- mesh.add_geometry(len(o.vertices), 0, faceCount)
-
- # add vertex
- unpackedVertices=[]
- for v in o.vertices:
- # convert right-handed y-up to right-handed z-up
- unpackedVertices.extend(
- (scale*v.x, scale*-v.z, scale*v.y))
- mesh.verts.foreach_set("co", unpackedVertices)
-
- # add face
- unpackedFaces = []
- usedMaterial=set()
-
- def getFace(f):
- face = []
- for i in range(f.index_count):
- face.append(f.getIndex(i))
- return face
-
- for f in o.faces:
- face=getFace(f)
- if len(face) != 3 and len(face) != 4:
- print("{0} vertices in face.".format(len(face)))
- continue
-
- 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)
- usedMaterial.add(f.material_index)
- try:
+def progress_start(base):
+ global progressBar
+ progressBar=ProgressBar(base)
+
+def progress_finish():
+ global progressBar
+ progressBar.finish()
+
+def progress_print(message, progress=0.05):
+ global progressBar
+ progressBar.advance(message, progress)
+
+def progress_set(message, progress):
+ global progressBar
+ progressBar.set(message, progress)
+
+
+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')
+
+ @staticmethod
+ def createBoneGroup(o, name, color_set='DEFAULT'):
+ # create group
+ object.activate(o)
+ enterPoseMode()
+ bpy.ops.pose.group_add()
+ # set name
+ pose=object.getPose(o)
+ g=pose.active_bone_group
+ g.name=name
+ g.color_set=color_set
+
+ @staticmethod
+ def boneGroups(o):
+ return object.getPose(o).bone_groups
+
+
+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, enable=True):
+ # search free slot
+ index=None
+ for i, slot in enumerate(material.texture_slots):
+ if not slot:
+ index=i
+ break
+ if index==None:
+ return
+
+ if enable:
+ material.add_texture(texture, "UV", "COLOR")
+ slot=material.texture_slots[index]
+ slot.blend_type='MULTIPLY'
+ slot.map_alpha=True
+ else:
+ material.add_texture(texture)
+ material.use_textures[index]=False
+ return index
+
+ @staticmethod
+ def getTexture(material, index):
+ return material.texture_slots[index].texture
+
+ @staticmethod
+ def hasTexture(material):
+ return material.texture_slots[0]
+
+ @staticmethod
+ def setUseTexture(material, index, enable):
+ material.use_textures[index]=enable
+
+ @staticmethod
+ def eachTexturePath(m):
+ 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
+ yield image.filename
+
+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)
- except:
- #print([getFace(f) for f in o.faces])
- print("fail to mesh.faces.foreach_set")
- return
-
- # add material
- meshMaterialMap={}
- materialIndex=0
- for i in usedMaterial:
- mesh.add_material(materials[i])
- meshMaterialMap[i]=materialIndex
- materialIndex+=1
-
- # each face
- mesh.add_uv_texture()
- for mqo_face, blender_face, uv_face in zip(
- o.faces, mesh.faces, mesh.uv_textures[0].data):
- if mqo_face.index_count<3:
- continue
- blender_face.material_index=meshMaterialMap[mqo_face.material_index]
- if mqo_face.index_count>=3:
- uv_face.uv1=[mqo_face.getUV(0).x, 1.0-mqo_face.getUV(0).y]
- uv_face.uv2=[mqo_face.getUV(1).x, 1.0-mqo_face.getUV(1).y]
- uv_face.uv3=[mqo_face.getUV(2).x, 1.0-mqo_face.getUV(2).y]
- if mqo_face.index_count==4:
- uv_face.uv4=[
- mqo_face.getUV(3).x, 1.0-mqo_face.getUV(3).y]
- if materials[mqo_face.material_index] in imageMap:
- uv_face.image=imageMap[mqo_face.material_index]
+ """
+ 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
+
+ @staticmethod
+ def addUV(mesh):
+ mesh.add_uv_texture()
+
+ @staticmethod
+ def hasFaceUV(mesh, i, face):
+ return mesh.active_uv_texture and mesh.active_uv_texture.data[i]
+
+ @staticmethod
+ def getFaceUV(mesh, i, faces, count=3):
+ if mesh.active_uv_texture and mesh.active_uv_texture.data[i]:
+ 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)
+ else:
+ return ((0, 0), (0, 0), (0, 0), (0, 0))
+
+ @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
- mesh.update()
-
-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 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.lock_rotation[1]=True
- b.lock_rotation[2]=True
- b.ik_min_x=0
- b.ik_max_x=180
- elif n.startswith("ankle_"):
- b.lock_rotation[1]=True
-
-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 meshAddVertexGroup(meshObject, name):
- meshObject.add_vertex_group(name)
-
-def vertexSetNormal(mvert, normal):
- mvert.normal=mathutils.Vector(normal)
-
-def meshUseVertexUv(mesh):
- pass
-
-def vertexSetUv(mvert, uv):
- pass
+ @staticmethod
+ def vertsDelete(mesh, remove_vertices):
+ enterEditMode()
+ bpy.ops.mesh.select_all(action='DESELECT')
+ enterObjectMode()
+
+ for i in remove_vertices:
+ mesh.verts[i].selected=True
+
+ enterEditMode()
+ bpy.ops.mesh.delete(type='VERT')
+ enterObjectMode()
+
+ @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()
+ enterObjectMode()
+
+ @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
+
+
+class face:
+ @staticmethod
+ def getVertexCount(face):
+ return len(face.verts)
+
+ @staticmethod
+ def getVertices(face):
+ return face.verts[:]
+
+ @staticmethod
+ def getIndices(face, count=3):
+ if count==3:
+ return [face.verts[0], face.verts[1], face.verts[2]]
+ elif count==4:
+ return [face.verts[0], face.verts[1], face.verts[2], face.verts[3]]
+ else:
+ assert(False)
+
+ @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.drawtype='STICK'
+ 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
+
+
+class bone:
+ @staticmethod
+ def setConnected(bone):
+ bone.connected=True
+
+ @staticmethod
+ def isConnected(b):
+ return b.connected
+
+ @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
+
+ @staticmethod
+ def getHeadLocal(b):
+ return b.head_local[0:3]
+
+ @staticmethod
+ def getTailLocal(b):
+ return b.tail_local[0:3]
+
+
+class constraint:
+ @staticmethod
+ def ikChainLen(c):
+ return c.chain_length
+
+ @staticmethod
+ def ikTarget(c):
+ return c.subtarget
+
+ @staticmethod
+ def ikItration(c):
+ return c.iterations
+
+ @staticmethod
+ def ikRotationWeight(c):
+ return c.weight
+
+ @staticmethod
+ def isIKSolver(c):
+ return c.type=='IK'
-def meshAssignVertexGroup(meshObject, name, index, weight):
- meshObject.add_vertex_to_group(index,
- meshObject.vertex_groups[name], weight, 'ADD')
-
-def meshCreateVerteicesAndFaces(mesh, vertices, faces):
- vertexCount=int(len(vertices)/3)
- faceCount=int(len(faces)/4)
- mesh.add_geometry(vertexCount, 0, faceCount)
- mesh.verts.foreach_set("co", vertices)
- mesh.faces.foreach_set("verts_raw", faces)
- assert(len(mesh.verts)==vertexCount)
-
-def meshAddUV(mesh):
- mesh.add_uv_texture()
-
-def meshVertsDelete(mesh, remove_vertices):
- enterEditMode()
- bpy.ops.mesh.select_all(action='DESELECT')
- for i in remove_vertices:
- mesh.verts[i].selected=True
- bpy.ops.mesh.delete(type='VERT')
- exitEditMode()
OSDN Git Service
