1884 lines
66 KiB
Python
1884 lines
66 KiB
Python
# @author zfedoran / http://github.com/zfedoran
|
|
|
|
import os
|
|
import sys
|
|
import math
|
|
import operator
|
|
|
|
# #####################################################
|
|
# Globals
|
|
# #####################################################
|
|
option_triangulate = True
|
|
option_textures = True
|
|
option_prefix = True
|
|
option_geometry = False
|
|
option_default_camera = False
|
|
option_default_light = False
|
|
|
|
converter = None
|
|
global_up_vector = None
|
|
|
|
# #####################################################
|
|
# Templates
|
|
# #####################################################
|
|
def Vector2String(v, no_brackets = False):
|
|
if no_brackets:
|
|
return '%g,%g' % (v[0], v[1])
|
|
else:
|
|
return '[ %g, %g ]' % (v[0], v[1])
|
|
|
|
def Vector3String(v, no_brackets = False):
|
|
if no_brackets:
|
|
return '%g,%g,%g' % (v[0], v[1], v[2])
|
|
else:
|
|
return '[ %g, %g, %g ]' % (v[0], v[1], v[2])
|
|
|
|
def ColorString(c, no_brackets = False):
|
|
if no_brackets:
|
|
return '%g, %g, %g' % (c[0], c[1], c[2])
|
|
else:
|
|
return '[ %g, %g, %g ]' % (c[0], c[1], c[2])
|
|
|
|
def LabelString(s):
|
|
return '"%s"' % s
|
|
|
|
def ArrayString(s):
|
|
return '[ %s ]' % s
|
|
|
|
def PaddingString(n):
|
|
output = ""
|
|
for i in range(n):
|
|
output += "\t"
|
|
return output
|
|
|
|
def BoolString(value):
|
|
if value:
|
|
return "true"
|
|
return "false"
|
|
|
|
# #####################################################
|
|
# Helpers
|
|
# #####################################################
|
|
def getObjectName(o, force_prefix = False):
|
|
if not o:
|
|
return ""
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Object_%s_" % o.GetUniqueID()
|
|
return prefix + o.GetName()
|
|
|
|
def getGeometryName(g, force_prefix = False):
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Geometry_%s_" % g.GetUniqueID()
|
|
return prefix + g.GetName()
|
|
|
|
def getEmbedName(e, force_prefix = False):
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Embed_%s_" % e.GetUniqueID()
|
|
return prefix + e.GetName()
|
|
|
|
def getMaterialName(m, force_prefix = False):
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Material_%s_" % m.GetUniqueID()
|
|
return prefix + m.GetName()
|
|
|
|
def getTextureName(t, force_prefix = False):
|
|
texture_file = t.GetFileName()
|
|
texture_id = os.path.splitext(os.path.basename(texture_file))[0]
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Texture_%s_" % t.GetUniqueID()
|
|
return prefix + texture_id
|
|
|
|
def getFogName(f, force_prefix = False):
|
|
prefix = ""
|
|
if option_prefix or force_prefix:
|
|
prefix = "Fog_%s_" % f.GetUniqueID()
|
|
return prefix + f.GetName()
|
|
|
|
def getObjectVisible(n):
|
|
return BoolString(True)
|
|
|
|
def getRadians(v):
|
|
return ((v[0]*math.pi)/180, (v[1]*math.pi)/180, (v[2]*math.pi)/180)
|
|
|
|
def getHex(c):
|
|
color = (int(c[0]*255) << 16) + (int(c[1]*255) << 8) + int(c[2]*255)
|
|
return color
|
|
|
|
def setBit(value, position, on):
|
|
if on:
|
|
mask = 1 << position
|
|
return (value | mask)
|
|
else:
|
|
mask = ~(1 << position)
|
|
return (value & mask)
|
|
|
|
def convert_fbx_color(color):
|
|
return [color.mRed, color.mGreen, color.mBlue, color.mAlpha]
|
|
|
|
def convert_fbx_vec2(v):
|
|
return [v[0], v[1]]
|
|
|
|
def convert_fbx_vec3(v):
|
|
return [v[0], v[1], v[2]]
|
|
|
|
def generate_uvs(uv_layers):
|
|
layers = []
|
|
for uvs in uv_layers:
|
|
layer = ",".join(Vector2String(n, True) for n in uvs)
|
|
layers.append(layer)
|
|
|
|
return ",".join("[%s]" % n for n in layers)
|
|
|
|
def generateMultiLineString(lines, separator, padding):
|
|
cleanLines = []
|
|
for i in range(len(lines)):
|
|
line = lines[i]
|
|
line = PaddingString(padding) + line
|
|
cleanLines.append(line)
|
|
return separator.join(cleanLines)
|
|
|
|
def get_up_vector(scene):
|
|
global_settings = scene.GetGlobalSettings()
|
|
axis_system = global_settings.GetAxisSystem()
|
|
up_vector = axis_system.GetUpVector()
|
|
tmp = [0,0,0]
|
|
tmp[up_vector[0] - 1] = up_vector[1] * 1
|
|
return FbxVector4(tmp[0], tmp[1], tmp[2], 1)
|
|
|
|
def generate_bounding_box(vertices):
|
|
minx = 0
|
|
miny = 0
|
|
minz = 0
|
|
maxx = 0
|
|
maxy = 0
|
|
maxz = 0
|
|
|
|
for vertex in vertices:
|
|
if vertex[0] < minx:
|
|
minx = vertex[0]
|
|
if vertex[1] < miny:
|
|
miny = vertex[1]
|
|
if vertex[2] < minz:
|
|
minz = vertex[2]
|
|
|
|
if vertex[0] > maxx:
|
|
maxx = vertex[0]
|
|
if vertex[1] > maxy:
|
|
maxy = vertex[1]
|
|
if vertex[2] > maxz:
|
|
maxz = vertex[2]
|
|
|
|
return [minx, miny, minz], [maxx, maxy, maxz]
|
|
|
|
|
|
# #####################################################
|
|
# Generate - Triangles
|
|
# #####################################################
|
|
def triangulate_node_hierarchy(node):
|
|
node_attribute = node.GetNodeAttribute();
|
|
|
|
if node_attribute:
|
|
if node_attribute.GetAttributeType() == FbxNodeAttribute.eMesh or \
|
|
node_attribute.GetAttributeType() == FbxNodeAttribute.eNurbs or \
|
|
node_attribute.GetAttributeType() == FbxNodeAttribute.eNurbsSurface or \
|
|
node_attribute.GetAttributeType() == FbxNodeAttribute.ePatch:
|
|
converter.TriangulateInPlace(node);
|
|
|
|
child_count = node.GetChildCount()
|
|
for i in range(child_count):
|
|
triangulate_node_hierarchy(node.GetChild(i))
|
|
|
|
def triangulate_scene(scene):
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
triangulate_node_hierarchy(node.GetChild(i))
|
|
|
|
# #####################################################
|
|
# Generate - Material String
|
|
# #####################################################
|
|
def generate_texture_bindings(material_property, texture_list):
|
|
binding_types = {
|
|
"DiffuseColor": "map", "DiffuseFactor": "diffuseFactor", "EmissiveColor": "emissiveMap",
|
|
"EmissiveFactor": "emissiveFactor", "AmbientColor": "ambientMap", "AmbientFactor": "ambientFactor",
|
|
"SpecularColor": "specularMap", "SpecularFactor": "specularFactor", "ShininessExponent": "shininessExponent",
|
|
"NormalMap": "normalMap", "Bump": "bumpMap", "TransparentColor": "transparentMap",
|
|
"TransparencyFactor": "transparentFactor", "ReflectionColor": "reflectionMap",
|
|
"ReflectionFactor": "reflectionFactor", "DisplacementColor": "displacementMap",
|
|
"VectorDisplacementColor": "vectorDisplacementMap"
|
|
}
|
|
|
|
if material_property.IsValid():
|
|
#Here we have to check if it's layeredtextures, or just textures:
|
|
layered_texture_count = material_property.GetSrcObjectCount(FbxLayeredTexture.ClassId)
|
|
if layered_texture_count > 0:
|
|
for j in range(layered_texture_count):
|
|
layered_texture = material_property.GetSrcObject(FbxLayeredTexture.ClassId, j)
|
|
texture_count = layered_texture.GetSrcObjectCount(FbxTexture.ClassId)
|
|
for k in range(texture_count):
|
|
texture = layered_texture.GetSrcObject(FbxTexture.ClassId,k)
|
|
if texture:
|
|
texture_id = getTextureName(texture, True)
|
|
texture_binding = ' "%s": "%s",' % (binding_types[str(material_property.GetName())], texture_id)
|
|
texture_list.append(texture_binding)
|
|
else:
|
|
# no layered texture simply get on the property
|
|
texture_count = material_property.GetSrcObjectCount(FbxTexture.ClassId)
|
|
for j in range(texture_count):
|
|
texture = material_property.GetSrcObject(FbxTexture.ClassId,j)
|
|
if texture:
|
|
texture_id = getTextureName(texture, True)
|
|
texture_binding = ' "%s": "%s",' % (binding_types[str(material_property.GetName())], texture_id)
|
|
texture_list.append(texture_binding)
|
|
|
|
def generate_material_string(material):
|
|
#Get the implementation to see if it's a hardware shader.
|
|
implementation = GetImplementation(material, "ImplementationHLSL")
|
|
implementation_type = "HLSL"
|
|
if not implementation:
|
|
implementation = GetImplementation(material, "ImplementationCGFX")
|
|
implementation_type = "CGFX"
|
|
|
|
output = []
|
|
|
|
if implementation:
|
|
# This material is a hardware shader, skip it
|
|
print("Shader materials are not supported")
|
|
return ''
|
|
|
|
elif material.GetClassId().Is(FbxSurfaceLambert.ClassId):
|
|
|
|
ambient = str(getHex(material.Ambient.Get()))
|
|
diffuse = str(getHex(material.Diffuse.Get()))
|
|
emissive = str(getHex(material.Emissive.Get()))
|
|
opacity = 1.0 - material.TransparencyFactor.Get()
|
|
opacity = 1.0 if opacity == 0 else opacity
|
|
opacity = str(opacity)
|
|
transparent = BoolString(False)
|
|
reflectivity = "1"
|
|
|
|
output = [
|
|
|
|
'\t' + LabelString( getMaterialName( material ) ) + ': {',
|
|
' "type" : "MeshLambertMaterial",',
|
|
' "parameters" : {',
|
|
' "color" : ' + diffuse + ',',
|
|
' "ambient" : ' + ambient + ',',
|
|
' "emissive" : ' + emissive + ',',
|
|
' "reflectivity" : ' + reflectivity + ',',
|
|
' "transparent" : ' + transparent + ',',
|
|
' "opacity" : ' + opacity + ',',
|
|
|
|
]
|
|
|
|
elif material.GetClassId().Is(FbxSurfacePhong.ClassId):
|
|
|
|
ambient = str(getHex(material.Ambient.Get()))
|
|
diffuse = str(getHex(material.Diffuse.Get()))
|
|
emissive = str(getHex(material.Emissive.Get()))
|
|
specular = str(getHex(material.Specular.Get()))
|
|
opacity = 1.0 - material.TransparencyFactor.Get()
|
|
opacity = 1.0 if opacity == 0 else opacity
|
|
opacity = str(opacity)
|
|
shininess = str(material.Shininess.Get())
|
|
transparent = BoolString(False)
|
|
reflectivity = "1"
|
|
bumpScale = "1"
|
|
|
|
output = [
|
|
|
|
'\t' + LabelString( getMaterialName( material ) ) + ': {',
|
|
' "type" : "MeshPhongMaterial",',
|
|
' "parameters" : {',
|
|
' "color" : ' + diffuse + ',',
|
|
' "ambient" : ' + ambient + ',',
|
|
' "emissive" : ' + emissive + ',',
|
|
' "specular" : ' + specular + ',',
|
|
' "shininess" : ' + shininess + ',',
|
|
' "bumpScale" : ' + bumpScale + ',',
|
|
' "reflectivity" : ' + reflectivity + ',',
|
|
' "transparent" : ' + transparent + ',',
|
|
' "opacity" : ' + opacity + ',',
|
|
|
|
]
|
|
|
|
else:
|
|
print("Unknown type of Material")
|
|
return ''
|
|
|
|
if option_textures:
|
|
texture_list = []
|
|
texture_count = FbxLayerElement.sTypeTextureCount()
|
|
for texture_index in range(texture_count):
|
|
material_property = material.FindProperty(FbxLayerElement.sTextureChannelNames(texture_index))
|
|
generate_texture_bindings(material_property, texture_list)
|
|
|
|
output += texture_list
|
|
|
|
wireframe = BoolString(False)
|
|
wireframeLinewidth = "1"
|
|
|
|
output.append(' "wireframe" : ' + wireframe + ',')
|
|
output.append(' "wireframeLinewidth" : ' + wireframeLinewidth)
|
|
output.append(' }')
|
|
output.append('}')
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
def generate_proxy_material_string(node, material_names):
|
|
|
|
output = [
|
|
|
|
'\t' + LabelString( getMaterialName( node, True ) ) + ': {',
|
|
' "type" : "MeshFaceMaterial",',
|
|
' "parameters" : {',
|
|
' "materials" : ' + ArrayString( ",".join(LabelString(m) for m in material_names) ),
|
|
' }',
|
|
'}'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
# #####################################################
|
|
# Parse - Materials
|
|
# #####################################################
|
|
def extract_materials_from_node(node, material_list):
|
|
name = node.GetName()
|
|
mesh = node.GetNodeAttribute()
|
|
|
|
node = None
|
|
if mesh:
|
|
node = mesh.GetNode()
|
|
if node:
|
|
material_count = node.GetMaterialCount()
|
|
|
|
material_names = []
|
|
for l in range(mesh.GetLayerCount()):
|
|
materials = mesh.GetLayer(l).GetMaterials()
|
|
if materials:
|
|
if materials.GetReferenceMode() == FbxLayerElement.eIndex:
|
|
#Materials are in an undefined external table
|
|
continue
|
|
for i in range(material_count):
|
|
material = node.GetMaterial(i)
|
|
material_names.append(getMaterialName(material))
|
|
material_string = generate_material_string(material)
|
|
material_list.append(material_string)
|
|
|
|
if material_count > 1:
|
|
proxy_material = generate_proxy_material_string(node, material_names)
|
|
material_list.append(proxy_material)
|
|
|
|
|
|
def generate_materials_from_hierarchy(node, material_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh:
|
|
extract_materials_from_node(node, material_list)
|
|
for i in range(node.GetChildCount()):
|
|
generate_materials_from_hierarchy(node.GetChild(i), material_list)
|
|
|
|
def generate_material_list(scene):
|
|
material_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_materials_from_hierarchy(node.GetChild(i), material_list)
|
|
return material_list
|
|
|
|
# #####################################################
|
|
# Generate - Texture String
|
|
# #####################################################
|
|
def generate_texture_string(texture):
|
|
|
|
#TODO: extract more texture properties
|
|
wrap_u = texture.GetWrapModeU()
|
|
wrap_v = texture.GetWrapModeV()
|
|
offset = texture.GetUVTranslation()
|
|
|
|
output = [
|
|
|
|
'\t' + LabelString( getTextureName( texture, True ) ) + ': {',
|
|
' "url" : "' + texture.GetFileName() + '",',
|
|
' "repeat" : ' + Vector2String( (1,1) ) + ',',
|
|
' "offset" : ' + Vector2String( texture.GetUVTranslation() ) + ',',
|
|
' "magFilter" : ' + LabelString( "LinearFilter" ) + ',',
|
|
' "minFilter" : ' + LabelString( "LinearMipMapLinearFilter" ) + ',',
|
|
' "anisotropy" : ' + BoolString( True ),
|
|
'}'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
# #####################################################
|
|
# Parse - Textures
|
|
# #####################################################
|
|
def extract_material_textures(material_property, texture_list):
|
|
if material_property.IsValid():
|
|
#Here we have to check if it's layeredtextures, or just textures:
|
|
layered_texture_count = material_property.GetSrcObjectCount(FbxLayeredTexture.ClassId)
|
|
if layered_texture_count > 0:
|
|
for j in range(layered_texture_count):
|
|
layered_texture = material_property.GetSrcObject(FbxLayeredTexture.ClassId, j)
|
|
texture_count = layered_texture.GetSrcObjectCount(FbxTexture.ClassId)
|
|
for k in range(texture_count):
|
|
texture = layered_texture.GetSrcObject(FbxTexture.ClassId,k)
|
|
if texture:
|
|
texture_string = generate_texture_string(texture)
|
|
texture_list.append(texture_string)
|
|
else:
|
|
# no layered texture simply get on the property
|
|
texture_count = material_property.GetSrcObjectCount(FbxTexture.ClassId)
|
|
for j in range(texture_count):
|
|
texture = material_property.GetSrcObject(FbxTexture.ClassId,j)
|
|
if texture:
|
|
texture_string = generate_texture_string(texture)
|
|
texture_list.append(texture_string)
|
|
|
|
def extract_textures_from_node(node, texture_list):
|
|
name = node.GetName()
|
|
mesh = node.GetNodeAttribute()
|
|
|
|
#for all materials attached to this mesh
|
|
material_count = mesh.GetNode().GetSrcObjectCount(FbxSurfaceMaterial.ClassId)
|
|
for material_index in range(material_count):
|
|
material = mesh.GetNode().GetSrcObject(FbxSurfaceMaterial.ClassId, material_index)
|
|
|
|
#go through all the possible textures types
|
|
if material:
|
|
texture_count = FbxLayerElement.sTypeTextureCount()
|
|
for texture_index in range(texture_count):
|
|
material_property = material.FindProperty(FbxLayerElement.sTextureChannelNames(texture_index))
|
|
extract_material_textures(material_property, texture_list)
|
|
|
|
def generate_textures_from_hierarchy(node, texture_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh:
|
|
extract_textures_from_node(node, texture_list)
|
|
for i in range(node.GetChildCount()):
|
|
generate_textures_from_hierarchy(node.GetChild(i), texture_list)
|
|
|
|
def generate_texture_list(scene):
|
|
if not option_textures:
|
|
return []
|
|
|
|
texture_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_textures_from_hierarchy(node.GetChild(i), texture_list)
|
|
return texture_list
|
|
|
|
# #####################################################
|
|
# Extract - Fbx Mesh data
|
|
# #####################################################
|
|
def extract_fbx_vertex_positions(mesh):
|
|
control_points_count = mesh.GetControlPointsCount()
|
|
control_points = mesh.GetControlPoints()
|
|
|
|
positions = []
|
|
for i in range(control_points_count):
|
|
positions.append(convert_fbx_vec3(control_points[i]))
|
|
|
|
node = mesh.GetNode()
|
|
if node and option_geometry:
|
|
# FbxMeshes are local to their node, we need the vertices in global space
|
|
# when scene nodes are not exported
|
|
transform = node.EvaluateGlobalTransform()
|
|
transform = FbxMatrix(transform)
|
|
|
|
for i in range(len(positions)):
|
|
v = positions[i]
|
|
position = FbxVector4(v[0], v[1], v[2])
|
|
position = transform.MultNormalize(position)
|
|
positions[i] = convert_fbx_vec3(position)
|
|
|
|
return positions
|
|
|
|
def extract_fbx_vertex_normals(mesh):
|
|
# eNone The mapping is undetermined.
|
|
# eByControlPoint There will be one mapping coordinate for each surface control point/vertex.
|
|
# eByPolygonVertex There will be one mapping coordinate for each vertex, for every polygon of which it is a part. This means that a vertex will have as many mapping coordinates as polygons of which it is a part.
|
|
# eByPolygon There can be only one mapping coordinate for the whole polygon.
|
|
# eByEdge There will be one mapping coordinate for each unique edge in the mesh. This is meant to be used with smoothing layer elements.
|
|
# eAllSame There can be only one mapping coordinate for the whole surface.
|
|
|
|
layered_normal_indices = []
|
|
layered_normal_values = []
|
|
|
|
poly_count = mesh.GetPolygonCount()
|
|
control_points = mesh.GetControlPoints()
|
|
|
|
for l in range(mesh.GetLayerCount()):
|
|
mesh_normals = mesh.GetLayer(l).GetNormals()
|
|
if not mesh_normals:
|
|
continue
|
|
|
|
normals_array = mesh_normals.GetDirectArray()
|
|
normals_count = normals_array.GetCount()
|
|
|
|
if normals_count == 0:
|
|
continue
|
|
|
|
normal_indices = []
|
|
normal_values = []
|
|
|
|
# values
|
|
for i in range(normals_count):
|
|
normal = convert_fbx_vec3(normals_array.GetAt(i))
|
|
normal_values.append(normal)
|
|
|
|
node = mesh.GetNode()
|
|
if node and option_geometry:
|
|
# FbxMeshes are local to their node, we need the normals in global space
|
|
# when scene nodes are not exported
|
|
transform = node.EvaluateGlobalTransform()
|
|
transform.SetT(FbxVector4(0,0,0,0))
|
|
transform = FbxMatrix(transform)
|
|
|
|
for i in range(len(normal_values)):
|
|
n = normal_values[i]
|
|
normal = FbxVector4(n[0], n[1], n[2])
|
|
normal = transform.MultNormalize(normal)
|
|
normal_values[i] = convert_fbx_vec3(normal)
|
|
|
|
# indices
|
|
vertexId = 0
|
|
for p in range(poly_count):
|
|
poly_size = mesh.GetPolygonSize(p)
|
|
poly_normals = []
|
|
|
|
for v in range(poly_size):
|
|
control_point_index = mesh.GetPolygonVertex(p, v)
|
|
|
|
if mesh_normals.GetMappingMode() == FbxLayerElement.eByControlPoint:
|
|
if mesh_normals.GetReferenceMode() == FbxLayerElement.eDirect:
|
|
poly_normals.append(control_point_index)
|
|
elif mesh_normals.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
index = mesh_normals.GetIndexArray().GetAt(control_point_index)
|
|
poly_normals.append(index)
|
|
elif mesh_normals.GetMappingMode() == FbxLayerElement.eByPolygonVertex:
|
|
if mesh_normals.GetReferenceMode() == FbxLayerElement.eDirect:
|
|
poly_normals.append(vertexId)
|
|
elif mesh_normals.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
index = mesh_normals.GetIndexArray().GetAt(vertexId)
|
|
poly_normals.append(index)
|
|
elif mesh_normals.GetMappingMode() == FbxLayerElement.eByPolygon or \
|
|
mesh_normals.GetMappingMode() == FbxLayerElement.eAllSame or \
|
|
mesh_normals.GetMappingMode() == FbxLayerElement.eNone:
|
|
print("unsupported normal mapping mode for polygon vertex")
|
|
|
|
vertexId += 1
|
|
normal_indices.append(poly_normals)
|
|
|
|
layered_normal_values.append(normal_values)
|
|
layered_normal_indices.append(normal_indices)
|
|
|
|
normal_values = []
|
|
normal_indices = []
|
|
|
|
# Three.js only supports one layer of normals
|
|
if len(layered_normal_values) > 0:
|
|
normal_values = layered_normal_values[0]
|
|
normal_indices = layered_normal_indices[0]
|
|
|
|
return normal_values, normal_indices
|
|
|
|
def extract_fbx_vertex_colors(mesh):
|
|
# eNone The mapping is undetermined.
|
|
# eByControlPoint There will be one mapping coordinate for each surface control point/vertex.
|
|
# eByPolygonVertex There will be one mapping coordinate for each vertex, for every polygon of which it is a part. This means that a vertex will have as many mapping coordinates as polygons of which it is a part.
|
|
# eByPolygon There can be only one mapping coordinate for the whole polygon.
|
|
# eByEdge There will be one mapping coordinate for each unique edge in the mesh. This is meant to be used with smoothing layer elements.
|
|
# eAllSame There can be only one mapping coordinate for the whole surface.
|
|
|
|
layered_color_indices = []
|
|
layered_color_values = []
|
|
|
|
poly_count = mesh.GetPolygonCount()
|
|
control_points = mesh.GetControlPoints()
|
|
|
|
for l in range(mesh.GetLayerCount()):
|
|
mesh_colors = mesh.GetLayer(l).GetVertexColors()
|
|
if not mesh_colors:
|
|
continue
|
|
|
|
colors_array = mesh_colors.GetDirectArray()
|
|
colors_count = colors_array.GetCount()
|
|
|
|
if colors_count == 0:
|
|
continue
|
|
|
|
color_indices = []
|
|
color_values = []
|
|
|
|
# values
|
|
for i in range(colors_count):
|
|
color = convert_fbx_color(colors_array.GetAt(i))
|
|
color_values.append(color)
|
|
|
|
# indices
|
|
vertexId = 0
|
|
for p in range(poly_count):
|
|
poly_size = mesh.GetPolygonSize(p)
|
|
poly_colors = []
|
|
|
|
for v in range(poly_size):
|
|
control_point_index = mesh.GetPolygonVertex(p, v)
|
|
|
|
if mesh_colors.GetMappingMode() == FbxLayerElement.eByControlPoint:
|
|
if mesh_colors.GetReferenceMode() == FbxLayerElement.eDirect:
|
|
poly_colors.append(control_point_index)
|
|
elif mesh_colors.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
index = mesh_colors.GetIndexArray().GetAt(control_point_index)
|
|
poly_colors.append(index)
|
|
elif mesh_colors.GetMappingMode() == FbxLayerElement.eByPolygonVertex:
|
|
if mesh_colors.GetReferenceMode() == FbxLayerElement.eDirect:
|
|
poly_colors.append(vertexId)
|
|
elif mesh_colors.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
index = mesh_colors.GetIndexArray().GetAt(vertexId)
|
|
poly_colors.append(index)
|
|
elif mesh_colors.GetMappingMode() == FbxLayerElement.eByPolygon or \
|
|
mesh_colors.GetMappingMode() == FbxLayerElement.eAllSame or \
|
|
mesh_colors.GetMappingMode() == FbxLayerElement.eNone:
|
|
print("unsupported color mapping mode for polygon vertex")
|
|
|
|
vertexId += 1
|
|
color_indices.append(poly_colors)
|
|
|
|
color_values = []
|
|
color_indices = []
|
|
|
|
# Three.js only supports one layer of colors
|
|
if len(layered_color_values) > 0:
|
|
color_values = layered_color_values[0]
|
|
color_indices = layered_color_indices[0]
|
|
|
|
return color_values, color_indices
|
|
|
|
def extract_fbx_vertex_uvs(mesh):
|
|
# eNone The mapping is undetermined.
|
|
# eByControlPoint There will be one mapping coordinate for each surface control point/vertex.
|
|
# eByPolygonVertex There will be one mapping coordinate for each vertex, for every polygon of which it is a part. This means that a vertex will have as many mapping coordinates as polygons of which it is a part.
|
|
# eByPolygon There can be only one mapping coordinate for the whole polygon.
|
|
# eByEdge There will be one mapping coordinate for each unique edge in the mesh. This is meant to be used with smoothing layer elements.
|
|
# eAllSame There can be only one mapping coordinate for the whole surface.
|
|
|
|
layered_uv_indices = []
|
|
layered_uv_values = []
|
|
|
|
poly_count = mesh.GetPolygonCount()
|
|
control_points = mesh.GetControlPoints()
|
|
|
|
for l in range(mesh.GetLayerCount()):
|
|
mesh_uvs = mesh.GetLayer(l).GetUVs()
|
|
if not mesh_uvs:
|
|
continue
|
|
|
|
uvs_array = mesh_uvs.GetDirectArray()
|
|
uvs_count = uvs_array.GetCount()
|
|
|
|
if uvs_count == 0:
|
|
continue
|
|
|
|
uv_indices = []
|
|
uv_values = []
|
|
|
|
# values
|
|
for i in range(uvs_count):
|
|
uv = convert_fbx_vec2(uvs_array.GetAt(i))
|
|
uv_values.append(uv)
|
|
|
|
# indices
|
|
vertexId = 0
|
|
for p in range(poly_count):
|
|
poly_size = mesh.GetPolygonSize(p)
|
|
poly_uvs = []
|
|
|
|
for v in range(poly_size):
|
|
control_point_index = mesh.GetPolygonVertex(p, v)
|
|
|
|
if mesh_uvs.GetMappingMode() == FbxLayerElement.eByControlPoint:
|
|
if mesh_uvs.GetReferenceMode() == FbxLayerElement.eDirect:
|
|
poly_uvs.append(control_point_index)
|
|
elif mesh_uvs.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
index = mesh_uvs.GetIndexArray().GetAt(control_point_index)
|
|
poly_uvs.append(index)
|
|
elif mesh_uvs.GetMappingMode() == FbxLayerElement.eByPolygonVertex:
|
|
uv_texture_index = mesh.GetTextureUVIndex(p, v)
|
|
if mesh_uvs.GetReferenceMode() == FbxLayerElement.eDirect or \
|
|
mesh_uvs.GetReferenceMode() == FbxLayerElement.eIndexToDirect:
|
|
poly_uvs.append(uv_texture_index)
|
|
elif mesh_uvs.GetMappingMode() == FbxLayerElement.eByPolygon or \
|
|
mesh_uvs.GetMappingMode() == FbxLayerElement.eAllSame or \
|
|
mesh_uvs.GetMappingMode() == FbxLayerElement.eNone:
|
|
print("unsupported uv mapping mode for polygon vertex")
|
|
|
|
vertexId += 1
|
|
uv_indices.append(poly_uvs)
|
|
|
|
layered_uv_values.append(uv_values)
|
|
layered_uv_indices.append(uv_indices)
|
|
|
|
return layered_uv_values, layered_uv_indices
|
|
|
|
# #####################################################
|
|
# Generate - Mesh String (for scene output)
|
|
# #####################################################
|
|
def generate_mesh_string_for_scene_output(node):
|
|
mesh = node.GetNodeAttribute()
|
|
mesh_list = [ mesh ]
|
|
|
|
vertices, vertex_offsets = process_mesh_vertices(mesh_list)
|
|
materials, material_offsets = process_mesh_materials(mesh_list)
|
|
|
|
normals_to_indices = generate_unique_normals_dictionary(mesh_list)
|
|
colors_to_indices = generate_unique_colors_dictionary(mesh_list)
|
|
uvs_to_indices_list = generate_unique_uvs_dictionary_layers(mesh_list)
|
|
|
|
normal_values = generate_normals_from_dictionary(normals_to_indices)
|
|
color_values = generate_colors_from_dictionary(colors_to_indices)
|
|
uv_values = generate_uvs_from_dictionary_layers(uvs_to_indices_list)
|
|
|
|
faces = process_mesh_polygons(mesh_list,
|
|
normals_to_indices,
|
|
colors_to_indices,
|
|
uvs_to_indices_list,
|
|
vertex_offsets,
|
|
material_offsets)
|
|
|
|
nuvs = []
|
|
for layer_index, uvs in enumerate(uv_values):
|
|
nuvs.append(str(len(uvs)))
|
|
|
|
nvertices = len(vertices)
|
|
nnormals = len(normal_values)
|
|
ncolors = len(color_values)
|
|
nfaces = len(faces)
|
|
nuvs = ",".join(nuvs)
|
|
|
|
aabb_min, aabb_max = generate_bounding_box(vertices)
|
|
aabb_min = ",".join(str(f) for f in aabb_min)
|
|
aabb_max = ",".join(str(f) for f in aabb_max)
|
|
|
|
vertices = ",".join(Vector3String(v, True) for v in vertices)
|
|
normals = ",".join(Vector3String(v, True) for v in normal_values)
|
|
colors = ",".join(Vector3String(v, True) for v in color_values)
|
|
faces = ",".join(faces)
|
|
uvs = generate_uvs(uv_values)
|
|
|
|
output = [
|
|
|
|
'\t' + LabelString( getEmbedName( node, True ) ) + ' : {',
|
|
' "metadata" : {',
|
|
' "vertices" : ' + str(nvertices) + ',',
|
|
' "normals" : ' + str(nnormals) + ',',
|
|
' "colors" : ' + str(ncolors) + ',',
|
|
' "faces" : ' + str(nfaces) + ',',
|
|
' "uvs" : ' + ArrayString(nuvs),
|
|
' },',
|
|
' "boundingBox" : {',
|
|
' "min" : ' + ArrayString(aabb_min) + ',',
|
|
' "max" : ' + ArrayString(aabb_max),
|
|
' },',
|
|
' "scale" : ' + str( 1 ) + ',',
|
|
' "materials" : ' + ArrayString("") + ',',
|
|
' "vertices" : ' + ArrayString(vertices) + ',',
|
|
' "normals" : ' + ArrayString(normals) + ',',
|
|
' "colors" : ' + ArrayString(colors) + ',',
|
|
' "uvs" : ' + ArrayString(uvs) + ',',
|
|
' "faces" : ' + ArrayString(faces),
|
|
'}'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
# #####################################################
|
|
# Generate - Mesh String (for non-scene output)
|
|
# #####################################################
|
|
def generate_mesh_string_for_non_scene_output(scene):
|
|
mesh_list = generate_mesh_list(scene)
|
|
|
|
vertices, vertex_offsets = process_mesh_vertices(mesh_list)
|
|
materials, material_offsets = process_mesh_materials(mesh_list)
|
|
|
|
normals_to_indices = generate_unique_normals_dictionary(mesh_list)
|
|
colors_to_indices = generate_unique_colors_dictionary(mesh_list)
|
|
uvs_to_indices_list = generate_unique_uvs_dictionary_layers(mesh_list)
|
|
|
|
normal_values = generate_normals_from_dictionary(normals_to_indices)
|
|
color_values = generate_colors_from_dictionary(colors_to_indices)
|
|
uv_values = generate_uvs_from_dictionary_layers(uvs_to_indices_list)
|
|
|
|
faces = process_mesh_polygons(mesh_list,
|
|
normals_to_indices,
|
|
colors_to_indices,
|
|
uvs_to_indices_list,
|
|
vertex_offsets,
|
|
material_offsets)
|
|
|
|
nuvs = []
|
|
for layer_index, uvs in enumerate(uv_values):
|
|
nuvs.append(str(len(uvs)))
|
|
|
|
nvertices = len(vertices)
|
|
nnormals = len(normal_values)
|
|
ncolors = len(color_values)
|
|
nfaces = len(faces)
|
|
nuvs = ",".join(nuvs)
|
|
|
|
aabb_min, aabb_max = generate_bounding_box(vertices)
|
|
aabb_min = ",".join(str(f) for f in aabb_min)
|
|
aabb_max = ",".join(str(f) for f in aabb_max)
|
|
|
|
vertices = ",".join(Vector3String(v, True) for v in vertices)
|
|
normals = ",".join(Vector3String(v, True) for v in normal_values)
|
|
colors = ",".join(Vector3String(v, True) for v in color_values)
|
|
faces = ",".join(faces)
|
|
uvs = generate_uvs(uv_values)
|
|
|
|
output = [
|
|
|
|
'{',
|
|
' "metadata" : {',
|
|
' "formatVersion" : 3.2,',
|
|
' "type" : "geometry",',
|
|
' "generatedBy" : "convert-to-threejs.py"' + ',',
|
|
' "vertices" : ' + str(nvertices) + ',',
|
|
' "normals" : ' + str(nnormals) + ',',
|
|
' "colors" : ' + str(ncolors) + ',',
|
|
' "faces" : ' + str(nfaces) + ',',
|
|
' "uvs" : ' + ArrayString(nuvs),
|
|
' },',
|
|
' "boundingBox" : {',
|
|
' "min" : ' + ArrayString(aabb_min) + ',',
|
|
' "max" : ' + ArrayString(aabb_max),
|
|
' },',
|
|
' "scale" : ' + str( 1 ) + ',',
|
|
' "materials" : ' + ArrayString("") + ',',
|
|
' "vertices" : ' + ArrayString(vertices) + ',',
|
|
' "normals" : ' + ArrayString(normals) + ',',
|
|
' "colors" : ' + ArrayString(colors) + ',',
|
|
' "uvs" : ' + ArrayString(uvs) + ',',
|
|
' "faces" : ' + ArrayString(faces),
|
|
'}'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n', 0 )
|
|
|
|
# #####################################################
|
|
# Process - Mesh Geometry
|
|
# #####################################################
|
|
def generate_normal_key(normal):
|
|
return (round(normal[0], 6), round(normal[1], 6), round(normal[2], 6))
|
|
|
|
def generate_color_key(color):
|
|
return getHex(color)
|
|
|
|
def generate_uv_key(uv):
|
|
return (round(uv[0], 6), round(uv[1], 6))
|
|
|
|
def append_non_duplicate_uvs(source_uvs, dest_uvs, counts):
|
|
source_layer_count = len(source_uvs)
|
|
for layer_index in range(source_layer_count):
|
|
|
|
dest_layer_count = len(dest_uvs)
|
|
|
|
if dest_layer_count <= layer_index:
|
|
dest_uv_layer = {}
|
|
count = 0
|
|
dest_uvs.append(dest_uv_layer)
|
|
counts.append(count)
|
|
else:
|
|
dest_uv_layer = dest_uvs[layer_index]
|
|
count = counts[layer_index]
|
|
|
|
source_uv_layer = source_uvs[layer_index]
|
|
|
|
for uv in source_uv_layer:
|
|
key = generate_uv_key(uv)
|
|
if key not in dest_uv_layer:
|
|
dest_uv_layer[key] = count
|
|
count += 1
|
|
|
|
counts[layer_index] = count
|
|
|
|
return counts
|
|
|
|
def generate_unique_normals_dictionary(mesh_list):
|
|
normals_dictionary = {}
|
|
nnormals = 0
|
|
|
|
# Merge meshes, remove duplicate data
|
|
for mesh in mesh_list:
|
|
node = mesh.GetNode()
|
|
normal_values, normal_indices = extract_fbx_vertex_normals(mesh)
|
|
|
|
if len(normal_values) > 0:
|
|
for normal in normal_values:
|
|
key = generate_normal_key(normal)
|
|
if key not in normals_dictionary:
|
|
normals_dictionary[key] = nnormals
|
|
nnormals += 1
|
|
|
|
return normals_dictionary
|
|
|
|
def generate_unique_colors_dictionary(mesh_list):
|
|
colors_dictionary = {}
|
|
ncolors = 0
|
|
|
|
# Merge meshes, remove duplicate data
|
|
for mesh in mesh_list:
|
|
color_values, color_indices = extract_fbx_vertex_colors(mesh)
|
|
|
|
if len(color_values) > 0:
|
|
for color in color_values:
|
|
key = generate_color_key(color)
|
|
if key not in colors_dictionary:
|
|
colors_dictionary[key] = count
|
|
count += 1
|
|
|
|
return colors_dictionary
|
|
|
|
def generate_unique_uvs_dictionary_layers(mesh_list):
|
|
uvs_dictionary_layers = []
|
|
nuvs_list = []
|
|
|
|
# Merge meshes, remove duplicate data
|
|
for mesh in mesh_list:
|
|
uv_values, uv_indices = extract_fbx_vertex_uvs(mesh)
|
|
|
|
if len(uv_values) > 0:
|
|
nuvs_list = append_non_duplicate_uvs(uv_values, uvs_dictionary_layers, nuvs_list)
|
|
|
|
return uvs_dictionary_layers
|
|
|
|
def generate_normals_from_dictionary(normals_dictionary):
|
|
normal_values = []
|
|
for key, index in sorted(normals_dictionary.items(), key = operator.itemgetter(1)):
|
|
normal_values.append(key)
|
|
|
|
return normal_values
|
|
|
|
def generate_colors_from_dictionary(colors_dictionary):
|
|
color_values = []
|
|
for key, index in sorted(colors_dictionary.items(), key = operator.itemgetter(1)):
|
|
color_values.append(key)
|
|
|
|
return color_values
|
|
|
|
def generate_uvs_from_dictionary_layers(uvs_dictionary_layers):
|
|
uv_values = []
|
|
for uvs_dictionary in uvs_dictionary_layers:
|
|
uv_values_layer = []
|
|
for key, index in sorted(uvs_dictionary.items(), key = operator.itemgetter(1)):
|
|
uv_values_layer.append(key)
|
|
uv_values.append(uv_values_layer)
|
|
|
|
return uv_values
|
|
|
|
def generate_normal_indices_for_poly(poly_index, mesh_normal_values, mesh_normal_indices, normals_to_indices):
|
|
if len(mesh_normal_indices) <= 0:
|
|
return []
|
|
|
|
poly_normal_indices = mesh_normal_indices[poly_index]
|
|
poly_size = len(poly_normal_indices)
|
|
|
|
output_poly_normal_indices = []
|
|
for v in range(poly_size):
|
|
normal_index = poly_normal_indices[v]
|
|
normal_value = mesh_normal_values[normal_index]
|
|
|
|
key = generate_normal_key(normal_value)
|
|
|
|
output_index = normals_to_indices[key]
|
|
output_poly_normal_indices.append(output_index)
|
|
|
|
return output_poly_normal_indices
|
|
|
|
def generate_color_indices_for_poly(poly_index, mesh_color_values, mesh_color_indices, colors_to_indices):
|
|
if len(mesh_color_indices) <= 0:
|
|
return []
|
|
|
|
poly_color_indices = mesh_color_indices[poly_index]
|
|
poly_size = len(poly_color_indices)
|
|
|
|
output_poly_color_indices = []
|
|
for v in range(poly_size):
|
|
color_index = poly_color_indices[v]
|
|
color_value = mesh_color_values[color_index]
|
|
|
|
key = generate_color_key(color_value)
|
|
|
|
output_index = colors_to_indices[key]
|
|
output_poly_color_indices.append(output_index)
|
|
|
|
return output_poly_color_indices
|
|
|
|
def generate_uv_indices_for_poly(poly_index, mesh_uv_values, mesh_uv_indices, uvs_to_indices):
|
|
if len(mesh_uv_indices) <= 0:
|
|
return []
|
|
|
|
poly_uv_indices = mesh_uv_indices[poly_index]
|
|
poly_size = len(poly_uv_indices)
|
|
|
|
output_poly_uv_indices = []
|
|
for v in range(poly_size):
|
|
uv_index = poly_uv_indices[v]
|
|
uv_value = mesh_uv_values[uv_index]
|
|
|
|
key = generate_uv_key(uv_value)
|
|
|
|
output_index = uvs_to_indices[key]
|
|
output_poly_uv_indices.append(output_index)
|
|
|
|
return output_poly_uv_indices
|
|
|
|
def process_mesh_vertices(mesh_list):
|
|
vertex_offset = 0
|
|
vertex_offset_list = [0]
|
|
vertices = []
|
|
for mesh in mesh_list:
|
|
node = mesh.GetNode()
|
|
mesh_vertices = extract_fbx_vertex_positions(mesh)
|
|
|
|
vertices.extend(mesh_vertices[:])
|
|
vertex_offset += len(mesh_vertices)
|
|
vertex_offset_list.append(vertex_offset)
|
|
|
|
return vertices, vertex_offset_list
|
|
|
|
def process_mesh_materials(mesh_list):
|
|
material_offset = 0
|
|
material_offset_list = [0]
|
|
materials_list = []
|
|
|
|
#TODO: remove duplicate mesh references
|
|
for mesh in mesh_list:
|
|
node = mesh.GetNode()
|
|
|
|
material_count = node.GetMaterialCount()
|
|
if material_count > 0:
|
|
for l in range(mesh.GetLayerCount()):
|
|
materials = mesh.GetLayer(l).GetMaterials()
|
|
if materials:
|
|
if materials.GetReferenceMode() == FbxLayerElement.eIndex:
|
|
#Materials are in an undefined external table
|
|
continue
|
|
|
|
for i in range(material_count):
|
|
material = node.GetMaterial(i)
|
|
materials_list.append( material )
|
|
|
|
material_offset += material_count
|
|
material_offset_list.append(material_offset)
|
|
|
|
return materials_list, material_offset_list
|
|
|
|
def process_mesh_polygons(mesh_list, normals_to_indices, colors_to_indices, uvs_to_indices_list, vertex_offset_list, material_offset_list):
|
|
faces = []
|
|
for mesh_index in range(len(mesh_list)):
|
|
mesh = mesh_list[mesh_index]
|
|
poly_count = mesh.GetPolygonCount()
|
|
control_points = mesh.GetControlPoints()
|
|
|
|
normal_values, normal_indices = extract_fbx_vertex_normals(mesh)
|
|
color_values, color_indices = extract_fbx_vertex_colors(mesh)
|
|
uv_values_layers, uv_indices_layers = extract_fbx_vertex_uvs(mesh)
|
|
|
|
for poly_index in range(poly_count):
|
|
poly_size = mesh.GetPolygonSize(poly_index)
|
|
|
|
face_normals = generate_normal_indices_for_poly(poly_index, normal_values, normal_indices, normals_to_indices)
|
|
face_colors = generate_color_indices_for_poly(poly_index, color_values, color_indices, colors_to_indices)
|
|
|
|
face_uv_layers = []
|
|
for l in range(len(uv_indices_layers)):
|
|
uv_values = uv_values_layers[l]
|
|
uv_indices = uv_indices_layers[l]
|
|
face_uv_indices = generate_uv_indices_for_poly(poly_index, uv_values, uv_indices, uvs_to_indices_list[l])
|
|
face_uv_layers.append(face_uv_indices)
|
|
|
|
face_vertices = []
|
|
for vertex_index in range(poly_size):
|
|
control_point_index = mesh.GetPolygonVertex(poly_index, vertex_index)
|
|
face_vertices.append(control_point_index)
|
|
|
|
#TODO: assign a default material to any mesh without one
|
|
if len(material_offset_list) <= mesh_index:
|
|
material_offset = 0
|
|
else:
|
|
material_offset = material_offset_list[mesh_index]
|
|
|
|
vertex_offset = vertex_offset_list[mesh_index]
|
|
|
|
face = generate_mesh_face(mesh,
|
|
poly_index,
|
|
face_vertices,
|
|
face_normals,
|
|
face_colors,
|
|
face_uv_layers,
|
|
vertex_offset,
|
|
material_offset)
|
|
|
|
faces.append(face)
|
|
|
|
|
|
return faces
|
|
|
|
def generate_mesh_face(mesh, polygon_index, vertex_indices, normals, colors, uv_layers, vertex_offset, material_offset):
|
|
isTriangle = ( len(vertex_indices) == 3 )
|
|
nVertices = 3 if isTriangle else 4
|
|
|
|
hasMaterial = False
|
|
for l in range(mesh.GetLayerCount()):
|
|
materials = mesh.GetLayer(l).GetMaterials()
|
|
if materials:
|
|
hasMaterial = True
|
|
break
|
|
|
|
hasFaceUvs = False
|
|
hasFaceVertexUvs = len(uv_layers) > 0
|
|
hasFaceNormals = False
|
|
hasFaceVertexNormals = len(normals) > 0
|
|
hasFaceColors = False
|
|
hasFaceVertexColors = len(colors) > 0
|
|
|
|
faceType = 0
|
|
faceType = setBit(faceType, 0, not isTriangle)
|
|
faceType = setBit(faceType, 1, hasMaterial)
|
|
faceType = setBit(faceType, 2, hasFaceUvs)
|
|
faceType = setBit(faceType, 3, hasFaceVertexUvs)
|
|
faceType = setBit(faceType, 4, hasFaceNormals)
|
|
faceType = setBit(faceType, 5, hasFaceVertexNormals)
|
|
faceType = setBit(faceType, 6, hasFaceColors)
|
|
faceType = setBit(faceType, 7, hasFaceVertexColors)
|
|
|
|
faceData = []
|
|
|
|
# order is important, must match order in JSONLoader
|
|
|
|
# face type
|
|
# vertex indices
|
|
# material index
|
|
# face uvs index
|
|
# face vertex uvs indices
|
|
# face color index
|
|
# face vertex colors indices
|
|
|
|
faceData.append(faceType)
|
|
|
|
tmp = []
|
|
for i in range(nVertices):
|
|
tmp.append(vertex_indices[i])
|
|
index = vertex_indices[i] + vertex_offset
|
|
faceData.append(index)
|
|
|
|
if hasMaterial:
|
|
material_id = 0
|
|
for l in range(mesh.GetLayerCount()):
|
|
materials = mesh.GetLayer(l).GetMaterials()
|
|
if materials:
|
|
material_id = materials.GetIndexArray().GetAt(polygon_index)
|
|
break
|
|
material_id += material_offset
|
|
faceData.append( material_id )
|
|
|
|
if hasFaceVertexUvs:
|
|
for polygon_uvs in uv_layers:
|
|
for i in range(nVertices):
|
|
index = polygon_uvs[i]
|
|
faceData.append(index)
|
|
|
|
if hasFaceVertexNormals:
|
|
for i in range(nVertices):
|
|
index = normals[i]
|
|
faceData.append(index)
|
|
|
|
if hasFaceVertexColors:
|
|
for i in range(nVertices):
|
|
index = colors[i]
|
|
faceData.append(index)
|
|
|
|
return ",".join( map(str, faceData) )
|
|
|
|
|
|
# #####################################################
|
|
# Generate - Mesh List
|
|
# #####################################################
|
|
def generate_mesh_list_from_hierarchy(node, mesh_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh or \
|
|
attribute_type == FbxNodeAttribute.eNurbs or \
|
|
attribute_type == FbxNodeAttribute.eNurbsSurface or \
|
|
attribute_type == FbxNodeAttribute.ePatch:
|
|
|
|
if attribute_type != FbxNodeAttribute.eMesh:
|
|
converter.TriangulateInPlace(node);
|
|
|
|
mesh_list.append(node.GetNodeAttribute())
|
|
|
|
for i in range(node.GetChildCount()):
|
|
generate_mesh_list_from_hierarchy(node.GetChild(i), mesh_list)
|
|
|
|
def generate_mesh_list(scene):
|
|
mesh_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_mesh_list_from_hierarchy(node.GetChild(i), mesh_list)
|
|
return mesh_list
|
|
|
|
# #####################################################
|
|
# Generate - Embeds
|
|
# #####################################################
|
|
def generate_embed_list_from_hierarchy(node, embed_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh or \
|
|
attribute_type == FbxNodeAttribute.eNurbs or \
|
|
attribute_type == FbxNodeAttribute.eNurbsSurface or \
|
|
attribute_type == FbxNodeAttribute.ePatch:
|
|
|
|
if attribute_type != FbxNodeAttribute.eMesh:
|
|
converter.TriangulateInPlace(node);
|
|
|
|
embed_string = generate_mesh_string_for_scene_output(node)
|
|
embed_list.append(embed_string)
|
|
|
|
for i in range(node.GetChildCount()):
|
|
generate_embed_list_from_hierarchy(node.GetChild(i), embed_list)
|
|
|
|
def generate_embed_list(scene):
|
|
embed_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_embed_list_from_hierarchy(node.GetChild(i), embed_list)
|
|
return embed_list
|
|
|
|
# #####################################################
|
|
# Generate - Geometries
|
|
# #####################################################
|
|
def generate_geometry_string(node):
|
|
|
|
output = [
|
|
'\t' + LabelString( getGeometryName( node, True ) ) + ' : {',
|
|
' "type" : "embedded",',
|
|
' "id" : ' + LabelString( getEmbedName( node, True ) ),
|
|
'}'
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
def generate_geometry_list_from_hierarchy(node, geometry_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh:
|
|
geometry_string = generate_geometry_string(node)
|
|
geometry_list.append(geometry_string)
|
|
for i in range(node.GetChildCount()):
|
|
generate_geometry_list_from_hierarchy(node.GetChild(i), geometry_list)
|
|
|
|
def generate_geometry_list(scene):
|
|
geometry_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_geometry_list_from_hierarchy(node.GetChild(i), geometry_list)
|
|
return geometry_list
|
|
|
|
# #####################################################
|
|
# Generate - Camera Names
|
|
# #####################################################
|
|
def generate_camera_name_list_from_hierarchy(node, camera_list):
|
|
if node.GetNodeAttribute() == None:
|
|
pass
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eCamera:
|
|
camera_string = getObjectName(node)
|
|
camera_list.append(camera_string)
|
|
for i in range(node.GetChildCount()):
|
|
generate_camera_name_list_from_hierarchy(node.GetChild(i), camera_list)
|
|
|
|
def generate_camera_name_list(scene):
|
|
camera_list = []
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
generate_camera_name_list_from_hierarchy(node.GetChild(i), camera_list)
|
|
return camera_list
|
|
|
|
# #####################################################
|
|
# Generate - Light Object
|
|
# #####################################################
|
|
def generate_default_light_string(padding):
|
|
direction = (1,1,1)
|
|
color = (1,1,1)
|
|
intensity = 80.0
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( 'default_light' ) + ' : {',
|
|
' "type" : "DirectionalLight",',
|
|
' "color" : ' + str(getHex(color)) + ',',
|
|
' "intensity" : ' + str(intensity/100.0) + ',',
|
|
' "direction" : ' + Vector3String( direction ) + ',',
|
|
' "target" : ' + LabelString( getObjectName( None ) ),
|
|
' }'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
def generate_light_string(node, padding):
|
|
light = node.GetNodeAttribute()
|
|
light_types = ["point", "directional", "spot", "area", "volume"]
|
|
light_type = light_types[light.LightType.Get()]
|
|
|
|
transform = node.EvaluateLocalTransform()
|
|
position = transform.GetT()
|
|
|
|
output = []
|
|
|
|
if light_type == "directional":
|
|
|
|
# Three.js directional lights emit light from a point in 3d space to a target node or the origin.
|
|
# When there is no target, we need to take a point, one unit away from the origin, and move it
|
|
# into the right location so that the origin acts like the target
|
|
|
|
if node.GetTarget():
|
|
direction = position
|
|
else:
|
|
translation = FbxVector4(0,0,0,0)
|
|
scale = FbxVector4(1,1,1,1)
|
|
rotation = transform.GetR()
|
|
matrix = FbxMatrix(translation, rotation, scale)
|
|
direction = matrix.MultNormalize(global_up_vector)
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "DirectionalLight",',
|
|
' "color" : ' + str(getHex(light.Color.Get())) + ',',
|
|
' "intensity" : ' + str(light.Intensity.Get()/100.0) + ',',
|
|
' "direction" : ' + Vector3String( direction ) + ',',
|
|
' "target" : ' + LabelString( getObjectName( node.GetTarget() ) ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
]
|
|
|
|
elif light_type == "point":
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "PointLight",',
|
|
' "color" : ' + str(getHex(light.Color.Get())) + ',',
|
|
' "intensity" : ' + str(light.Intensity.Get()/100.0) + ',',
|
|
' "position" : ' + Vector3String( position ) + ',',
|
|
' "distance" : ' + str(light.FarAttenuationEnd.Get()) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
elif light_type == "spot":
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "SpotLight",',
|
|
' "color" : ' + str(getHex(light.Color.Get())) + ',',
|
|
' "intensity" : ' + str(light.Intensity.Get()/100.0) + ',',
|
|
' "position" : ' + Vector3String( position ) + ',',
|
|
' "distance" : ' + str(light.FarAttenuationEnd.Get()) + ',',
|
|
' "angle" : ' + str((light.OuterAngle.Get()*math.pi)/180) + ',',
|
|
' "exponent" : ' + str(light.DecayType.Get()) + ',',
|
|
' "target" : ' + LabelString( getObjectName( node.GetTarget() ) ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
def generate_ambient_light_string(scene):
|
|
|
|
scene_settings = scene.GetGlobalSettings()
|
|
ambient_color = scene_settings.GetAmbientColor()
|
|
ambient_color = (ambient_color.mRed, ambient_color.mGreen, ambient_color.mBlue)
|
|
|
|
if ambient_color[0] == 0 and ambient_color[1] == 0 and ambient_color[2] == 0:
|
|
return None
|
|
|
|
class AmbientLight:
|
|
def GetName(self):
|
|
return "AmbientLight"
|
|
|
|
node = AmbientLight()
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "AmbientLight",',
|
|
' "color" : ' + str(getHex(ambient_color)),
|
|
'}'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', 0 )
|
|
|
|
# #####################################################
|
|
# Generate - Camera Object
|
|
# #####################################################
|
|
def generate_default_camera_string(padding):
|
|
position = (100, 100, 100)
|
|
near = 0.1
|
|
far = 1000
|
|
fov = 75
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( 'default_camera' ) + ' : {',
|
|
' "type" : "PerspectiveCamera",',
|
|
' "fov" : ' + str(fov) + ',',
|
|
' "near" : ' + str(near) + ',',
|
|
' "far" : ' + str(far) + ',',
|
|
' "position" : ' + Vector3String( position ),
|
|
' }'
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
def generate_camera_string(node, padding):
|
|
camera = node.GetNodeAttribute()
|
|
|
|
target_node = node.GetTarget()
|
|
target = ""
|
|
if target_node:
|
|
transform = target.EvaluateLocalTransform()
|
|
target = transform.GetT()
|
|
else:
|
|
target = camera.InterestPosition.Get()
|
|
|
|
position = camera.Position.Get()
|
|
|
|
projection_types = [ "perspective", "orthogonal" ]
|
|
projection = projection_types[camera.ProjectionType.Get()]
|
|
|
|
near = camera.NearPlane.Get()
|
|
far = camera.FarPlane.Get()
|
|
|
|
output = []
|
|
|
|
if projection == "perspective":
|
|
|
|
aspect = camera.PixelAspectRatio.Get()
|
|
fov = camera.FieldOfView.Get()
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "PerspectiveCamera",',
|
|
' "fov" : ' + str(fov) + ',',
|
|
' "aspect" : ' + str(aspect) + ',',
|
|
' "near" : ' + str(near) + ',',
|
|
' "far" : ' + str(far) + ',',
|
|
' "position" : ' + Vector3String( position ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
elif projection == "orthogonal":
|
|
|
|
left = ""
|
|
right = ""
|
|
top = ""
|
|
bottom = ""
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "type" : "OrthographicCamera",',
|
|
' "left" : ' + left + ',',
|
|
' "right" : ' + right + ',',
|
|
' "top" : ' + top + ',',
|
|
' "bottom" : ' + bottom + ',',
|
|
' "near" : ' + str(near) + ',',
|
|
' "far" : ' + str(far) + ',',
|
|
' "position" : ' + Vector3String( position ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
# #####################################################
|
|
# Generate - Mesh Object
|
|
# #####################################################
|
|
def generate_mesh_object_string(node, padding):
|
|
mesh = node.GetNodeAttribute()
|
|
transform = node.EvaluateLocalTransform()
|
|
position = transform.GetT()
|
|
scale = transform.GetS()
|
|
rotation = getRadians(transform.GetR())
|
|
|
|
material_count = node.GetMaterialCount()
|
|
material_name = ""
|
|
|
|
if material_count > 0:
|
|
material_names = []
|
|
for l in range(mesh.GetLayerCount()):
|
|
materials = mesh.GetLayer(l).GetMaterials()
|
|
if materials:
|
|
if materials.GetReferenceMode() == FbxLayerElement.eIndex:
|
|
#Materials are in an undefined external table
|
|
continue
|
|
for i in range(material_count):
|
|
material = node.GetMaterial(i)
|
|
material_names.append( getMaterialName(material) )
|
|
#If this mesh has more than one material, use a proxy material
|
|
material_name = getMaterialName( node, True) if material_count > 1 else material_names[0]
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "geometry" : ' + LabelString( getGeometryName( node, True ) ) + ',',
|
|
' "material" : ' + LabelString( material_name ) + ',',
|
|
' "position" : ' + Vector3String( position ) + ',',
|
|
' "rotation" : ' + Vector3String( rotation ) + ',',
|
|
' "scale" : ' + Vector3String( scale ) + ',',
|
|
' "visible" : ' + getObjectVisible( node ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
# #####################################################
|
|
# Generate - Object
|
|
# #####################################################
|
|
def generate_object_string(node, padding):
|
|
node_types = ["Unknown", "Null", "Marker", "Skeleton", "Mesh", "Nurbs", "Patch", "Camera",
|
|
"CameraStereo", "CameraSwitcher", "Light", "OpticalReference", "OpticalMarker", "NurbsCurve",
|
|
"TrimNurbsSurface", "Boundary", "NurbsSurface", "Shape", "LODGroup", "SubDiv", "CachedEffect", "Line"]
|
|
|
|
transform = node.EvaluateLocalTransform()
|
|
position = transform.GetT()
|
|
scale = transform.GetS()
|
|
rotation = getRadians(transform.GetR())
|
|
|
|
node_type = ""
|
|
if node.GetNodeAttribute() == None:
|
|
node_type = "Null"
|
|
else:
|
|
node_type = node_types[node.GetNodeAttribute().GetAttributeType()]
|
|
|
|
output = [
|
|
|
|
'\t\t' + LabelString( getObjectName( node ) ) + ' : {',
|
|
' "fbx_type" : ' + LabelString( node_type ) + ',',
|
|
' "position" : ' + Vector3String( position ) + ',',
|
|
' "rotation" : ' + Vector3String( rotation ) + ',',
|
|
' "scale" : ' + Vector3String( scale ) + ',',
|
|
' "visible" : ' + getObjectVisible( node ) + ( ',' if node.GetChildCount() > 0 else '' )
|
|
|
|
]
|
|
|
|
return generateMultiLineString( output, '\n\t\t', padding )
|
|
|
|
# #####################################################
|
|
# Parse - Objects
|
|
# #####################################################
|
|
def generate_object_hierarchy(node, object_list, pad, siblings_left):
|
|
object_count = 0
|
|
if node.GetNodeAttribute() == None:
|
|
object_string = generate_object_string(node, pad)
|
|
object_list.append(object_string)
|
|
object_count += 1
|
|
else:
|
|
attribute_type = (node.GetNodeAttribute().GetAttributeType())
|
|
if attribute_type == FbxNodeAttribute.eMesh:
|
|
object_string = generate_mesh_object_string(node, pad)
|
|
object_list.append(object_string)
|
|
object_count += 1
|
|
elif attribute_type == FbxNodeAttribute.eLight:
|
|
object_string = generate_light_string(node, pad)
|
|
object_list.append(object_string)
|
|
object_count += 1
|
|
elif attribute_type == FbxNodeAttribute.eCamera:
|
|
object_string = generate_camera_string(node, pad)
|
|
object_list.append(object_string)
|
|
object_count += 1
|
|
else:
|
|
object_string = generate_object_string(node, pad)
|
|
object_list.append(object_string)
|
|
object_count += 1
|
|
|
|
if node.GetChildCount() > 0:
|
|
object_list.append( PaddingString( pad + 1 ) + '\t\t"children" : {\n' )
|
|
|
|
for i in range(node.GetChildCount()):
|
|
object_count += generate_object_hierarchy(node.GetChild(i), object_list, pad + 2, node.GetChildCount() - i - 1)
|
|
|
|
object_list.append( PaddingString( pad + 1 ) + '\t\t}' )
|
|
object_list.append( PaddingString( pad ) + '\t\t}' + (',\n' if siblings_left > 0 else ''))
|
|
|
|
return object_count
|
|
|
|
def generate_scene_objects_string(scene):
|
|
object_count = 0
|
|
object_list = []
|
|
|
|
ambient_light = generate_ambient_light_string(scene)
|
|
if ambient_light:
|
|
if scene.GetNodeCount() > 0 or option_default_light or option_default_camera:
|
|
ambient_light += (',\n')
|
|
object_list.append(ambient_light)
|
|
object_count += 1
|
|
|
|
if option_default_light:
|
|
default_light = generate_default_light_string(0)
|
|
if scene.GetNodeCount() > 0 or option_default_camera:
|
|
default_light += (',\n')
|
|
object_list.append(default_light)
|
|
object_count += 1
|
|
|
|
if option_default_camera:
|
|
default_camera = generate_default_camera_string(0)
|
|
if scene.GetNodeCount() > 0:
|
|
default_camera += (',\n')
|
|
object_list.append(default_camera)
|
|
object_count += 1
|
|
|
|
node = scene.GetRootNode()
|
|
if node:
|
|
for i in range(node.GetChildCount()):
|
|
object_count += generate_object_hierarchy(node.GetChild(i), object_list, 0, node.GetChildCount() - i - 1)
|
|
|
|
return "\n".join(object_list), object_count
|
|
|
|
# #####################################################
|
|
# Parse - Geometry (non-scene output)
|
|
# #####################################################
|
|
def extract_geometry(scene, filename):
|
|
mesh_string = generate_mesh_string_for_non_scene_output(scene)
|
|
return mesh_string
|
|
|
|
# #####################################################
|
|
# Parse - Scene (scene output)
|
|
# #####################################################
|
|
def extract_scene(scene, filename):
|
|
global_settings = scene.GetGlobalSettings()
|
|
objects, nobjects = generate_scene_objects_string(scene)
|
|
|
|
textures = generate_texture_list(scene)
|
|
materials = generate_material_list(scene)
|
|
geometries = generate_geometry_list(scene)
|
|
embeds = generate_embed_list(scene)
|
|
fogs = []
|
|
|
|
ntextures = len(textures)
|
|
nmaterials = len(materials)
|
|
ngeometries = len(geometries)
|
|
|
|
#TODO: extract actual root/scene data here
|
|
position = Vector3String( (0,0,0) )
|
|
rotation = Vector3String( (0,0,0) )
|
|
scale = Vector3String( (1,1,1) )
|
|
|
|
camera_names = generate_camera_name_list(scene)
|
|
scene_settings = scene.GetGlobalSettings()
|
|
|
|
#TODO: this might exist as part of the FBX spec
|
|
bgcolor = Vector3String( (0.667,0.667,0.667) )
|
|
bgalpha = 1
|
|
|
|
# This does not seem to be any help here
|
|
# global_settings.GetDefaultCamera()
|
|
|
|
defcamera = LabelString(camera_names[0] if len(camera_names) > 0 else "")
|
|
if option_default_camera:
|
|
defcamera = LabelString('default_camera')
|
|
|
|
#TODO: extract fog info from scene
|
|
deffog = LabelString("")
|
|
|
|
geometries = generateMultiLineString( geometries, ",\n\n\t", 0 )
|
|
materials = generateMultiLineString( materials, ",\n\n\t", 0 )
|
|
textures = generateMultiLineString( textures, ",\n\n\t", 0 )
|
|
embeds = generateMultiLineString( embeds, ",\n\n\t", 0 )
|
|
fogs = generateMultiLineString( fogs, ",\n\n\t", 0 )
|
|
|
|
output = [
|
|
|
|
'{',
|
|
' "metadata": {',
|
|
' "formatVersion" : 3.2,',
|
|
' "type" : "scene",',
|
|
' "generatedBy" : "convert-to-threejs.py",',
|
|
' "objects" : ' + str(nobjects) + ',',
|
|
' "geometries" : ' + str(ngeometries) + ',',
|
|
' "materials" : ' + str(nmaterials) + ',',
|
|
' "textures" : ' + str(ntextures),
|
|
' },',
|
|
|
|
'',
|
|
' "urlBaseType": "relativeToScene",',
|
|
'',
|
|
|
|
' "objects" :',
|
|
' {',
|
|
objects,
|
|
' },',
|
|
'',
|
|
|
|
' "geometries" :',
|
|
' {',
|
|
'\t' + geometries,
|
|
' },',
|
|
'',
|
|
|
|
' "materials" :',
|
|
' {',
|
|
'\t' + materials,
|
|
' },',
|
|
'',
|
|
|
|
' "textures" :',
|
|
' {',
|
|
'\t' + textures,
|
|
' },',
|
|
'',
|
|
|
|
' "embeds" :',
|
|
' {',
|
|
'\t' + embeds,
|
|
' },',
|
|
'',
|
|
|
|
' "fogs" :',
|
|
' {',
|
|
'\t' + fogs,
|
|
' },',
|
|
'',
|
|
|
|
' "transform" :',
|
|
' {',
|
|
' "position" : ' + position + ',',
|
|
' "rotation" : ' + rotation + ',',
|
|
' "scale" : ' + scale,
|
|
' },',
|
|
'',
|
|
|
|
' "defaults" :',
|
|
' {',
|
|
' "bgcolor" : ' + str(bgcolor) + ',',
|
|
' "bgalpha" : ' + str(bgalpha) + ',',
|
|
' "camera" : ' + defcamera + ',',
|
|
' "fog" : ' + deffog,
|
|
' }',
|
|
'}'
|
|
|
|
]
|
|
|
|
return "\n".join(output)
|
|
|
|
# #####################################################
|
|
# file helpers
|
|
# #####################################################
|
|
def write_file(fname, content):
|
|
out = open(fname, "w")
|
|
out.write(content)
|
|
out.close()
|
|
|
|
# #####################################################
|
|
# main
|
|
# #####################################################
|
|
if __name__ == "__main__":
|
|
from optparse import OptionParser
|
|
|
|
try:
|
|
from FbxCommon import *
|
|
except ImportError:
|
|
import platform
|
|
msg = 'Could not locate the python FBX SDK!\n'
|
|
msg += 'You need to copy the FBX SDK into your python install folder such as '
|
|
if platform.system() == 'Windows' or platform.system() == 'Microsoft':
|
|
msg += '"Python26/Lib/site-packages"'
|
|
elif platform.system() == 'Linux':
|
|
msg += '"/usr/local/lib/python2.6/site-packages"'
|
|
elif platform.system() == 'Darwin':
|
|
msg += '"/Library/Frameworks/Python.framework/Versions/2.6/lib/python2.6/site-packages"'
|
|
msg += ' folder.'
|
|
print(msg)
|
|
sys.exit(1)
|
|
|
|
usage = "Usage: %prog [source_file.fbx] [output_file.js] [options]"
|
|
parser = OptionParser(usage=usage)
|
|
|
|
parser.add_option('-t', '--triangulate', action='store_true', dest='triangulate', help="force quad geometry into triangles", default=False)
|
|
parser.add_option('-x', '--no-textures', action='store_true', dest='notextures', help="don't include texture references in output file", default=False)
|
|
parser.add_option('-p', '--prefix', action='store_true', dest='prefix', help="prefix object names in output file", default=False)
|
|
parser.add_option('-g', '--geometry-only', action='store_true', dest='geometry', help="output geometry only", default=False)
|
|
parser.add_option('-c', '--default-camera', action='store_true', dest='defcamera', help="include default camera in output scene", default=False)
|
|
parser.add_option('-l', '--defualt-light', action='store_true', dest='deflight', help="include default light in output scene", default=False)
|
|
|
|
(options, args) = parser.parse_args()
|
|
|
|
option_triangulate = options.triangulate
|
|
option_textures = True if not options.notextures else False
|
|
option_prefix = options.prefix
|
|
option_geometry = options.geometry
|
|
option_default_camera = options.defcamera
|
|
option_default_light = options.deflight
|
|
|
|
# Prepare the FBX SDK.
|
|
sdk_manager, scene = InitializeSdkObjects()
|
|
converter = FbxGeometryConverter(sdk_manager)
|
|
global_up_vector = get_up_vector(scene)
|
|
|
|
# The converter takes an FBX file as an argument.
|
|
if len(args) > 1:
|
|
print("\nLoading file: %s" % args[0])
|
|
result = LoadScene(sdk_manager, scene, args[0])
|
|
else:
|
|
result = False
|
|
print("\nUsage: convert_fbx_to_threejs [source_file.fbx] [output_file.js]\n")
|
|
|
|
if not result:
|
|
print("\nAn error occurred while loading the file...")
|
|
else:
|
|
if option_triangulate:
|
|
print("\nForcing geometry to triangles")
|
|
triangulate_scene(scene)
|
|
|
|
if option_geometry:
|
|
output_content = extract_geometry(scene, os.path.basename(args[0]))
|
|
else:
|
|
output_content = extract_scene(scene, os.path.basename(args[0]))
|
|
|
|
output_path = os.path.join(os.getcwd(), args[1])
|
|
write_file(output_path, output_content)
|
|
|
|
print("\nExported Three.js file to:\n%s\n" % output_path)
|
|
|
|
# Destroy all objects created by the FBX SDK.
|
|
sdk_manager.Destroy()
|
|
sys.exit(0)
|