-
-###############################################################################
-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 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 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')
+
+
+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")
+ slot=material.texture_slots[material.active_texture_index]
+ slot.blend_type='MULTIPLY'
+ slot.map_alpha=True
+
+ @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)