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.materials+=[material]
-def meshAddMqoGeometry(mesh_object, o, materials, imageMap, scale):
- mesh=mesh_object.getData(mesh=True)
- # add vertices
- mesh.verts.extend(Mathutils.Vector(0, 0, 0)) # dummy
- mesh.verts.extend([(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices])
- # add faces
- mesh_faces=[]
- for face in o.faces:
- face_indices=[]
- for i in xrange(face.index_count):
- face_indices.append(face.getIndex(i)+1)
- mesh_faces.append(face_indices)
- #new_faces=mesh.faces.extend([face.indices for face in o.faces],
- new_faces=mesh.faces.extend(mesh_faces,
+def meshAddGeometry(mesh, vertices, faces):
+ mesh.verts.extend(vertices)
+ new_faces=mesh.faces.extend(faces,
#ignoreDups=True,
indexList=True)
mesh.update()
-
- # gather used materials
- materialMap = {}
- if new_faces:
- for i in new_faces:
- if type(i) is int:
- materialMap[o.faces[i].material_index]=True
-
- # blender limits 16 materials per mesh
- # separate mesh ?
- for i, material_index in enumerate(materialMap.keys()):
- if i>=16:
- print("over 16 materials!")
- break
- mesh.materials+=[materials[material_index]]
- materialMap[material_index]=i
-
- # set face params
- for i, f in enumerate(o.faces):
- if not type(new_faces[i]) is int:
- continue
-
- face=mesh.faces[new_faces[i]]
-
- uv_array=[]
- for i in xrange(f.index_count):
- uv_array.append(Blender.Mathutils.Vector(
- f.getUV(i).x,
- 1.0-f.getUV(i).y)
- )
- try:
- face.uv=uv_array
- except Exception as msg:
- #print msg
- #print face.index, uv_array
- pass
-
- if f.material_index in materialMap:
- face.mat = materialMap[f.material_index]
-
- face.smooth = 1
-
- # rmeove dummy 0 vertex
- mesh.verts.delete(0)
-
- mesh.calcNormals()
- mesh.flipNormals()
- 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=""
# 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)
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 faceNormal(face):
return face.no
-def meshFaceUv(mesh, i, face):
+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]
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]
+
def createPmdMaterial(m):
material = bpy.data.materials.new("Material")
- material.diffuse_shader='TOON'
+ 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
def objectAddMirrorModifier(mesh_object):
return mesh_object.modifiers.new("Modifier", "MIRROR")
-def meshAddMqoGeometry(mesh_object, o, materials, imageMap, scale):
- mesh=mesh_object.data
- # 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)
-
+def meshAddGeometry(mesh, vertices, faces):
+ mesh.from_pydata(vertices, [], faces)
+ """
+ mesh.add_geometry(len(vertices), 0, len(faces))
# 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))
+ for v in vertices:
+ unpackedVertices.extend(v)
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
-
+ for face in faces:
if len(face) == 4:
if face[3] == 0:
# rotate indices if the 4th is 0
face = [face[2], face[0], face[1], 0]
else:
face.append(0)
-
unpackedFaces.extend(face)
- usedMaterial.add(f.material_index)
- try:
- mesh.faces.foreach_set("verts_raw", unpackedFaces)
- except:
- #print([getFace(f) for f in o.faces])
- print("fail to mesh.faces.foreach_set")
- return
+ mesh.faces.foreach_set("verts_raw", unpackedFaces)
+ """
+ assert(len(vertices)==len(mesh.verts))
+ assert(len(faces)==len(mesh.faces))
- # add material
- meshMaterialMap={}
- materialIndex=0
- for i in usedMaterial:
- mesh.add_material(materials[i])
- meshMaterialMap[i]=materialIndex
- materialIndex+=1
+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
- # 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]
- uv_face.tex=True
-
- mesh.update()
+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=""
def vertexSetNormal(mvert, normal):
mvert.normal=mathutils.Vector(normal)
+def faceSetNormal(face, normal):
+ face.normal=normal
+
def meshUseVertexUv(mesh):
pass
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 meshSetSmooth(mesh, smoothing):
mesh.autosmooth_angle=int(smoothing)
mesh.autosmooth=True
- mesh.calc_normals()
+
+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()
+
+def meshFlipNormals(mesh):
+ mesh.flipNormals()
+
+def materialHasTexture(material):
+ return material.texture_slots[0]
+
+def faceGetIndices(face):
+ return [face.verts[0], face.verts[1], face.verts[2]]
io.write("}\r\n") \r
\r
def __write_object(self, io, info, scene):\r
- print(info)\r
+ #print(info)\r
\r
obj=info.object\r
if obj.type.upper()!='MESH':\r
elif o.getName().startswith('bone'):\r
bl.objectLayerMask(mesh_object, [0, 1])\r
\r
- bl.meshAddMqoGeometry(mesh_object, o, materials, imageMap, scale)\r
+ # geometry\r
+ vertices=[(v.x * scale, -v.z * scale, v.y * scale) for v in o.vertices]\r
+ faces=[]\r
+ materialMap={}\r
+ for f in o.faces:\r
+ face_indices=[]\r
+ # flip face\r
+ for i in reversed(range(f.index_count)):\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
+\r
+ # blender limits 16 materials per mesh\r
+ for i, material_index in enumerate(materialMap.keys()):\r
+ if i>=16:\r
+ # split a mesh ?\r
+ print("over 16 materials!")\r
+ break\r
+ bl.meshAddMaterial(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
+ 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
+ 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
\r
# mirror modifier\r
if o.mirror:\r
# set smoothing\r
bl.meshSetSmooth(mesh, o.smoothing)\r
\r
+ # calc normal\r
+ #bl.meshRecalcNormals(mesh_object)\r
+\r
return objects\r
\r
\r
bl.progress_print('create vertices')
# create vertices
vertices=[]
- if isBlender24():
- for v in l.each_vertex():
- vertices.append(convert_coord(v.pos))
- else:
- for v in l.each_vertex():
- vertices.extend(convert_coord(v.pos))
+ for v in l.each_vertex():
+ vertices.append(convert_coord(v.pos))
############################################################
# face
i0=material_faces[j]
i1=material_faces[j+1]
i2=material_faces[j+2]
- if i2==0:
- triangle=[i2, i0, i1]
- else:
- triangle=[i0, i1, i2]
+ # flip
+ triangle=[i2, i1, i0]
if degenerate(*triangle):
continue
- if isBlender24():
- mesh_face_indices.append(triangle[0:3])
- else:
- mesh_face_indices.extend(
- [triangle[0], triangle[1], triangle[2], 0])
+ mesh_face_indices.append(triangle[0:3])
mesh_face_materials.append(material_index)
used_vertices.add(i0)
used_vertices.add(i1)
############################################################
# create vertices & faces
############################################################
- bl.meshCreateVerteicesAndFaces(mesh, vertices, mesh_face_indices)
+ bl.meshAddGeometry(mesh, vertices, mesh_face_indices)
############################################################
# vertex bone weight
l.each_vertex(), mesh.verts):
# normal, uv
bl.vertexSetNormal(mvert, convert_coord(v.normal))
- bl.vertexSetUv(mvert, convert_uv(v.uv))
+ #bl.vertexSetUv(mvert, convert_uv(v.uv))
# bone weight
w1=float(v.weight0)/100.0
w2=1.0-w1
############################################################
used_map={}
bl.meshAddUV(mesh)
+ for i, (face, material_index) in enumerate(
+ zip(mesh.faces, mesh_face_materials)):
+ try:
+ index=mesh_material_map[material_index]
+ except KeyError as message:
+ print(message, mesh_material_map, m)
+ assert(False)
+ bl.faceSetMaterial(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,
+ # fix uv
+ [(uv.x, 1.0-uv.y) for uv in uv_array],
+ imageMap.get(index, None))
+
+ # set smooth
+ face.smooth = 1
- if isBlender24():
- for face, material_index in zip(mesh.faces, mesh_face_materials):
- try:
- index=mesh_material_map[material_index]
- except KeyError as message:
- print(message, mesh_material_map, m)
- assert(False)
- face.mat=index
- material=mesh.materials[index]
- texture=material.getTextures()[0]
- used_map[index]=True
- if texture:
- face.image=texture.tex.image
- texture.tex.imageFlags|=Blender.Texture.ImageFlags.USEALPHA
- face.uv=[
- face.verts[0].uvco, face.verts[1].uvco, face.verts[2].uvco]
- # set smooth
- face.smooth = 1
- # flip
- mesh.flipNormals()
- else:
- for face, uv_face, material_index in zip(mesh.faces,
- mesh.uv_textures[0].data,
- mesh_face_materials,
- ):
- try:
- index=mesh_material_map[material_index]
- except KeyError as message:
- print(message, mesh_material_map, m)
- assert(False)
- face.material_index=index
- material=mesh.materials[index]
- used_map[index]=True
- if material.texture_slots[0]:
- uv=l.getUV(face.verts[0])
- uv_face.uv1=[uv.x, 1.0-uv.y]
-
- uv=l.getUV(face.verts[1])
- uv_face.uv2=[uv.x, 1.0-uv.y]
-
- uv=l.getUV(face.verts[2])
- uv_face.uv3=[uv.x, 1.0-uv.y]
- if face.material_index in imageMap:
- uv_face.image=imageMap[face.material_index]
- uv_face.tex=True
-
- # set smooth
- face.smooth = 1
mesh.update()
############################################################
OSDN Git Service
