diff --git a/io_anim_bvh/__init__.py b/io_anim_bvh/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a5c57d9b66ed6bbde70f50d9bae6f42aabe3038f
--- /dev/null
+++ b/io_anim_bvh/__init__.py
@@ -0,0 +1,133 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "BioVision Motion Capture (BVH) format",
+ "author": "Campbell Barton",
+ "location": "File > Import-Export",
+ "description": "Import-Export BVH from armature objects",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/MotionCapture_BVH",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "import_bvh" in locals():
+ imp.reload(import_bvh)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ImportHelper, ExportHelper
+
+
+class ImportBVH(bpy.types.Operator, ImportHelper):
+ '''Load a BVH motion capture file'''
+ bl_idname = "import_anim.bvh"
+ bl_label = "Import BVH"
+
+ filename_ext = ".bvh"
+ filter_glob = StringProperty(default="*.bvh", options={'HIDDEN'})
+
+ target = EnumProperty(items=(
+ ('ARMATURE', "Armature", ""),
+ ('OBJECT', "Object", ""),
+ ),
+ name="Target",
+ description="Import target type.",
+ default='ARMATURE')
+
+ global_scale = FloatProperty(name="Scale", description="Scale the BVH by this value", min=0.0001, max=1000000.0, soft_min=0.001, soft_max=100.0, default=1.0)
+ frame_start = IntProperty(name="Start Frame", description="Starting frame for the animation", default=1)
+ use_cyclic = BoolProperty(name="Loop", description="Loop the animation playback", default=False)
+ rotate_mode = EnumProperty(items=(
+ ('QUATERNION', "Quaternion", "Convert rotations to quaternions"),
+ ('NATIVE', "Euler (Native)", "Use the rotation order defined in the BVH file"),
+ ('XYZ', "Euler (XYZ)", "Convert rotations to euler XYZ"),
+ ('XZY', "Euler (XZY)", "Convert rotations to euler XZY"),
+ ('YXZ', "Euler (YXZ)", "Convert rotations to euler YXZ"),
+ ('YZX', "Euler (YZX)", "Convert rotations to euler YZX"),
+ ('ZXY', "Euler (ZXY)", "Convert rotations to euler ZXY"),
+ ('ZYX', "Euler (ZYX)", "Convert rotations to euler ZYX"),
+ ),
+ name="Rotation",
+ description="Rotation conversion.",
+ default='NATIVE')
+
+ def execute(self, context):
+ from . import import_bvh
+ return import_bvh.load(self, context, **self.as_keywords(ignore=("filter_glob",)))
+
+
+class ExportBVH(bpy.types.Operator, ExportHelper):
+ '''Save a BVH motion capture file from an armature'''
+ bl_idname = "export_anim.bvh"
+ bl_label = "Export BVH"
+
+ filename_ext = ".bvh"
+ filter_glob = StringProperty(default="*.bvh", options={'HIDDEN'})
+
+ global_scale = FloatProperty(name="Scale", description="Scale the BVH by this value", min=0.0001, max=1000000.0, soft_min=0.001, soft_max=100.0, default=1.0)
+ frame_start = IntProperty(name="Start Frame", description="Starting frame to export", default=0)
+ frame_end = IntProperty(name="End Frame", description="End frame to export", default=0)
+
+ @classmethod
+ def poll(cls, context):
+ obj = context.object
+ return obj and obj.type == 'ARMATURE'
+
+ def invoke(self, context, event):
+ self.frame_start = context.scene.frame_start
+ self.frame_end = context.scene.frame_end
+
+ return super().invoke(context, event)
+
+ def execute(self, context):
+ if self.frame_start == 0 and self.frame_end == 0:
+ self.frame_start = context.scene.frame_start
+ self.frame_end = context.scene.frame_end
+
+ from . import export_bvh
+ return export_bvh.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob")))
+
+
+def menu_func_import(self, context):
+ self.layout.operator(ImportBVH.bl_idname, text="Motion Capture (.bvh)")
+
+
+def menu_func_export(self, context):
+ self.layout.operator(ExportBVH.bl_idname, text="Motion Capture (.bvh)")
+
+
+def register():
+ bpy.types.INFO_MT_file_import.append(menu_func_import)
+ bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_import.remove(menu_func_import)
+ bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+if __name__ == "__main__":
+ register()
diff --git a/io_anim_bvh/export_bvh.py b/io_anim_bvh/export_bvh.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc7b4207c7320a75a946043f3a9e787256de30d8
--- /dev/null
+++ b/io_anim_bvh/export_bvh.py
@@ -0,0 +1,245 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Campbell Barton
+# fixes from Andrea Rugliancich
+
+import bpy
+
+
+def write_armature(context, filepath, frame_start, frame_end, global_scale=1.0):
+
+ from mathutils import Matrix, Vector, Euler
+ from math import degrees
+
+ file = open(filepath, "w")
+
+ obj = context.object
+ arm = obj.data
+
+ # Build a dictionary of children.
+ # None for parentless
+ children = {None: []}
+
+ # initialize with blank lists
+ for bone in arm.bones:
+ children[bone.name] = []
+
+ for bone in arm.bones:
+ children[getattr(bone.parent, "name", None)].append(bone.name)
+
+ # sort the children
+ for children_list in children.values():
+ children_list.sort()
+
+ # bone name list in the order that the bones are written
+ serialized_names = []
+
+ node_locations = {}
+
+ file.write("HIERARCHY\n")
+
+ def write_recursive_nodes(bone_name, indent):
+ my_children = children[bone_name]
+
+ indent_str = "\t" * indent
+
+ bone = arm.bones[bone_name]
+ loc = bone.head_local
+ node_locations[bone_name] = loc
+
+ # make relative if we can
+ if bone.parent:
+ loc = loc - node_locations[bone.parent.name]
+
+ if indent:
+ file.write("%sJOINT %s\n" % (indent_str, bone_name))
+ else:
+ file.write("%sROOT %s\n" % (indent_str, bone_name))
+
+ file.write("%s{\n" % indent_str)
+ file.write("%s\tOFFSET %.6f %.6f %.6f\n" % (indent_str, loc.x * global_scale, loc.y * global_scale, loc.z * global_scale))
+ if bone.use_connect and bone.parent:
+ file.write("%s\tCHANNELS 3 Xrotation Yrotation Zrotation\n" % indent_str)
+ else:
+ file.write("%s\tCHANNELS 6 Xposition Yposition Zposition Xrotation Yrotation Zrotation\n" % indent_str)
+
+ if my_children:
+ # store the location for the children
+ # to het their relative offset
+
+ # Write children
+ for child_bone in my_children:
+ serialized_names.append(child_bone)
+ write_recursive_nodes(child_bone, indent + 1)
+
+ else:
+ # Write the bone end.
+ file.write("%s\tEnd Site\n" % indent_str)
+ file.write("%s\t{\n" % indent_str)
+ loc = bone.tail_local - node_locations[bone_name]
+ file.write("%s\t\tOFFSET %.6f %.6f %.6f\n" % (indent_str, loc.x * global_scale, loc.y * global_scale, loc.z * global_scale))
+ file.write("%s\t}\n" % indent_str)
+
+ file.write("%s}\n" % indent_str)
+
+ if len(children[None]) == 1:
+ key = children[None][0]
+ serialized_names.append(key)
+ indent = 0
+
+ write_recursive_nodes(key, indent)
+
+ else:
+ # Write a dummy parent node
+ file.write("ROOT %s\n" % key)
+ file.write("{\n")
+ file.write("\tOFFSET 0.0 0.0 0.0\n")
+ file.write("\tCHANNELS 0\n") # Xposition Yposition Zposition Xrotation Yrotation Zrotation
+ key = None
+ indent = 1
+
+ write_recursive_nodes(key, indent)
+
+ file.write("}\n")
+
+ # redefine bones as sorted by serialized_names
+ # so we can write motion
+
+ class decorated_bone(object):
+ __slots__ = (\
+ "name", # bone name, used as key in many places
+ "parent", # decorated bone parent, set in a later loop
+ "rest_bone", # blender armature bone
+ "pose_bone", # blender pose bone
+ "pose_mat", # blender pose matrix
+ "rest_arm_mat", # blender rest matrix (armature space)
+ "rest_local_mat", # blender rest batrix (local space)
+ "pose_imat", # pose_mat inverted
+ "rest_arm_imat", # rest_arm_mat inverted
+ "rest_local_imat", # rest_local_mat inverted
+ "prev_euler", # last used euler to preserve euler compability in between keyframes
+ "connected", # is the bone connected to the parent bone?
+ )
+
+ def __init__(self, bone_name):
+ self.name = bone_name
+ self.rest_bone = arm.bones[bone_name]
+ self.pose_bone = obj.pose.bones[bone_name]
+
+ self.pose_mat = self.pose_bone.matrix
+
+ mat = self.rest_bone.matrix
+ self.rest_arm_mat = self.rest_bone.matrix_local
+ self.rest_local_mat = self.rest_bone.matrix
+
+ # inverted mats
+ self.pose_imat = self.pose_mat.copy().invert()
+ self.rest_arm_imat = self.rest_arm_mat.copy().invert()
+ self.rest_local_imat = self.rest_local_mat.copy().invert()
+
+ self.parent = None
+ self.prev_euler = Euler((0.0, 0.0, 0.0))
+ self.connected = (self.rest_bone.use_connect and self.rest_bone.parent)
+
+ def update_posedata(self):
+ self.pose_mat = self.pose_bone.matrix
+ self.pose_imat = self.pose_mat.copy().invert()
+
+ def __repr__(self):
+ if self.parent:
+ return "[\"%s\" child on \"%s\"]\n" % (self.name, self.parent.name)
+ else:
+ return "[\"%s\" root bone]\n" % (self.name)
+
+ bones_decorated = [decorated_bone(bone_name) for bone_name in serialized_names]
+
+ # Assign parents
+ bones_decorated_dict = {}
+ for dbone in bones_decorated:
+ bones_decorated_dict[dbone.name] = dbone
+
+ for dbone in bones_decorated:
+ parent = dbone.rest_bone.parent
+ if parent:
+ dbone.parent = bones_decorated_dict[parent.name]
+ del bones_decorated_dict
+ # finish assigning parents
+
+ scene = bpy.context.scene
+
+ file.write("MOTION\n")
+ file.write("Frames: %d\n" % (frame_end - frame_start + 1))
+ file.write("Frame Time: %.6f\n" % (1.0 / (scene.render.fps / scene.render.fps_base)))
+
+ for frame in range(frame_start, frame_end + 1):
+ scene.frame_set(frame)
+
+ for dbone in bones_decorated:
+ dbone.update_posedata()
+
+ for dbone in bones_decorated:
+ trans = Matrix.Translation(dbone.rest_bone.head_local)
+ itrans = Matrix.Translation(-dbone.rest_bone.head_local)
+
+ if dbone.parent:
+ mat_final = dbone.parent.rest_arm_mat * dbone.parent.pose_imat * dbone.pose_mat * dbone.rest_arm_imat
+ mat_final = itrans * mat_final * trans
+ loc = mat_final.translation_part() + (dbone.rest_bone.head_local - dbone.parent.rest_bone.head_local)
+ else:
+ mat_final = dbone.pose_mat * dbone.rest_arm_imat
+ mat_final = itrans * mat_final * trans
+ loc = mat_final.translation_part() + dbone.rest_bone.head
+
+ # keep eulers compatible, no jumping on interpolation.
+ rot = mat_final.rotation_part().invert().to_euler('XYZ', dbone.prev_euler)
+
+ if not dbone.connected:
+ file.write("%.6f %.6f %.6f " % (loc * global_scale)[:])
+
+ file.write("%.6f %.6f %.6f " % (-degrees(rot[0]), -degrees(rot[1]), -degrees(rot[2])))
+
+ dbone.prev_euler = rot
+
+ file.write("\n")
+
+ file.close()
+
+ print("BVH Exported: %s frames:%d\n" % (filepath, frame_end - frame_start + 1))
+
+
+def save(operator, context, filepath="",
+ frame_start=-1,
+ frame_end=-1,
+ global_scale=1.0,
+ ):
+
+ write_armature(context, filepath,
+ frame_start=frame_start,
+ frame_end=frame_end,
+ global_scale=global_scale,
+ )
+
+ return {'FINISHED'}
+
+
+if __name__ == "__main__":
+ scene = bpy.context.scene
+ _read(bpy.data.filepath.rstrip(".blend") + ".bvh", bpy.context.object, scene.frame_start, scene.frame_end, 1.0)
diff --git a/io_anim_bvh/import_bvh.py b/io_anim_bvh/import_bvh.py
new file mode 100644
index 0000000000000000000000000000000000000000..5a0c0fcfd452dd4499f61dc4cfb6bc223924acb3
--- /dev/null
+++ b/io_anim_bvh/import_bvh.py
@@ -0,0 +1,550 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Campbell Barton
+
+import math
+from math import radians
+
+import bpy
+import mathutils
+from mathutils import Vector, Euler, Matrix
+
+
+class bvh_node_class(object):
+ __slots__ = (
+ 'name', # bvh joint name
+ 'parent', # bvh_node_class type or None for no parent
+ 'children', # a list of children of this type.
+ 'rest_head_world', # worldspace rest location for the head of this node
+ 'rest_head_local', # localspace rest location for the head of this node
+ 'rest_tail_world', # worldspace rest location for the tail of this node
+ 'rest_tail_local', # worldspace rest location for the tail of this node
+ 'channels', # list of 6 ints, -1 for an unused channel, otherwise an index for the BVH motion data lines, lock triple then rot triple
+ 'rot_order', # a triple of indicies as to the order rotation is applied. [0,1,2] is x/y/z - [None, None, None] if no rotation.
+ 'rot_order_str', # same as above but a string 'XYZ' format.
+ 'anim_data', # a list one tuple's one for each frame. (locx, locy, locz, rotx, roty, rotz), euler rotation ALWAYS stored xyz order, even when native used.
+ 'has_loc', # Conveinience function, bool, same as (channels[0]!=-1 or channels[1]!=-1 channels[2]!=-1)
+ 'has_rot', # Conveinience function, bool, same as (channels[3]!=-1 or channels[4]!=-1 channels[5]!=-1)
+ 'temp') # use this for whatever you want
+
+ _eul_order_lookup = {\
+ (0, 1, 2): 'XYZ',
+ (0, 2, 1): 'XZY',
+ (1, 0, 2): 'YXZ',
+ (1, 2, 0): 'YZX',
+ (2, 0, 1): 'ZXY',
+ (2, 1, 0): 'ZYX'}
+
+ def __init__(self, name, rest_head_world, rest_head_local, parent, channels, rot_order):
+ self.name = name
+ self.rest_head_world = rest_head_world
+ self.rest_head_local = rest_head_local
+ self.rest_tail_world = None
+ self.rest_tail_local = None
+ self.parent = parent
+ self.channels = channels
+ self.rot_order = tuple(rot_order)
+ self.rot_order_str = __class__._eul_order_lookup[self.rot_order]
+
+ # convenience functions
+ self.has_loc = channels[0] != -1 or channels[1] != -1 or channels[2] != -1
+ self.has_rot = channels[3] != -1 or channels[4] != -1 or channels[5] != -1
+
+ self.children = []
+
+ # list of 6 length tuples: (lx,ly,lz, rx,ry,rz)
+ # even if the channels arnt used they will just be zero
+ #
+ self.anim_data = [(0, 0, 0, 0, 0, 0)]
+
+ def __repr__(self):
+ return 'BVH name:"%s", rest_loc:(%.3f,%.3f,%.3f), rest_tail:(%.3f,%.3f,%.3f)' %\
+ (self.name,\
+ self.rest_head_world.x, self.rest_head_world.y, self.rest_head_world.z,\
+ self.rest_head_world.x, self.rest_head_world.y, self.rest_head_world.z)
+
+
+def read_bvh(context, file_path, rotate_mode='XYZ', global_scale=1.0):
+ # File loading stuff
+ # Open the file for importing
+ file = open(file_path, 'rU')
+
+ # Seperate into a list of lists, each line a list of words.
+ file_lines = file.readlines()
+ # Non standard carrage returns?
+ if len(file_lines) == 1:
+ file_lines = file_lines[0].split('\r')
+
+ # Split by whitespace.
+ file_lines = [ll for ll in [l.split() for l in file_lines] if ll]
+
+ # Create Hirachy as empties
+ if file_lines[0][0].lower() == 'hierarchy':
+ #print 'Importing the BVH Hierarchy for:', file_path
+ pass
+ else:
+ raise 'ERROR: This is not a BVH file'
+
+ bvh_nodes = {None: None}
+ bvh_nodes_serial = [None]
+
+ channelIndex = -1
+
+ lineIdx = 0 # An index for the file.
+ while lineIdx < len(file_lines) - 1:
+ #...
+ if file_lines[lineIdx][0].lower() == 'root' or file_lines[lineIdx][0].lower() == 'joint':
+
+ # Join spaces into 1 word with underscores joining it.
+ if len(file_lines[lineIdx]) > 2:
+ file_lines[lineIdx][1] = '_'.join(file_lines[lineIdx][1:])
+ file_lines[lineIdx] = file_lines[lineIdx][:2]
+
+ # MAY NEED TO SUPPORT MULTIPLE ROOT's HERE!!!, Still unsure weather multiple roots are possible.??
+
+ # Make sure the names are unique- Object names will match joint names exactly and both will be unique.
+ name = file_lines[lineIdx][1]
+
+ #print '%snode: %s, parent: %s' % (len(bvh_nodes_serial) * ' ', name, bvh_nodes_serial[-1])
+
+ lineIdx += 2 # Increment to the next line (Offset)
+ rest_head_local = Vector((float(file_lines[lineIdx][1]), float(file_lines[lineIdx][2]), float(file_lines[lineIdx][3]))) * global_scale
+ lineIdx += 1 # Increment to the next line (Channels)
+
+ # newChannel[Xposition, Yposition, Zposition, Xrotation, Yrotation, Zrotation]
+ # newChannel references indecies to the motiondata,
+ # if not assigned then -1 refers to the last value that will be added on loading at a value of zero, this is appended
+ # We'll add a zero value onto the end of the MotionDATA so this is always refers to a value.
+ my_channel = [-1, -1, -1, -1, -1, -1]
+ my_rot_order = [None, None, None]
+ rot_count = 0
+ for channel in file_lines[lineIdx][2:]:
+ channel = channel.lower()
+ channelIndex += 1 # So the index points to the right channel
+ if channel == 'xposition':
+ my_channel[0] = channelIndex
+ elif channel == 'yposition':
+ my_channel[1] = channelIndex
+ elif channel == 'zposition':
+ my_channel[2] = channelIndex
+
+ elif channel == 'xrotation':
+ my_channel[3] = channelIndex
+ my_rot_order[rot_count] = 0
+ rot_count += 1
+ elif channel == 'yrotation':
+ my_channel[4] = channelIndex
+ my_rot_order[rot_count] = 1
+ rot_count += 1
+ elif channel == 'zrotation':
+ my_channel[5] = channelIndex
+ my_rot_order[rot_count] = 2
+ rot_count += 1
+
+ channels = file_lines[lineIdx][2:]
+
+ my_parent = bvh_nodes_serial[-1] # account for none
+
+ # Apply the parents offset accumulatively
+ if my_parent is None:
+ rest_head_world = Vector(rest_head_local)
+ else:
+ rest_head_world = my_parent.rest_head_world + rest_head_local
+
+ bvh_node = bvh_nodes[name] = bvh_node_class(name, rest_head_world, rest_head_local, my_parent, my_channel, my_rot_order)
+
+ # If we have another child then we can call ourselves a parent, else
+ bvh_nodes_serial.append(bvh_node)
+
+ # Account for an end node
+ if file_lines[lineIdx][0].lower() == 'end' and file_lines[lineIdx][1].lower() == 'site': # There is sometimes a name after 'End Site' but we will ignore it.
+ lineIdx += 2 # Increment to the next line (Offset)
+ rest_tail = Vector((float(file_lines[lineIdx][1]), float(file_lines[lineIdx][2]), float(file_lines[lineIdx][3]))) * global_scale
+
+ bvh_nodes_serial[-1].rest_tail_world = bvh_nodes_serial[-1].rest_head_world + rest_tail
+ bvh_nodes_serial[-1].rest_tail_local = bvh_nodes_serial[-1].rest_head_local + rest_tail
+
+ # Just so we can remove the Parents in a uniform way- End has kids
+ # so this is a placeholder
+ bvh_nodes_serial.append(None)
+
+ if len(file_lines[lineIdx]) == 1 and file_lines[lineIdx][0] == '}': # == ['}']
+ bvh_nodes_serial.pop() # Remove the last item
+
+ if len(file_lines[lineIdx]) == 1 and file_lines[lineIdx][0].lower() == 'motion':
+ #print '\nImporting motion data'
+ lineIdx += 3 # Set the cursor to the first frame
+ break
+
+ lineIdx += 1
+
+ # Remove the None value used for easy parent reference
+ del bvh_nodes[None]
+ # Dont use anymore
+ del bvh_nodes_serial
+
+ bvh_nodes_list = bvh_nodes.values()
+
+ while lineIdx < len(file_lines):
+ line = file_lines[lineIdx]
+ for bvh_node in bvh_nodes_list:
+ #for bvh_node in bvh_nodes_serial:
+ lx = ly = lz = rx = ry = rz = 0.0
+ channels = bvh_node.channels
+ anim_data = bvh_node.anim_data
+ if channels[0] != -1:
+ lx = global_scale * float(line[channels[0]])
+
+ if channels[1] != -1:
+ ly = global_scale * float(line[channels[1]])
+
+ if channels[2] != -1:
+ lz = global_scale * float(line[channels[2]])
+
+ if channels[3] != -1 or channels[4] != -1 or channels[5] != -1:
+
+ rx = radians(float(line[channels[3]]))
+ ry = radians(float(line[channels[4]]))
+ rz = radians(float(line[channels[5]]))
+
+ # Done importing motion data #
+ anim_data.append((lx, ly, lz, rx, ry, rz))
+ lineIdx += 1
+
+ # Assign children
+ for bvh_node in bvh_nodes.values():
+ bvh_node_parent = bvh_node.parent
+ if bvh_node_parent:
+ bvh_node_parent.children.append(bvh_node)
+
+ # Now set the tip of each bvh_node
+ for bvh_node in bvh_nodes.values():
+
+ if not bvh_node.rest_tail_world:
+ if len(bvh_node.children) == 0:
+ # could just fail here, but rare BVH files have childless nodes
+ bvh_node.rest_tail_world = Vector(bvh_node.rest_head_world)
+ bvh_node.rest_tail_local = Vector(bvh_node.rest_head_local)
+ elif len(bvh_node.children) == 1:
+ bvh_node.rest_tail_world = Vector(bvh_node.children[0].rest_head_world)
+ bvh_node.rest_tail_local = bvh_node.rest_head_local + bvh_node.children[0].rest_head_local
+ else:
+ # allow this, see above
+ #if not bvh_node.children:
+ # raise 'error, bvh node has no end and no children. bad file'
+
+ # Removed temp for now
+ rest_tail_world = Vector((0.0, 0.0, 0.0))
+ rest_tail_local = Vector((0.0, 0.0, 0.0))
+ for bvh_node_child in bvh_node.children:
+ rest_tail_world += bvh_node_child.rest_head_world
+ rest_tail_local += bvh_node_child.rest_head_local
+
+ bvh_node.rest_tail_world = rest_tail_world * (1.0 / len(bvh_node.children))
+ bvh_node.rest_tail_local = rest_tail_local * (1.0 / len(bvh_node.children))
+
+ # Make sure tail isnt the same location as the head.
+ if (bvh_node.rest_tail_local - bvh_node.rest_head_local).length <= 0.001 * global_scale:
+ bvh_node.rest_tail_local.y = bvh_node.rest_tail_local.y + global_scale / 10
+ bvh_node.rest_tail_world.y = bvh_node.rest_tail_world.y + global_scale / 10
+
+ return bvh_nodes
+
+
+def bvh_node_dict2objects(context, bvh_name, bvh_nodes, rotate_mode='NATIVE', frame_start=1, IMPORT_LOOP=False):
+
+ if frame_start < 1:
+ frame_start = 1
+
+ scene = context.scene
+ for obj in scene.objects:
+ obj.select = False
+
+ objects = []
+
+ def add_ob(name):
+ obj = bpy.data.objects.new(name, None)
+ scene.objects.link(obj)
+ objects.append(obj)
+ obj.select = True
+
+ # nicer drawing.
+ obj.empty_draw_type = 'CUBE'
+ obj.empty_draw_size = 0.1
+
+ return obj
+
+ # Add objects
+ for name, bvh_node in bvh_nodes.items():
+ bvh_node.temp = add_ob(name)
+ bvh_node.temp.rotation_mode = bvh_node.rot_order_str[::-1]
+
+ # Parent the objects
+ for bvh_node in bvh_nodes.values():
+ for bvh_node_child in bvh_node.children:
+ bvh_node_child.temp.parent = bvh_node.temp
+
+ # Offset
+ for bvh_node in bvh_nodes.values():
+ # Make relative to parents offset
+ bvh_node.temp.location = bvh_node.rest_head_local
+
+ # Add tail objects
+ for name, bvh_node in bvh_nodes.items():
+ if not bvh_node.children:
+ ob_end = add_ob(name + '_end')
+ ob_end.parent = bvh_node.temp
+ ob_end.location = bvh_node.rest_tail_world - bvh_node.rest_head_world
+
+ for name, bvh_node in bvh_nodes.items():
+ obj = bvh_node.temp
+
+ for frame_current in range(len(bvh_node.anim_data)):
+
+ lx, ly, lz, rx, ry, rz = bvh_node.anim_data[frame_current]
+
+ if bvh_node.has_loc:
+ obj.delta_location = Vector((lx, ly, lz)) - bvh_node.rest_head_world
+ obj.keyframe_insert("delta_location", index=-1, frame=frame_start + frame_current)
+
+ if bvh_node.has_rot:
+ obj.delta_rotation_euler = rx, ry, rz
+ obj.keyframe_insert("delta_rotation_euler", index=-1, frame=frame_start + frame_current)
+
+ return objects
+
+
+def bvh_node_dict2armature(context, bvh_name, bvh_nodes, rotate_mode='XYZ', frame_start=1, IMPORT_LOOP=False):
+
+ if frame_start < 1:
+ frame_start = 1
+
+ # Add the new armature,
+ scene = context.scene
+ for obj in scene.objects:
+ obj.select = False
+
+ arm_data = bpy.data.armatures.new(bvh_name)
+ arm_ob = bpy.data.objects.new(bvh_name, arm_data)
+
+ scene.objects.link(arm_ob)
+
+ arm_ob.select = True
+ scene.objects.active = arm_ob
+
+ bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+ bpy.ops.object.mode_set(mode='EDIT', toggle=False)
+
+ # Get the average bone length for zero length bones, we may not use this.
+ average_bone_length = 0.0
+ nonzero_count = 0
+ for bvh_node in bvh_nodes.values():
+ l = (bvh_node.rest_head_local - bvh_node.rest_tail_local).length
+ if l:
+ average_bone_length += l
+ nonzero_count += 1
+
+ # Very rare cases all bones couldbe zero length???
+ if not average_bone_length:
+ average_bone_length = 0.1
+ else:
+ # Normal operation
+ average_bone_length = average_bone_length / nonzero_count
+
+ # XXX, annoying, remove bone.
+ while arm_data.edit_bones:
+ arm_ob.edit_bones.remove(arm_data.edit_bones[-1])
+
+ ZERO_AREA_BONES = []
+ for name, bvh_node in bvh_nodes.items():
+ # New editbone
+ bone = bvh_node.temp = arm_data.edit_bones.new(name)
+
+ bone.head = bvh_node.rest_head_world
+ bone.tail = bvh_node.rest_tail_world
+
+ # ZERO AREA BONES.
+ if (bone.head - bone.tail).length < 0.001:
+ if bvh_node.parent:
+ ofs = bvh_node.parent.rest_head_local - bvh_node.parent.rest_tail_local
+ if ofs.length: # is our parent zero length also?? unlikely
+ bone.tail = bone.tail + ofs
+ else:
+ bone.tail.y = bone.tail.y + average_bone_length
+ else:
+ bone.tail.y = bone.tail.y + average_bone_length
+
+ ZERO_AREA_BONES.append(bone.name)
+
+ for bvh_node in bvh_nodes.values():
+ if bvh_node.parent:
+ # bvh_node.temp is the Editbone
+
+ # Set the bone parent
+ bvh_node.temp.parent = bvh_node.parent.temp
+
+ # Set the connection state
+ if not bvh_node.has_loc and\
+ bvh_node.parent and\
+ bvh_node.parent.temp.name not in ZERO_AREA_BONES and\
+ bvh_node.parent.rest_tail_local == bvh_node.rest_head_local:
+ bvh_node.temp.use_connect = True
+
+ # Replace the editbone with the editbone name,
+ # to avoid memory errors accessing the editbone outside editmode
+ for bvh_node in bvh_nodes.values():
+ bvh_node.temp = bvh_node.temp.name
+
+ # Now Apply the animation to the armature
+
+ # Get armature animation data
+ bpy.ops.object.mode_set(mode='OBJECT', toggle=False)
+
+ pose = arm_ob.pose
+ pose_bones = pose.bones
+
+ if rotate_mode == 'NATIVE':
+ for bvh_node in bvh_nodes.values():
+ bone_name = bvh_node.temp # may not be the same name as the bvh_node, could have been shortened.
+ pose_bone = pose_bones[bone_name]
+ pose_bone.rotation_mode = bvh_node.rot_order_str
+
+ elif rotate_mode != 'QUATERNION':
+ for pose_bone in pose_bones:
+ pose_bone.rotation_mode = rotate_mode
+ else:
+ # Quats default
+ pass
+
+ context.scene.update()
+
+ arm_ob.animation_data_create()
+ action = bpy.data.actions.new(name=bvh_name)
+ arm_ob.animation_data.action = action
+
+ # Replace the bvh_node.temp (currently an editbone)
+ # With a tuple (pose_bone, armature_bone, bone_rest_matrix, bone_rest_matrix_inv)
+ for bvh_node in bvh_nodes.values():
+ bone_name = bvh_node.temp # may not be the same name as the bvh_node, could have been shortened.
+ pose_bone = pose_bones[bone_name]
+ rest_bone = arm_data.bones[bone_name]
+ bone_rest_matrix = rest_bone.matrix_local.rotation_part()
+
+ bone_rest_matrix_inv = Matrix(bone_rest_matrix)
+ bone_rest_matrix_inv.invert()
+
+ bone_rest_matrix_inv.resize4x4()
+ bone_rest_matrix.resize4x4()
+ bvh_node.temp = (pose_bone, bone, bone_rest_matrix, bone_rest_matrix_inv)
+
+ # Make a dict for fast access without rebuilding a list all the time.
+
+ # KEYFRAME METHOD, SLOW, USE IPOS DIRECT
+ # TODO: use f-point samples instead (Aligorith)
+ if rotate_mode != 'QUATERNION':
+ prev_euler = [Euler() for i in range(len(bvh_nodes))]
+
+ # Animate the data, the last used bvh_node will do since they all have the same number of frames
+ for frame_current in range(len(bvh_node.anim_data) - 1): # skip the first frame (rest frame)
+ # print frame_current
+
+ # if frame_current==40: # debugging
+ # break
+
+ scene.frame_set(frame_start + frame_current)
+
+ # Dont neet to set the current frame
+ for i, bvh_node in enumerate(bvh_nodes.values()):
+ pose_bone, bone, bone_rest_matrix, bone_rest_matrix_inv = bvh_node.temp
+ lx, ly, lz, rx, ry, rz = bvh_node.anim_data[frame_current + 1]
+
+ if bvh_node.has_rot:
+ # apply rotation order and convert to XYZ
+ # note that the rot_order_str is reversed.
+ bone_rotation_matrix = Euler((rx, ry, rz), bvh_node.rot_order_str[::-1]).to_matrix().resize4x4()
+ bone_rotation_matrix = bone_rest_matrix_inv * bone_rotation_matrix * bone_rest_matrix
+
+ if rotate_mode == 'QUATERNION':
+ pose_bone.rotation_quaternion = bone_rotation_matrix.to_quat()
+ else:
+ euler = bone_rotation_matrix.to_euler(bvh_node.rot_order_str, prev_euler[i])
+ pose_bone.rotation_euler = euler
+ prev_euler[i] = euler
+
+ if bvh_node.has_loc:
+ pose_bone.location = (bone_rest_matrix_inv * Matrix.Translation(Vector((lx, ly, lz)) - bvh_node.rest_head_local)).translation_part()
+
+ if bvh_node.has_loc:
+ pose_bone.keyframe_insert("location")
+ if bvh_node.has_rot:
+ if rotate_mode == 'QUATERNION':
+ pose_bone.keyframe_insert("rotation_quaternion")
+ else:
+ pose_bone.keyframe_insert("rotation_euler")
+
+ for cu in action.fcurves:
+ if IMPORT_LOOP:
+ pass # 2.5 doenst have cyclic now?
+
+ for bez in cu.keyframe_points:
+ bez.interpolation = 'LINEAR'
+
+ return arm_ob
+
+
+def load(operator, context, filepath="", target='ARMATURE', rotate_mode='NATIVE', global_scale=1.0, use_cyclic=False, frame_start=1):
+ import time
+ t1 = time.time()
+ print('\tparsing bvh %r...' % filepath, end="")
+
+ bvh_nodes = read_bvh(context, filepath,
+ rotate_mode=rotate_mode,
+ global_scale=global_scale)
+
+ print('%.4f' % (time.time() - t1))
+
+ frame_orig = context.scene.frame_current
+
+ t1 = time.time()
+ print('\timporting to blender...', end="")
+
+ bvh_name = bpy.path.display_name_from_filepath(filepath)
+
+ if target == 'ARMATURE':
+ bvh_node_dict2armature(context, bvh_name, bvh_nodes,
+ rotate_mode=rotate_mode,
+ frame_start=frame_start,
+ IMPORT_LOOP=use_cyclic)
+
+ elif target == 'OBJECT':
+ bvh_node_dict2objects(context, bvh_name, bvh_nodes,
+ rotate_mode=rotate_mode,
+ frame_start=frame_start,
+ IMPORT_LOOP=use_cyclic)
+
+ else:
+ raise Exception("invalid type")
+
+ print('Done in %.4f\n' % (time.time() - t1))
+
+ context.scene.frame_set(frame_orig)
+
+ return {'FINISHED'}
diff --git a/io_mesh_ply/__init__.py b/io_mesh_ply/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..bdac6fa2bab3789562f2d0c3e432fcbdd70f0ffb
--- /dev/null
+++ b/io_mesh_ply/__init__.py
@@ -0,0 +1,112 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "Stanford PLY format",
+ "author": "Bruce Merry, Campbell Barton",
+ "location": "File > Import-Export",
+ "description": "Import-Export PLY mesh data withs UV's and vertex colors",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/Stanford_PLY",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "export_ply" in locals():
+ imp.reload(export_ply)
+ if "import_ply" in locals():
+ imp.reload(import_ply)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ImportHelper, ExportHelper
+
+
+class ImportPLY(bpy.types.Operator, ImportHelper):
+ '''Load a BVH motion capture file'''
+ bl_idname = "import_mesh.ply"
+ bl_label = "Import PLY"
+
+ filename_ext = ".ply"
+ filter_glob = StringProperty(default="*.ply", options={'HIDDEN'})
+
+ def execute(self, context):
+ from . import import_ply
+ return import_ply.load(self, context, **self.as_keywords(ignore=("filter_glob",)))
+
+
+class ExportPLY(bpy.types.Operator, ExportHelper):
+ '''Export a single object as a stanford PLY with normals, colours and texture coordinates.'''
+ bl_idname = "export_mesh.ply"
+ bl_label = "Export PLY"
+
+ filename_ext = ".ply"
+ filter_glob = StringProperty(default="*.ply", options={'HIDDEN'})
+
+ use_modifiers = BoolProperty(name="Apply Modifiers", description="Apply Modifiers to the exported mesh", default=True)
+ use_normals = BoolProperty(name="Normals", description="Export Normals for smooth and hard shaded faces", default=True)
+ use_uv_coords = BoolProperty(name="UVs", description="Exort the active UV layer", default=True)
+ use_colors = BoolProperty(name="Vertex Colors", description="Exort the active vertex color layer", default=True)
+
+ @classmethod
+ def poll(cls, context):
+ return context.active_object != None
+
+ def execute(self, context):
+ filepath = self.filepath
+ filepath = bpy.path.ensure_ext(filepath, self.filename_ext)
+ from . import export_ply
+ return export_ply.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob")))
+
+ def draw(self, context):
+ layout = self.layout
+
+ row = layout.row()
+ row.prop(self, "use_modifiers")
+ row.prop(self, "use_normals")
+ row = layout.row()
+ row.prop(self, "use_uv_coords")
+ row.prop(self, "use_colors")
+
+
+def menu_func_import(self, context):
+ self.layout.operator(ImportPLY.bl_idname, text="Stanford (.ply)")
+
+
+def menu_func_export(self, context):
+ self.layout.operator(ExportPLY.bl_idname, text="Stanford (.ply)")
+
+
+def register():
+ bpy.types.INFO_MT_file_import.append(menu_func_import)
+ bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_import.remove(menu_func_import)
+ bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+if __name__ == "__main__":
+ register()
diff --git a/io_mesh_ply/export_ply.py b/io_mesh_ply/export_ply.py
new file mode 100644
index 0000000000000000000000000000000000000000..271a2d23207a063a3a5cce9e3494562d6dac7296
--- /dev/null
+++ b/io_mesh_ply/export_ply.py
@@ -0,0 +1,203 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Copyright (C) 2004, 2005: Bruce Merry, bmerry@cs.uct.ac.za
+# Contributors: Bruce Merry, Campbell Barton
+
+"""
+This script exports Stanford PLY files from Blender. It supports normals,
+colours, and texture coordinates per face or per vertex.
+Only one mesh can be exported at a time.
+"""
+
+import bpy
+import os
+
+
+def save(operator, context, filepath="", use_modifiers=True, use_normals=True, use_uv_coords=True, use_colors=True):
+
+ def rvec3d(v):
+ return round(v[0], 6), round(v[1], 6), round(v[2], 6)
+
+ def rvec2d(v):
+ return round(v[0], 6), round(v[1], 6)
+
+ scene = context.scene
+ obj = context.object
+
+ if not obj:
+ raise Exception("Error, Select 1 active object")
+
+ file = open(filepath, 'w')
+
+ if scene.objects.active:
+ bpy.ops.object.mode_set(mode='OBJECT')
+
+ if use_modifiers:
+ mesh = obj.create_mesh(scene, True, 'PREVIEW')
+ else:
+ mesh = obj.data
+
+ if not mesh:
+ raise Exception("Error, could not get mesh data from active object")
+
+ # mesh.transform(obj.matrix_world) # XXX
+
+ faceUV = (len(mesh.uv_textures) > 0)
+ vertexUV = (len(mesh.sticky) > 0)
+ vertexColors = len(mesh.vertex_colors) > 0
+
+ if (not faceUV) and (not vertexUV):
+ use_uv_coords = False
+ if not vertexColors:
+ use_colors = False
+
+ if not use_uv_coords:
+ faceUV = vertexUV = False
+ if not use_colors:
+ vertexColors = False
+
+ if faceUV:
+ active_uv_layer = mesh.uv_textures.active
+ if not active_uv_layer:
+ use_uv_coords = False
+ faceUV = None
+ else:
+ active_uv_layer = active_uv_layer.data
+
+ if vertexColors:
+ active_col_layer = mesh.vertex_colors.active
+ if not active_col_layer:
+ use_colors = False
+ vertexColors = None
+ else:
+ active_col_layer = active_col_layer.data
+
+ # incase
+ color = uvcoord = uvcoord_key = normal = normal_key = None
+
+ mesh_verts = mesh.vertices # save a lookup
+ ply_verts = [] # list of dictionaries
+ # vdict = {} # (index, normal, uv) -> new index
+ vdict = [{} for i in range(len(mesh_verts))]
+ ply_faces = [[] for f in range(len(mesh.faces))]
+ vert_count = 0
+ for i, f in enumerate(mesh.faces):
+
+ smooth = f.use_smooth
+ if not smooth:
+ normal = tuple(f.normal)
+ normal_key = rvec3d(normal)
+
+ if faceUV:
+ uv = active_uv_layer[i]
+ uv = uv.uv1, uv.uv2, uv.uv3, uv.uv4 # XXX - crufty :/
+ if vertexColors:
+ col = active_col_layer[i]
+ col = col.color1[:], col.color2[:], col.color3[:], col.color4[:]
+
+ f_verts = f.vertices
+
+ pf = ply_faces[i]
+ for j, vidx in enumerate(f_verts):
+ v = mesh_verts[vidx]
+
+ if smooth:
+ normal = tuple(v.normal)
+ normal_key = rvec3d(normal)
+
+ if faceUV:
+ uvcoord = uv[j][0], 1.0 - uv[j][1]
+ uvcoord_key = rvec2d(uvcoord)
+ elif vertexUV:
+ uvcoord = v.uvco[0], 1.0 - v.uvco[1]
+ uvcoord_key = rvec2d(uvcoord)
+
+ if vertexColors:
+ color = col[j]
+ color = int(color[0] * 255.0), int(color[1] * 255.0), int(color[2] * 255.0)
+
+ key = normal_key, uvcoord_key, color
+
+ vdict_local = vdict[vidx]
+ pf_vidx = vdict_local.get(key) # Will be None initially
+
+ if pf_vidx is None: # same as vdict_local.has_key(key)
+ pf_vidx = vdict_local[key] = vert_count
+ ply_verts.append((vidx, normal, uvcoord, color))
+ vert_count += 1
+
+ pf.append(pf_vidx)
+
+ file.write('ply\n')
+ file.write('format ascii 1.0\n')
+ file.write('comment Created by Blender %s - www.blender.org, source file: %r\n' % (bpy.app.version_string, os.path.basename(bpy.data.filepath)))
+
+ file.write('element vertex %d\n' % len(ply_verts))
+
+ file.write('property float x\n')
+ file.write('property float y\n')
+ file.write('property float z\n')
+
+ if use_normals:
+ file.write('property float nx\n')
+ file.write('property float ny\n')
+ file.write('property float nz\n')
+ if use_uv_coords:
+ file.write('property float s\n')
+ file.write('property float t\n')
+ if use_colors:
+ file.write('property uchar red\n')
+ file.write('property uchar green\n')
+ file.write('property uchar blue\n')
+
+ file.write('element face %d\n' % len(mesh.faces))
+ file.write('property list uchar uint vertex_indices\n')
+ file.write('end_header\n')
+
+ for i, v in enumerate(ply_verts):
+ file.write('%.6f %.6f %.6f ' % mesh_verts[v[0]].co[:]) # co
+ if use_normals:
+ file.write('%.6f %.6f %.6f ' % v[1]) # no
+ if use_uv_coords:
+ file.write('%.6f %.6f ' % v[2]) # uv
+ if use_colors:
+ file.write('%u %u %u' % v[3]) # col
+ file.write('\n')
+
+ for pf in ply_faces:
+ if len(pf) == 3:
+ file.write('3 %d %d %d\n' % tuple(pf))
+ else:
+ file.write('4 %d %d %d %d\n' % tuple(pf))
+
+ file.close()
+ print("writing %r done" % filepath)
+
+ if use_modifiers:
+ bpy.data.meshes.remove(mesh)
+
+ # XXX
+ """
+ if is_editmode:
+ Blender.Window.EditMode(1, '', 0)
+ """
+
+ return {'FINISHED'}
diff --git a/io_mesh_ply/import_ply.py b/io_mesh_ply/import_ply.py
new file mode 100644
index 0000000000000000000000000000000000000000..6de90b1e86ef2c0c673933a21d0e88d0b1337540
--- /dev/null
+++ b/io_mesh_ply/import_ply.py
@@ -0,0 +1,339 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+import re
+import struct
+
+
+class element_spec(object):
+ __slots__ = ("name",
+ "count",
+ "properties",
+ )
+
+ def __init__(self, name, count):
+ self.name = name
+ self.count = count
+ self.properties = []
+
+ def load(self, format, stream):
+ if format == 'ascii':
+ stream = re.split('\s+', stream.readline())
+ return [x.load(format, stream) for x in self.properties]
+
+ def index(self, name):
+ for i, p in enumerate(self.properties):
+ if p.name == name:
+ return i
+ return -1
+
+
+class property_spec(object):
+ __slots__ = ("name",
+ "list_type",
+ "numeric_type",
+ )
+
+ def __init__(self, name, list_type, numeric_type):
+ self.name = name
+ self.list_type = list_type
+ self.numeric_type = numeric_type
+
+ def read_format(self, format, count, num_type, stream):
+ if format == 'ascii':
+ if num_type == 's':
+ ans = []
+ for i in range(count):
+ s = stream[i]
+ if len(s) < 2 or s[0] != '"' or s[-1] != '"':
+ print('Invalid string', s)
+ print('Note: ply_import.py does not handle whitespace in strings')
+ return None
+ ans.append(s[1:-1])
+ stream[:count] = []
+ return ans
+ if num_type == 'f' or num_type == 'd':
+ mapper = float
+ else:
+ mapper = int
+ ans = [mapper(x) for x in stream[:count]]
+ stream[:count] = []
+ return ans
+ else:
+ if num_type == 's':
+ ans = []
+ for i in range(count):
+ fmt = format + 'i'
+ data = stream.read(struct.calcsize(fmt))
+ length = struct.unpack(fmt, data)[0]
+ fmt = '%s%is' % (format, length)
+ data = stream.read(struct.calcsize(fmt))
+ s = struct.unpack(fmt, data)[0]
+ ans.append(s[:-1]) # strip the NULL
+ return ans
+ else:
+ fmt = '%s%i%s' % (format, count, num_type)
+ data = stream.read(struct.calcsize(fmt))
+ return struct.unpack(fmt, data)
+
+ def load(self, format, stream):
+ if self.list_type is not None:
+ count = int(self.read_format(format, 1, self.list_type, stream)[0])
+ return self.read_format(format, count, self.numeric_type, stream)
+ else:
+ return self.read_format(format, 1, self.numeric_type, stream)[0]
+
+
+class object_spec(object):
+ __slots__ = ("specs",
+ )
+ 'A list of element_specs'
+ def __init__(self):
+ self.specs = []
+
+ def load(self, format, stream):
+ return dict([(i.name, [i.load(format, stream) for j in range(i.count)]) for i in self.specs])
+
+ '''
+ # Longhand for above LC
+ answer = {}
+ for i in self.specs:
+ answer[i.name] = []
+ for j in range(i.count):
+ if not j % 100 and meshtools.show_progress:
+ Blender.Window.DrawProgressBar(float(j) / i.count, 'Loading ' + i.name)
+ answer[i.name].append(i.load(format, stream))
+ return answer
+ '''
+
+
+def read(filepath):
+ format = ''
+ version = '1.0'
+ format_specs = {'binary_little_endian': '<',
+ 'binary_big_endian': '>',
+ 'ascii': 'ascii'}
+ type_specs = {'char': 'b',
+ 'uchar': 'B',
+ 'int8': 'b',
+ 'uint8': 'B',
+ 'int16': 'h',
+ 'uint16': 'H',
+ 'ushort': 'H',
+ 'int': 'i',
+ 'int32': 'i',
+ 'uint': 'I',
+ 'uint32': 'I',
+ 'float': 'f',
+ 'float32': 'f',
+ 'float64': 'd',
+ 'double': 'd',
+ 'string': 's'}
+ obj_spec = object_spec()
+
+ try:
+ file = open(filepath, 'rU') # Only for parsing the header, not binary data
+ signature = file.readline()
+
+ if not signature.startswith('ply'):
+ print('Signature line was invalid')
+ return None
+
+ while 1:
+ tokens = re.split(r'[ \n]+', file.readline())
+
+ if len(tokens) == 0:
+ continue
+ if tokens[0] == 'end_header':
+ break
+ elif tokens[0] == 'comment' or tokens[0] == 'obj_info':
+ continue
+ elif tokens[0] == 'format':
+ if len(tokens) < 3:
+ print('Invalid format line')
+ return None
+ if tokens[1] not in format_specs: # .keys(): # keys is implicit
+ print('Unknown format', tokens[1])
+ return None
+ if tokens[2] != version:
+ print('Unknown version', tokens[2])
+ return None
+ format = tokens[1]
+ elif tokens[0] == 'element':
+ if len(tokens) < 3:
+ print('Invalid element line')
+ return None
+ obj_spec.specs.append(element_spec(tokens[1], int(tokens[2])))
+ elif tokens[0] == 'property':
+ if not len(obj_spec.specs):
+ print('Property without element')
+ return None
+ if tokens[1] == 'list':
+ obj_spec.specs[-1].properties.append(property_spec(tokens[4], type_specs[tokens[2]], type_specs[tokens[3]]))
+ else:
+ obj_spec.specs[-1].properties.append(property_spec(tokens[2], None, type_specs[tokens[1]]))
+
+ if format != 'ascii':
+ file.close() # was ascii, now binary
+ file = open(filepath, 'rb')
+
+ # skip the header...
+ while not file.readline().startswith('end_header'):
+ pass
+
+ obj = obj_spec.load(format_specs[format], file)
+
+ except IOError:
+ try:
+ file.close()
+ except:
+ pass
+
+ return None
+ try:
+ file.close()
+ except:
+ pass
+
+ return obj_spec, obj
+
+
+import bpy
+
+
+def load_ply(filepath):
+ import time
+ from io_utils import load_image, unpack_list, unpack_face_list
+
+ t = time.time()
+ obj_spec, obj = read(filepath)
+ if obj is None:
+ print('Invalid file')
+ return
+
+ uvindices = colindices = None
+ # noindices = None # Ignore normals
+
+ for el in obj_spec.specs:
+ if el.name == 'vertex':
+ vindices = vindices_x, vindices_y, vindices_z = (el.index('x'), el.index('y'), el.index('z'))
+ # noindices = (el.index('nx'), el.index('ny'), el.index('nz'))
+ # if -1 in noindices: noindices = None
+ uvindices = (el.index('s'), el.index('t'))
+ if -1 in uvindices:
+ uvindices = None
+ colindices = (el.index('red'), el.index('green'), el.index('blue'))
+ if -1 in colindices:
+ colindices = None
+ elif el.name == 'face':
+ findex = el.index('vertex_indices')
+
+ mesh_faces = []
+ mesh_uvs = []
+ mesh_colors = []
+
+ def add_face(vertices, indices, uvindices, colindices):
+ mesh_faces.append(indices)
+ if uvindices:
+ mesh_uvs.append([(vertices[index][uvindices[0]], 1.0 - vertices[index][uvindices[1]]) for index in indices])
+ if colindices:
+ mesh_colors.append([(vertices[index][colindices[0]], vertices[index][colindices[1]], vertices[index][colindices[2]]) for index in indices])
+
+ if uvindices or colindices:
+ # If we have Cols or UVs then we need to check the face order.
+ add_face_simple = add_face
+
+ # EVIL EEKADOODLE - face order annoyance.
+ def add_face(vertices, indices, uvindices, colindices):
+ if len(indices) == 4:
+ if indices[2] == 0 or indices[3] == 0:
+ indices = indices[2], indices[3], indices[0], indices[1]
+ elif len(indices) == 3:
+ if indices[2] == 0:
+ indices = indices[1], indices[2], indices[0]
+
+ add_face_simple(vertices, indices, uvindices, colindices)
+
+ verts = obj['vertex']
+
+ if 'face' in obj:
+ for f in obj['face']:
+ ind = f[findex]
+ len_ind = len(ind)
+ if len_ind <= 4:
+ add_face(verts, ind, uvindices, colindices)
+ else:
+ # Fan fill the face
+ for j in range(len_ind - 2):
+ add_face(verts, (ind[0], ind[j + 1], ind[j + 2]), uvindices, colindices)
+
+ ply_name = bpy.path.display_name_from_filepath(filepath)
+
+ mesh = bpy.data.meshes.new(name=ply_name)
+
+ mesh.vertices.add(len(obj['vertex']))
+
+ mesh.vertices.foreach_set("co", [a for v in obj['vertex'] for a in (v[vindices_x], v[vindices_y], v[vindices_z])])
+
+ if mesh_faces:
+ mesh.faces.add(len(mesh_faces))
+ mesh.faces.foreach_set("vertices_raw", unpack_face_list(mesh_faces))
+
+ if uvindices or colindices:
+ if uvindices:
+ uvlay = mesh.uv_textures.new()
+ if colindices:
+ vcol_lay = mesh.vertex_colors.new()
+
+ if uvindices:
+ for i, f in enumerate(uvlay.data):
+ ply_uv = mesh_uvs[i]
+ for j, uv in enumerate(f.uv):
+ uv[:] = ply_uv[j]
+
+ if colindices:
+ faces = obj['face']
+ for i, f in enumerate(vcol_lay.data):
+ # XXX, colors dont come in right, needs further investigation.
+ ply_col = mesh_colors[i]
+ if len(faces[i]) == 4:
+ f_col = f.color1, f.color2, f.color3, f.color4
+ else:
+ f_col = f.color1, f.color2, f.color3
+
+ for j, col in enumerate(f_col):
+ col.r, col.g, col.b = ply_col[j]
+
+ mesh.update()
+
+ scn = bpy.context.scene
+ #scn.objects.selected = [] # XXX25
+
+ obj = bpy.data.objects.new(ply_name, mesh)
+ scn.objects.link(obj)
+ scn.objects.active = obj
+ obj.select = True
+
+ print('\nSuccessfully imported %r in %.3f sec' % (filepath, time.time() - t))
+
+
+def load(operator, context, filepath=""):
+ load_ply(filepath)
+ return {'FINISHED'}
diff --git a/io_scene_3ds/__init__.py b/io_scene_3ds/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..8e701abeb6ba889e37d21c3a764958d3dbe0730e
--- /dev/null
+++ b/io_scene_3ds/__init__.py
@@ -0,0 +1,100 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "Autodesk 3DS format",
+ "author": "Bob Holcomb, Campbell Barton",
+ "location": "File > Import-Export",
+ "description": "Import-Export 3DS, meshes, uvs, materials, textures, cameras & lamps",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/Autodesk_3DS",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "import_3ds" in locals():
+ imp.reload(import_3ds)
+ if "export_3ds" in locals():
+ imp.reload(export_3ds)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ImportHelper, ExportHelper
+
+
+class Import3DS(bpy.types.Operator, ImportHelper):
+ '''Import from 3DS file format (.3ds)'''
+ bl_idname = "import_scene.autodesk_3ds"
+ bl_label = 'Import 3DS'
+
+ filename_ext = ".3ds"
+ filter_glob = StringProperty(default="*.3ds", options={'HIDDEN'})
+
+ constrain_size = FloatProperty(name="Size Constraint", description="Scale the model by 10 until it reacehs the size constraint. Zero Disables.", min=0.0, max=1000.0, soft_min=0.0, soft_max=1000.0, default=10.0)
+ use_image_search = BoolProperty(name="Image Search", description="Search subdirectories for any assosiated images (Warning, may be slow)", default=True)
+ use_apply_transform = BoolProperty(name="Apply Transform", description="Workaround for object transformations importing incorrectly", default=True)
+
+ def execute(self, context):
+ from . import import_3ds
+ return import_3ds.load(self, context, **self.as_keywords(ignore=("filter_glob",)))
+
+
+class Export3DS(bpy.types.Operator, ExportHelper):
+ '''Export to 3DS file format (.3ds)'''
+ bl_idname = "export_scene.autodesk_3ds"
+ bl_label = 'Export 3DS'
+
+ filename_ext = ".3ds"
+ filter_glob = StringProperty(default="*.3ds", options={'HIDDEN'})
+
+ def execute(self, context):
+ from . import export_3ds
+ return export_3ds.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob")))
+
+
+# Add to a menu
+def menu_func_export(self, context):
+ self.layout.operator(Export3DS.bl_idname, text="3D Studio (.3ds)")
+
+
+def menu_func_import(self, context):
+ self.layout.operator(Import3DS.bl_idname, text="3D Studio (.3ds)")
+
+
+def register():
+ bpy.types.INFO_MT_file_import.append(menu_func_import)
+ bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_import.remove(menu_func_import)
+ bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+# NOTES:
+# why add 1 extra vertex? and remove it when done? - "Answer - eekadoodle - would need to re-order UV's without this since face order isnt always what we give blender, BMesh will solve :D"
+# disabled scaling to size, this requires exposing bb (easy) and understanding how it works (needs some time)
+
+if __name__ == "__main__":
+ register()
diff --git a/io_scene_3ds/export_3ds.py b/io_scene_3ds/export_3ds.py
new file mode 100644
index 0000000000000000000000000000000000000000..65ed8fbce85eaadfcdbc61943ee470b45db95e8c
--- /dev/null
+++ b/io_scene_3ds/export_3ds.py
@@ -0,0 +1,1044 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Bob Holcomb
+# Contributors: Campbell Barton, Bob Holcomb, Richard Lärkäng, Damien McGinnes, Mark Stijnman
+
+"""
+Exporting is based on 3ds loader from www.gametutorials.com(Thanks DigiBen) and using information
+from the lib3ds project (http://lib3ds.sourceforge.net/) sourcecode.
+"""
+
+######################################################
+# Data Structures
+######################################################
+
+#Some of the chunks that we will export
+#----- Primary Chunk, at the beginning of each file
+PRIMARY= 0x4D4D
+
+#------ Main Chunks
+OBJECTINFO = 0x3D3D #This gives the version of the mesh and is found right before the material and object information
+VERSION = 0x0002 #This gives the version of the .3ds file
+KFDATA = 0xB000 #This is the header for all of the key frame info
+
+#------ sub defines of OBJECTINFO
+MATERIAL=45055 #0xAFFF // This stored the texture info
+OBJECT=16384 #0x4000 // This stores the faces, vertices, etc...
+
+#>------ sub defines of MATERIAL
+MATNAME = 0xA000 # This holds the material name
+MATAMBIENT = 0xA010 # Ambient color of the object/material
+MATDIFFUSE = 0xA020 # This holds the color of the object/material
+MATSPECULAR = 0xA030 # SPecular color of the object/material
+MATSHINESS = 0xA040 # ??
+MATMAP = 0xA200 # This is a header for a new material
+MATMAPFILE = 0xA300 # This holds the file name of the texture
+
+RGB1= 0x0011
+RGB2= 0x0012
+
+#>------ sub defines of OBJECT
+OBJECT_MESH = 0x4100 # This lets us know that we are reading a new object
+OBJECT_LIGHT = 0x4600 # This lets un know we are reading a light object
+OBJECT_CAMERA= 0x4700 # This lets un know we are reading a camera object
+
+#>------ sub defines of CAMERA
+OBJECT_CAM_RANGES= 0x4720 # The camera range values
+
+#>------ sub defines of OBJECT_MESH
+OBJECT_VERTICES = 0x4110 # The objects vertices
+OBJECT_FACES = 0x4120 # The objects faces
+OBJECT_MATERIAL = 0x4130 # This is found if the object has a material, either texture map or color
+OBJECT_UV = 0x4140 # The UV texture coordinates
+OBJECT_TRANS_MATRIX = 0x4160 # The Object Matrix
+
+#>------ sub defines of KFDATA
+KFDATA_KFHDR = 0xB00A
+KFDATA_KFSEG = 0xB008
+KFDATA_KFCURTIME = 0xB009
+KFDATA_OBJECT_NODE_TAG = 0xB002
+
+#>------ sub defines of OBJECT_NODE_TAG
+OBJECT_NODE_ID = 0xB030
+OBJECT_NODE_HDR = 0xB010
+OBJECT_PIVOT = 0xB013
+OBJECT_INSTANCE_NAME = 0xB011
+POS_TRACK_TAG = 0xB020
+ROT_TRACK_TAG = 0xB021
+SCL_TRACK_TAG = 0xB022
+
+import struct
+
+# So 3ds max can open files, limit names to 12 in length
+# this is verry annoying for filenames!
+name_unique = []
+name_mapping = {}
+def sane_name(name):
+ name_fixed = name_mapping.get(name)
+ if name_fixed is not None:
+ return name_fixed
+
+ new_name = name[:12]
+
+ i = 0
+
+ while new_name in name_unique:
+ new_name = new_name[:-4] + '.%.3d' % i
+ i+=1
+
+ name_unique.append(new_name)
+ name_mapping[name] = new_name
+ return new_name
+
+def uv_key(uv):
+ return round(uv[0], 6), round(uv[1], 6)
+
+# size defines:
+SZ_SHORT = 2
+SZ_INT = 4
+SZ_FLOAT = 4
+
+class _3ds_short(object):
+ '''Class representing a short (2-byte integer) for a 3ds file.
+ *** This looks like an unsigned short H is unsigned from the struct docs - Cam***'''
+ __slots__ = ('value', )
+ def __init__(self, val=0):
+ self.value = val
+
+ def get_size(self):
+ return SZ_SHORT
+
+ def write(self,file):
+ file.write(struct.pack("<H", self.value))
+
+ def __str__(self):
+ return str(self.value)
+
+class _3ds_int(object):
+ '''Class representing an int (4-byte integer) for a 3ds file.'''
+ __slots__ = ('value', )
+ def __init__(self, val):
+ self.value = val
+
+ def get_size(self):
+ return SZ_INT
+
+ def write(self,file):
+ file.write(struct.pack("<I", self.value))
+
+ def __str__(self):
+ return str(self.value)
+
+class _3ds_float(object):
+ '''Class representing a 4-byte IEEE floating point number for a 3ds file.'''
+ __slots__ = ('value', )
+ def __init__(self, val):
+ self.value=val
+
+ def get_size(self):
+ return SZ_FLOAT
+
+ def write(self,file):
+ file.write(struct.pack("<f", self.value))
+
+ def __str__(self):
+ return str(self.value)
+
+
+class _3ds_string(object):
+ '''Class representing a zero-terminated string for a 3ds file.'''
+ __slots__ = ('value', )
+ def __init__(self, val):
+ self.value=val
+
+ def get_size(self):
+ return (len(self.value)+1)
+
+ def write(self,file):
+ binary_format = "<%ds" % (len(self.value)+1)
+ file.write(struct.pack(binary_format, self.value))
+
+ def __str__(self):
+ return self.value
+
+class _3ds_point_3d(object):
+ '''Class representing a three-dimensional point for a 3ds file.'''
+ __slots__ = 'x','y','z'
+ def __init__(self, point):
+ self.x, self.y, self.z = point
+
+ def get_size(self):
+ return 3*SZ_FLOAT
+
+ def write(self,file):
+ file.write(struct.pack('<3f', self.x, self.y, self.z))
+
+ def __str__(self):
+ return '(%f, %f, %f)' % (self.x, self.y, self.z)
+
+# Used for writing a track
+"""
+class _3ds_point_4d(object):
+ '''Class representing a four-dimensional point for a 3ds file, for instance a quaternion.'''
+ __slots__ = 'x','y','z','w'
+ def __init__(self, point=(0.0,0.0,0.0,0.0)):
+ self.x, self.y, self.z, self.w = point
+
+ def get_size(self):
+ return 4*SZ_FLOAT
+
+ def write(self,file):
+ data=struct.pack('<4f', self.x, self.y, self.z, self.w)
+ file.write(data)
+
+ def __str__(self):
+ return '(%f, %f, %f, %f)' % (self.x, self.y, self.z, self.w)
+"""
+
+class _3ds_point_uv(object):
+ '''Class representing a UV-coordinate for a 3ds file.'''
+ __slots__ = ('uv', )
+ def __init__(self, point):
+ self.uv = point
+
+ def __cmp__(self, other):
+ return cmp(self.uv,other.uv)
+
+ def get_size(self):
+ return 2*SZ_FLOAT
+
+ def write(self,file):
+ data=struct.pack('<2f', self.uv[0], self.uv[1])
+ file.write(data)
+
+ def __str__(self):
+ return '(%g, %g)' % self.uv
+
+class _3ds_rgb_color(object):
+ '''Class representing a (24-bit) rgb color for a 3ds file.'''
+ __slots__ = 'r','g','b'
+ def __init__(self, col):
+ self.r, self.g, self.b = col
+
+ def get_size(self):
+ return 3
+
+ def write(self,file):
+ file.write( struct.pack('<3B', int(255*self.r), int(255*self.g), int(255*self.b) ) )
+# file.write( struct.pack('<3c', chr(int(255*self.r)), chr(int(255*self.g)), chr(int(255*self.b)) ) )
+
+ def __str__(self):
+ return '{%f, %f, %f}' % (self.r, self.g, self.b)
+
+class _3ds_face(object):
+ '''Class representing a face for a 3ds file.'''
+ __slots__ = ('vindex', )
+ def __init__(self, vindex):
+ self.vindex = vindex
+
+ def get_size(self):
+ return 4*SZ_SHORT
+
+ def write(self,file):
+ # The last zero is only used by 3d studio
+ file.write(struct.pack("<4H", self.vindex[0],self.vindex[1], self.vindex[2], 0))
+
+ def __str__(self):
+ return '[%d %d %d]' % (self.vindex[0],self.vindex[1], self.vindex[2])
+
+class _3ds_array(object):
+ '''Class representing an array of variables for a 3ds file.
+
+ Consists of a _3ds_short to indicate the number of items, followed by the items themselves.
+ '''
+ __slots__ = 'values', 'size'
+ def __init__(self):
+ self.values=[]
+ self.size=SZ_SHORT
+
+ # add an item:
+ def add(self,item):
+ self.values.append(item)
+ self.size+=item.get_size()
+
+ def get_size(self):
+ return self.size
+
+ def write(self,file):
+ _3ds_short(len(self.values)).write(file)
+ #_3ds_int(len(self.values)).write(file)
+ for value in self.values:
+ value.write(file)
+
+ # To not overwhelm the output in a dump, a _3ds_array only
+ # outputs the number of items, not all of the actual items.
+ def __str__(self):
+ return '(%d items)' % len(self.values)
+
+class _3ds_named_variable(object):
+ '''Convenience class for named variables.'''
+
+ __slots__ = 'value', 'name'
+ def __init__(self, name, val=None):
+ self.name=name
+ self.value=val
+
+ def get_size(self):
+ if self.value is None:
+ return 0
+ else:
+ return self.value.get_size()
+
+ def write(self, file):
+ if self.value is not None:
+ self.value.write(file)
+
+ def dump(self,indent):
+ if self.value is not None:
+ spaces=""
+ for i in range(indent):
+ spaces += " "
+ if (self.name!=""):
+ print(spaces, self.name, " = ", self.value)
+ else:
+ print(spaces, "[unnamed]", " = ", self.value)
+
+
+#the chunk class
+class _3ds_chunk(object):
+ '''Class representing a chunk in a 3ds file.
+
+ Chunks contain zero or more variables, followed by zero or more subchunks.
+ '''
+ __slots__ = 'ID', 'size', 'variables', 'subchunks'
+ def __init__(self, id=0):
+ self.ID=_3ds_short(id)
+ self.size=_3ds_int(0)
+ self.variables=[]
+ self.subchunks=[]
+
+ def set_ID(id):
+ self.ID=_3ds_short(id)
+
+ def add_variable(self, name, var):
+ '''Add a named variable.
+
+ The name is mostly for debugging purposes.'''
+ self.variables.append(_3ds_named_variable(name,var))
+
+ def add_subchunk(self, chunk):
+ '''Add a subchunk.'''
+ self.subchunks.append(chunk)
+
+ def get_size(self):
+ '''Calculate the size of the chunk and return it.
+
+ The sizes of the variables and subchunks are used to determine this chunk\'s size.'''
+ tmpsize=self.ID.get_size()+self.size.get_size()
+ for variable in self.variables:
+ tmpsize+=variable.get_size()
+ for subchunk in self.subchunks:
+ tmpsize+=subchunk.get_size()
+ self.size.value=tmpsize
+ return self.size.value
+
+ def write(self, file):
+ '''Write the chunk to a file.
+
+ Uses the write function of the variables and the subchunks to do the actual work.'''
+ #write header
+ self.ID.write(file)
+ self.size.write(file)
+ for variable in self.variables:
+ variable.write(file)
+ for subchunk in self.subchunks:
+ subchunk.write(file)
+
+
+ def dump(self, indent=0):
+ '''Write the chunk to a file.
+
+ Dump is used for debugging purposes, to dump the contents of a chunk to the standard output.
+ Uses the dump function of the named variables and the subchunks to do the actual work.'''
+ spaces=""
+ for i in range(indent):
+ spaces += " "
+ print(spaces, "ID=", hex(self.ID.value), "size=", self.get_size())
+ for variable in self.variables:
+ variable.dump(indent+1)
+ for subchunk in self.subchunks:
+ subchunk.dump(indent+1)
+
+
+
+######################################################
+# EXPORT
+######################################################
+
+def get_material_images(material):
+ # blender utility func.
+ if material:
+ return [s.texture.image for s in material.texture_slots if s and s.texture.type == 'IMAGE' and s.texture.image]
+
+ return []
+# images = []
+# if material:
+# for mtex in material.getTextures():
+# if mtex and mtex.tex.type == Blender.Texture.Types.IMAGE:
+# image = mtex.tex.image
+# if image:
+# images.append(image) # maye want to include info like diffuse, spec here.
+# return images
+
+
+def make_material_subchunk(id, color):
+ '''Make a material subchunk.
+
+ Used for color subchunks, such as diffuse color or ambient color subchunks.'''
+ mat_sub = _3ds_chunk(id)
+ col1 = _3ds_chunk(RGB1)
+ col1.add_variable("color1", _3ds_rgb_color(color))
+ mat_sub.add_subchunk(col1)
+# optional:
+# col2 = _3ds_chunk(RGB1)
+# col2.add_variable("color2", _3ds_rgb_color(color))
+# mat_sub.add_subchunk(col2)
+ return mat_sub
+
+
+def make_material_texture_chunk(id, images):
+ """Make Material Map texture chunk
+ """
+ mat_sub = _3ds_chunk(id)
+
+ def add_image(img):
+ import os
+ filename = os.path.basename(image.filepath)
+ mat_sub_file = _3ds_chunk(MATMAPFILE)
+ mat_sub_file.add_variable("mapfile", _3ds_string(sane_name(filename)))
+ mat_sub.add_subchunk(mat_sub_file)
+
+ for image in images:
+ add_image(image)
+
+ return mat_sub
+
+def make_material_chunk(material, image):
+ '''Make a material chunk out of a blender material.'''
+ material_chunk = _3ds_chunk(MATERIAL)
+ name = _3ds_chunk(MATNAME)
+
+ if material: name_str = material.name
+ else: name_str = 'None'
+ if image: name_str += image.name
+
+ name.add_variable("name", _3ds_string(sane_name(name_str)))
+ material_chunk.add_subchunk(name)
+
+ if not material:
+ material_chunk.add_subchunk(make_material_subchunk(MATAMBIENT, (0,0,0) ))
+ material_chunk.add_subchunk(make_material_subchunk(MATDIFFUSE, (.8, .8, .8) ))
+ material_chunk.add_subchunk(make_material_subchunk(MATSPECULAR, (1,1,1) ))
+
+ else:
+ material_chunk.add_subchunk(make_material_subchunk(MATAMBIENT, [a*material.ambient for a in material.diffuse_color] ))
+# material_chunk.add_subchunk(make_material_subchunk(MATAMBIENT, [a*material.amb for a in material.rgbCol] ))
+ material_chunk.add_subchunk(make_material_subchunk(MATDIFFUSE, material.diffuse_color))
+# material_chunk.add_subchunk(make_material_subchunk(MATDIFFUSE, material.rgbCol))
+ material_chunk.add_subchunk(make_material_subchunk(MATSPECULAR, material.specular_color))
+# material_chunk.add_subchunk(make_material_subchunk(MATSPECULAR, material.specCol))
+
+ images = get_material_images(material) # can be None
+ if image: images.append(image)
+
+ if images:
+ material_chunk.add_subchunk(make_material_texture_chunk(MATMAP, images))
+
+ return material_chunk
+
+class tri_wrapper(object):
+ '''Class representing a triangle.
+
+ Used when converting faces to triangles'''
+
+ __slots__ = 'vertex_index', 'mat', 'image', 'faceuvs', 'offset'
+ def __init__(self, vindex=(0,0,0), mat=None, image=None, faceuvs=None):
+ self.vertex_index= vindex
+ self.mat= mat
+ self.image= image
+ self.faceuvs= faceuvs
+ self.offset= [0, 0, 0] # offset indicies
+
+
+def extract_triangles(mesh):
+ '''Extract triangles from a mesh.
+
+ If the mesh contains quads, they will be split into triangles.'''
+ tri_list = []
+ do_uv = len(mesh.uv_textures)
+# do_uv = mesh.faceUV
+
+# if not do_uv:
+# face_uv = None
+
+ img = None
+ for i, face in enumerate(mesh.faces):
+ f_v = face.vertices
+# f_v = face.v
+
+ uf = mesh.uv_textures.active.data[i] if do_uv else None
+
+ if do_uv:
+ f_uv = uf.uv
+ # f_uv = (uf.uv1, uf.uv2, uf.uv3, uf.uv4) if face.vertices[3] else (uf.uv1, uf.uv2, uf.uv3)
+# f_uv = face.uv
+ img = uf.image if uf else None
+# img = face.image
+ if img: img = img.name
+
+ # if f_v[3] == 0:
+ if len(f_v)==3:
+ new_tri = tri_wrapper((f_v[0], f_v[1], f_v[2]), face.material_index, img)
+# new_tri = tri_wrapper((f_v[0].index, f_v[1].index, f_v[2].index), face.mat, img)
+ if (do_uv): new_tri.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[1]), uv_key(f_uv[2])
+ tri_list.append(new_tri)
+
+ else: #it's a quad
+ new_tri = tri_wrapper((f_v[0], f_v[1], f_v[2]), face.material_index, img)
+# new_tri = tri_wrapper((f_v[0].index, f_v[1].index, f_v[2].index), face.mat, img)
+ new_tri_2 = tri_wrapper((f_v[0], f_v[2], f_v[3]), face.material_index, img)
+# new_tri_2 = tri_wrapper((f_v[0].index, f_v[2].index, f_v[3].index), face.mat, img)
+
+ if (do_uv):
+ new_tri.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[1]), uv_key(f_uv[2])
+ new_tri_2.faceuvs= uv_key(f_uv[0]), uv_key(f_uv[2]), uv_key(f_uv[3])
+
+ tri_list.append( new_tri )
+ tri_list.append( new_tri_2 )
+
+ return tri_list
+
+
+def remove_face_uv(verts, tri_list):
+ '''Remove face UV coordinates from a list of triangles.
+
+ Since 3ds files only support one pair of uv coordinates for each vertex, face uv coordinates
+ need to be converted to vertex uv coordinates. That means that vertices need to be duplicated when
+ there are multiple uv coordinates per vertex.'''
+
+ # initialize a list of UniqueLists, one per vertex:
+ #uv_list = [UniqueList() for i in xrange(len(verts))]
+ unique_uvs= [{} for i in range(len(verts))]
+
+ # for each face uv coordinate, add it to the UniqueList of the vertex
+ for tri in tri_list:
+ for i in range(3):
+ # store the index into the UniqueList for future reference:
+ # offset.append(uv_list[tri.vertex_index[i]].add(_3ds_point_uv(tri.faceuvs[i])))
+
+ context_uv_vert= unique_uvs[tri.vertex_index[i]]
+ uvkey= tri.faceuvs[i]
+
+ offset_index__uv_3ds = context_uv_vert.get(uvkey)
+
+ if not offset_index__uv_3ds:
+ offset_index__uv_3ds = context_uv_vert[uvkey] = len(context_uv_vert), _3ds_point_uv(uvkey)
+
+ tri.offset[i] = offset_index__uv_3ds[0]
+
+
+
+ # At this point, each vertex has a UniqueList containing every uv coordinate that is associated with it
+ # only once.
+
+ # Now we need to duplicate every vertex as many times as it has uv coordinates and make sure the
+ # faces refer to the new face indices:
+ vert_index = 0
+ vert_array = _3ds_array()
+ uv_array = _3ds_array()
+ index_list = []
+ for i,vert in enumerate(verts):
+ index_list.append(vert_index)
+
+ pt = _3ds_point_3d(vert.co) # reuse, should be ok
+ uvmap = [None] * len(unique_uvs[i])
+ for ii, uv_3ds in unique_uvs[i].values():
+ # add a vertex duplicate to the vertex_array for every uv associated with this vertex:
+ vert_array.add(pt)
+ # add the uv coordinate to the uv array:
+ # This for loop does not give uv's ordered by ii, so we create a new map
+ # and add the uv's later
+ # uv_array.add(uv_3ds)
+ uvmap[ii] = uv_3ds
+
+ # Add the uv's in the correct order
+ for uv_3ds in uvmap:
+ # add the uv coordinate to the uv array:
+ uv_array.add(uv_3ds)
+
+ vert_index += len(unique_uvs[i])
+
+ # Make sure the triangle vertex indices now refer to the new vertex list:
+ for tri in tri_list:
+ for i in range(3):
+ tri.offset[i]+=index_list[tri.vertex_index[i]]
+ tri.vertex_index= tri.offset
+
+ return vert_array, uv_array, tri_list
+
+def make_faces_chunk(tri_list, mesh, materialDict):
+ '''Make a chunk for the faces.
+
+ Also adds subchunks assigning materials to all faces.'''
+
+ materials = mesh.materials
+ if not materials:
+ mat = None
+
+ face_chunk = _3ds_chunk(OBJECT_FACES)
+ face_list = _3ds_array()
+
+
+ if len(mesh.uv_textures):
+# if mesh.faceUV:
+ # Gather materials used in this mesh - mat/image pairs
+ unique_mats = {}
+ for i,tri in enumerate(tri_list):
+
+ face_list.add(_3ds_face(tri.vertex_index))
+
+ if materials:
+ mat = materials[tri.mat]
+ if mat: mat = mat.name
+
+ img = tri.image
+
+ try:
+ context_mat_face_array = unique_mats[mat, img][1]
+ except:
+
+ if mat: name_str = mat
+ else: name_str = 'None'
+ if img: name_str += img
+
+ context_mat_face_array = _3ds_array()
+ unique_mats[mat, img] = _3ds_string(sane_name(name_str)), context_mat_face_array
+
+
+ context_mat_face_array.add(_3ds_short(i))
+ # obj_material_faces[tri.mat].add(_3ds_short(i))
+
+ face_chunk.add_variable("faces", face_list)
+ for mat_name, mat_faces in unique_mats.values():
+ obj_material_chunk=_3ds_chunk(OBJECT_MATERIAL)
+ obj_material_chunk.add_variable("name", mat_name)
+ obj_material_chunk.add_variable("face_list", mat_faces)
+ face_chunk.add_subchunk(obj_material_chunk)
+
+ else:
+
+ obj_material_faces=[]
+ obj_material_names=[]
+ for m in materials:
+ if m:
+ obj_material_names.append(_3ds_string(sane_name(m.name)))
+ obj_material_faces.append(_3ds_array())
+ n_materials = len(obj_material_names)
+
+ for i,tri in enumerate(tri_list):
+ face_list.add(_3ds_face(tri.vertex_index))
+ if (tri.mat < n_materials):
+ obj_material_faces[tri.mat].add(_3ds_short(i))
+
+ face_chunk.add_variable("faces", face_list)
+ for i in range(n_materials):
+ obj_material_chunk=_3ds_chunk(OBJECT_MATERIAL)
+ obj_material_chunk.add_variable("name", obj_material_names[i])
+ obj_material_chunk.add_variable("face_list", obj_material_faces[i])
+ face_chunk.add_subchunk(obj_material_chunk)
+
+ return face_chunk
+
+def make_vert_chunk(vert_array):
+ '''Make a vertex chunk out of an array of vertices.'''
+ vert_chunk = _3ds_chunk(OBJECT_VERTICES)
+ vert_chunk.add_variable("vertices",vert_array)
+ return vert_chunk
+
+def make_uv_chunk(uv_array):
+ '''Make a UV chunk out of an array of UVs.'''
+ uv_chunk = _3ds_chunk(OBJECT_UV)
+ uv_chunk.add_variable("uv coords", uv_array)
+ return uv_chunk
+
+def make_mesh_chunk(mesh, materialDict):
+ '''Make a chunk out of a Blender mesh.'''
+
+ # Extract the triangles from the mesh:
+ tri_list = extract_triangles(mesh)
+
+ if len(mesh.uv_textures):
+# if mesh.faceUV:
+ # Remove the face UVs and convert it to vertex UV:
+ vert_array, uv_array, tri_list = remove_face_uv(mesh.vertices, tri_list)
+ else:
+ # Add the vertices to the vertex array:
+ vert_array = _3ds_array()
+ for vert in mesh.vertices:
+ vert_array.add(_3ds_point_3d(vert.co))
+ # If the mesh has vertex UVs, create an array of UVs:
+ if len(mesh.sticky):
+# if mesh.vertexUV:
+ uv_array = _3ds_array()
+ for uv in mesh.sticky:
+# for vert in mesh.vertices:
+ uv_array.add(_3ds_point_uv(uv.co))
+# uv_array.add(_3ds_point_uv(vert.uvco))
+ else:
+ # no UV at all:
+ uv_array = None
+
+ # create the chunk:
+ mesh_chunk = _3ds_chunk(OBJECT_MESH)
+
+ # add vertex chunk:
+ mesh_chunk.add_subchunk(make_vert_chunk(vert_array))
+ # add faces chunk:
+
+ mesh_chunk.add_subchunk(make_faces_chunk(tri_list, mesh, materialDict))
+
+ # if available, add uv chunk:
+ if uv_array:
+ mesh_chunk.add_subchunk(make_uv_chunk(uv_array))
+
+ return mesh_chunk
+
+""" # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+def make_kfdata(start=0, stop=0, curtime=0):
+ '''Make the basic keyframe data chunk'''
+ kfdata = _3ds_chunk(KFDATA)
+
+ kfhdr = _3ds_chunk(KFDATA_KFHDR)
+ kfhdr.add_variable("revision", _3ds_short(0))
+ # Not really sure what filename is used for, but it seems it is usually used
+ # to identify the program that generated the .3ds:
+ kfhdr.add_variable("filename", _3ds_string("Blender"))
+ kfhdr.add_variable("animlen", _3ds_int(stop-start))
+
+ kfseg = _3ds_chunk(KFDATA_KFSEG)
+ kfseg.add_variable("start", _3ds_int(start))
+ kfseg.add_variable("stop", _3ds_int(stop))
+
+ kfcurtime = _3ds_chunk(KFDATA_KFCURTIME)
+ kfcurtime.add_variable("curtime", _3ds_int(curtime))
+
+ kfdata.add_subchunk(kfhdr)
+ kfdata.add_subchunk(kfseg)
+ kfdata.add_subchunk(kfcurtime)
+ return kfdata
+"""
+
+"""
+def make_track_chunk(ID, obj):
+ '''Make a chunk for track data.
+
+ Depending on the ID, this will construct a position, rotation or scale track.'''
+ track_chunk = _3ds_chunk(ID)
+ track_chunk.add_variable("track_flags", _3ds_short())
+ track_chunk.add_variable("unknown", _3ds_int())
+ track_chunk.add_variable("unknown", _3ds_int())
+ track_chunk.add_variable("nkeys", _3ds_int(1))
+ # Next section should be repeated for every keyframe, but for now, animation is not actually supported.
+ track_chunk.add_variable("tcb_frame", _3ds_int(0))
+ track_chunk.add_variable("tcb_flags", _3ds_short())
+ if obj.type=='Empty':
+ if ID==POS_TRACK_TAG:
+ # position vector:
+ track_chunk.add_variable("position", _3ds_point_3d(obj.getLocation()))
+ elif ID==ROT_TRACK_TAG:
+ # rotation (quaternion, angle first, followed by axis):
+ q = obj.getEuler().to_quat()
+ track_chunk.add_variable("rotation", _3ds_point_4d((q.angle, q.axis[0], q.axis[1], q.axis[2])))
+ elif ID==SCL_TRACK_TAG:
+ # scale vector:
+ track_chunk.add_variable("scale", _3ds_point_3d(obj.getSize()))
+ else:
+ # meshes have their transformations applied before
+ # exporting, so write identity transforms here:
+ if ID==POS_TRACK_TAG:
+ # position vector:
+ track_chunk.add_variable("position", _3ds_point_3d((0.0,0.0,0.0)))
+ elif ID==ROT_TRACK_TAG:
+ # rotation (quaternion, angle first, followed by axis):
+ track_chunk.add_variable("rotation", _3ds_point_4d((0.0, 1.0, 0.0, 0.0)))
+ elif ID==SCL_TRACK_TAG:
+ # scale vector:
+ track_chunk.add_variable("scale", _3ds_point_3d((1.0, 1.0, 1.0)))
+
+ return track_chunk
+"""
+
+"""
+def make_kf_obj_node(obj, name_to_id):
+ '''Make a node chunk for a Blender object.
+
+ Takes the Blender object as a parameter. Object id's are taken from the dictionary name_to_id.
+ Blender Empty objects are converted to dummy nodes.'''
+
+ name = obj.name
+ # main object node chunk:
+ kf_obj_node = _3ds_chunk(KFDATA_OBJECT_NODE_TAG)
+ # chunk for the object id:
+ obj_id_chunk = _3ds_chunk(OBJECT_NODE_ID)
+ # object id is from the name_to_id dictionary:
+ obj_id_chunk.add_variable("node_id", _3ds_short(name_to_id[name]))
+
+ # object node header:
+ obj_node_header_chunk = _3ds_chunk(OBJECT_NODE_HDR)
+ # object name:
+ if obj.type == 'Empty':
+ # Empties are called "$$$DUMMY" and use the OBJECT_INSTANCE_NAME chunk
+ # for their name (see below):
+ obj_node_header_chunk.add_variable("name", _3ds_string("$$$DUMMY"))
+ else:
+ # Add the name:
+ obj_node_header_chunk.add_variable("name", _3ds_string(sane_name(name)))
+ # Add Flag variables (not sure what they do):
+ obj_node_header_chunk.add_variable("flags1", _3ds_short(0))
+ obj_node_header_chunk.add_variable("flags2", _3ds_short(0))
+
+ # Check parent-child relationships:
+ parent = obj.parent
+ if (parent is None) or (parent.name not in name_to_id):
+ # If no parent, or the parents name is not in the name_to_id dictionary,
+ # parent id becomes -1:
+ obj_node_header_chunk.add_variable("parent", _3ds_short(-1))
+ else:
+ # Get the parent's id from the name_to_id dictionary:
+ obj_node_header_chunk.add_variable("parent", _3ds_short(name_to_id[parent.name]))
+
+ # Add pivot chunk:
+ obj_pivot_chunk = _3ds_chunk(OBJECT_PIVOT)
+ obj_pivot_chunk.add_variable("pivot", _3ds_point_3d(obj.getLocation()))
+ kf_obj_node.add_subchunk(obj_pivot_chunk)
+
+ # add subchunks for object id and node header:
+ kf_obj_node.add_subchunk(obj_id_chunk)
+ kf_obj_node.add_subchunk(obj_node_header_chunk)
+
+ # Empty objects need to have an extra chunk for the instance name:
+ if obj.type == 'Empty':
+ obj_instance_name_chunk = _3ds_chunk(OBJECT_INSTANCE_NAME)
+ obj_instance_name_chunk.add_variable("name", _3ds_string(sane_name(name)))
+ kf_obj_node.add_subchunk(obj_instance_name_chunk)
+
+ # Add track chunks for position, rotation and scale:
+ kf_obj_node.add_subchunk(make_track_chunk(POS_TRACK_TAG, obj))
+ kf_obj_node.add_subchunk(make_track_chunk(ROT_TRACK_TAG, obj))
+ kf_obj_node.add_subchunk(make_track_chunk(SCL_TRACK_TAG, obj))
+
+ return kf_obj_node
+"""
+
+
+def save(operator, context, filepath=""):
+ import bpy
+ import time
+ from io_utils import create_derived_objects, free_derived_objects
+
+ '''Save the Blender scene to a 3ds file.'''
+
+ # Time the export
+ time1 = time.clock()
+# Blender.Window.WaitCursor(1)
+
+ sce = context.scene
+
+ if bpy.ops.object.mode_set.poll():
+ bpy.ops.object.mode_set(mode='OBJECT')
+
+ # Initialize the main chunk (primary):
+ primary = _3ds_chunk(PRIMARY)
+ # Add version chunk:
+ version_chunk = _3ds_chunk(VERSION)
+ version_chunk.add_variable("version", _3ds_int(3))
+ primary.add_subchunk(version_chunk)
+
+ # init main object info chunk:
+ object_info = _3ds_chunk(OBJECTINFO)
+
+ ''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+ # init main key frame data chunk:
+ kfdata = make_kfdata()
+ '''
+
+ # Get all the supported objects selected in this scene:
+ # ob_sel= list(sce.objects.context)
+ # mesh_objects = [ (ob, me) for ob in ob_sel for me in (BPyMesh.getMeshFromObject(ob, None, True, False, sce),) if me ]
+ # empty_objects = [ ob for ob in ob_sel if ob.type == 'Empty' ]
+
+ # Make a list of all materials used in the selected meshes (use a dictionary,
+ # each material is added once):
+ materialDict = {}
+ mesh_objects = []
+ scene = context.scene
+ for ob in [ob for ob in scene.objects if ob.is_visible(scene)]:
+# for ob in sce.objects.context:
+
+ # get derived objects
+ free, derived = create_derived_objects(scene, ob)
+
+ if derived is None:
+ continue
+
+ for ob_derived, mat in derived:
+# for ob_derived, mat in getDerivedObjects(ob, False):
+
+ if ob.type not in ('MESH', 'CURVE', 'SURFACE', 'FONT', 'META'):
+ continue
+
+ data = ob_derived.create_mesh(scene, True, 'PREVIEW')
+# data = getMeshFromObject(ob_derived, None, True, False, sce)
+ if data:
+ data.transform(mat)
+# data.transform(mat, recalc_normals=False)
+ mesh_objects.append((ob_derived, data))
+ mat_ls = data.materials
+ mat_ls_len = len(mat_ls)
+
+ # get material/image tuples.
+ if len(data.uv_textures):
+# if data.faceUV:
+ if not mat_ls:
+ mat = mat_name = None
+
+ for f, uf in zip(data.faces, data.uv_textures.active.data):
+ if mat_ls:
+ mat_index = f.material_index
+# mat_index = f.mat
+ if mat_index >= mat_ls_len:
+ mat_index = f.mat = 0
+ mat = mat_ls[mat_index]
+ if mat: mat_name = mat.name
+ else: mat_name = None
+ # else there already set to none
+
+ img = uf.image
+# img = f.image
+ if img: img_name = img.name
+ else: img_name = None
+
+ materialDict.setdefault((mat_name, img_name), (mat, img) )
+
+
+ else:
+ for mat in mat_ls:
+ if mat: # material may be None so check its not.
+ materialDict.setdefault((mat.name, None), (mat, None) )
+
+ # Why 0 Why!
+ for f in data.faces:
+ if f.material_index >= mat_ls_len:
+# if f.mat >= mat_ls_len:
+ f.material_index = 0
+ # f.mat = 0
+
+ if free:
+ free_derived_objects(ob)
+
+
+ # Make material chunks for all materials used in the meshes:
+ for mat_and_image in materialDict.values():
+ object_info.add_subchunk(make_material_chunk(mat_and_image[0], mat_and_image[1]))
+
+ # Give all objects a unique ID and build a dictionary from object name to object id:
+ """
+ name_to_id = {}
+ for ob, data in mesh_objects:
+ name_to_id[ob.name]= len(name_to_id)
+ #for ob in empty_objects:
+ # name_to_id[ob.name]= len(name_to_id)
+ """
+
+ # Create object chunks for all meshes:
+ i = 0
+ for ob, blender_mesh in mesh_objects:
+ # create a new object chunk
+ object_chunk = _3ds_chunk(OBJECT)
+
+ # set the object name
+ object_chunk.add_variable("name", _3ds_string(sane_name(ob.name)))
+
+ # make a mesh chunk out of the mesh:
+ object_chunk.add_subchunk(make_mesh_chunk(blender_mesh, materialDict))
+ object_info.add_subchunk(object_chunk)
+
+ ''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+ # make a kf object node for the object:
+ kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id))
+ '''
+ if not blender_mesh.users:
+ bpy.data.meshes.remove(blender_mesh)
+# blender_mesh.vertices = None
+
+ i+=i
+
+ # Create chunks for all empties:
+ ''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+ for ob in empty_objects:
+ # Empties only require a kf object node:
+ kfdata.add_subchunk(make_kf_obj_node(ob, name_to_id))
+ pass
+ '''
+
+ # Add main object info chunk to primary chunk:
+ primary.add_subchunk(object_info)
+
+ ''' # COMMENTED OUT FOR 2.42 RELEASE!! CRASHES 3DS MAX
+ # Add main keyframe data chunk to primary chunk:
+ primary.add_subchunk(kfdata)
+ '''
+
+ # At this point, the chunk hierarchy is completely built.
+
+ # Check the size:
+ primary.get_size()
+ # Open the file for writing:
+ file = open(filepath, 'wb')
+
+ # Recursively write the chunks to file:
+ primary.write(file)
+
+ # Close the file:
+ file.close()
+
+ # Clear name mapping vars, could make locals too
+ name_unique[:] = []
+ name_mapping.clear()
+
+ # Debugging only: report the exporting time:
+# Blender.Window.WaitCursor(0)
+ print("3ds export time: %.2f" % (time.clock() - time1))
+
+ # Debugging only: dump the chunk hierarchy:
+ #primary.dump()
+
+ return {'FINISHED'}
diff --git a/io_scene_3ds/import_3ds.py b/io_scene_3ds/import_3ds.py
new file mode 100644
index 0000000000000000000000000000000000000000..26093078335b0a08bfb6f5a0f1e43671d48b1988
--- /dev/null
+++ b/io_scene_3ds/import_3ds.py
@@ -0,0 +1,894 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Bob Holcomb
+# Contributors: Bob Holcomb, Richard L?rk?ng, Damien McGinnes, Campbell Barton, Mario Lapin, Dominique Lorre
+
+import os
+import time
+import struct
+
+from io_utils import load_image
+
+import bpy
+import mathutils
+
+BOUNDS_3DS = []
+
+
+######################################################
+# Data Structures
+######################################################
+
+#Some of the chunks that we will see
+#----- Primary Chunk, at the beginning of each file
+PRIMARY = int('0x4D4D',16)
+
+#------ Main Chunks
+OBJECTINFO = 0x3D3D #This gives the version of the mesh and is found right before the material and object information
+VERSION = 0x0002 #This gives the version of the .3ds file
+EDITKEYFRAME= 0xB000 #This is the header for all of the key frame info
+
+#------ sub defines of OBJECTINFO
+MATERIAL = 45055 #0xAFFF // This stored the texture info
+OBJECT = 16384 #0x4000 // This stores the faces, vertices, etc...
+
+#>------ sub defines of MATERIAL
+#------ sub defines of MATERIAL_BLOCK
+MAT_NAME = 0xA000 # This holds the material name
+MAT_AMBIENT = 0xA010 # Ambient color of the object/material
+MAT_DIFFUSE = 0xA020 # This holds the color of the object/material
+MAT_SPECULAR = 0xA030 # SPecular color of the object/material
+MAT_SHINESS = 0xA040 # ??
+MAT_TRANSPARENCY= 0xA050 # Transparency value of material
+MAT_SELF_ILLUM = 0xA080 # Self Illumination value of material
+MAT_WIRE = 0xA085 # Only render's wireframe
+
+MAT_TEXTURE_MAP = 0xA200 # This is a header for a new texture map
+MAT_SPECULAR_MAP= 0xA204 # This is a header for a new specular map
+MAT_OPACITY_MAP = 0xA210 # This is a header for a new opacity map
+MAT_REFLECTION_MAP= 0xA220 # This is a header for a new reflection map
+MAT_BUMP_MAP = 0xA230 # This is a header for a new bump map
+MAT_MAP_FILEPATH = 0xA300 # This holds the file name of the texture
+
+MAT_FLOAT_COLOR = 0x0010 #color defined as 3 floats
+MAT_24BIT_COLOR = 0x0011 #color defined as 3 bytes
+
+#>------ sub defines of OBJECT
+OBJECT_MESH = 0x4100 # This lets us know that we are reading a new object
+OBJECT_LAMP = 0x4600 # This lets un know we are reading a light object
+OBJECT_LAMP_SPOT = 0x4610 # The light is a spotloght.
+OBJECT_LAMP_OFF = 0x4620 # The light off.
+OBJECT_LAMP_ATTENUATE = 0x4625
+OBJECT_LAMP_RAYSHADE = 0x4627
+OBJECT_LAMP_SHADOWED = 0x4630
+OBJECT_LAMP_LOCAL_SHADOW = 0x4640
+OBJECT_LAMP_LOCAL_SHADOW2 = 0x4641
+OBJECT_LAMP_SEE_CONE = 0x4650
+OBJECT_LAMP_SPOT_RECTANGULAR = 0x4651
+OBJECT_LAMP_SPOT_OVERSHOOT = 0x4652
+OBJECT_LAMP_SPOT_PROJECTOR = 0x4653
+OBJECT_LAMP_EXCLUDE = 0x4654
+OBJECT_LAMP_RANGE = 0x4655
+OBJECT_LAMP_ROLL = 0x4656
+OBJECT_LAMP_SPOT_ASPECT = 0x4657
+OBJECT_LAMP_RAY_BIAS = 0x4658
+OBJECT_LAMP_INNER_RANGE = 0x4659
+OBJECT_LAMP_OUTER_RANGE = 0x465A
+OBJECT_LAMP_MULTIPLIER = 0x465B
+OBJECT_LAMP_AMBIENT_LIGHT = 0x4680
+
+
+
+OBJECT_CAMERA= 0x4700 # This lets un know we are reading a camera object
+
+#>------ sub defines of CAMERA
+OBJECT_CAM_RANGES= 0x4720 # The camera range values
+
+#>------ sub defines of OBJECT_MESH
+OBJECT_VERTICES = 0x4110 # The objects vertices
+OBJECT_FACES = 0x4120 # The objects faces
+OBJECT_MATERIAL = 0x4130 # This is found if the object has a material, either texture map or color
+OBJECT_UV = 0x4140 # The UV texture coordinates
+OBJECT_TRANS_MATRIX = 0x4160 # The Object Matrix
+
+#>------ sub defines of EDITKEYFRAME
+# ED_KEY_AMBIENT_NODE = 0xB001
+ED_KEY_OBJECT_NODE = 0xB002
+# ED_KEY_CAMERA_NODE = 0xB003
+# ED_KEY_TARGET_NODE = 0xB004
+# ED_KEY_LIGHT_NODE = 0xB005
+# ED_KEY_L_TARGET_NODE = 0xB006
+# ED_KEY_SPOTLIGHT_NODE = 0xB007
+#>------ sub defines of ED_KEY_OBJECT_NODE
+# EK_OB_KEYFRAME_SEG = 0xB008
+# EK_OB_KEYFRAME_CURTIME = 0xB009
+# EK_OB_KEYFRAME_HEADER = 0xB00A
+EK_OB_NODE_HEADER = 0xB010
+EK_OB_INSTANCE_NAME = 0xB011
+# EK_OB_PRESCALE = 0xB012
+# EK_OB_PIVOT = 0xB013
+# EK_OB_BOUNDBOX = 0xB014
+# EK_OB_MORPH_SMOOTH = 0xB015
+EK_OB_POSITION_TRACK = 0xB020
+EK_OB_ROTATION_TRACK = 0xB021
+EK_OB_SCALE_TRACK = 0xB022
+# EK_OB_CAMERA_FOV_TRACK = 0xB023
+# EK_OB_CAMERA_ROLL_TRACK = 0xB024
+# EK_OB_COLOR_TRACK = 0xB025
+# EK_OB_MORPH_TRACK = 0xB026
+# EK_OB_HOTSPOT_TRACK = 0xB027
+# EK_OB_FALLOF_TRACK = 0xB028
+# EK_OB_HIDE_TRACK = 0xB029
+# EK_OB_NODE_ID = 0xB030
+
+ROOT_OBJECT = 0xFFFF
+
+global scn
+scn = None
+global object_dictionary # dictionary for object hierarchy
+object_dictionary = {}
+
+
+#the chunk class
+class chunk:
+ ID = 0
+ length = 0
+ bytes_read = 0
+
+ #we don't read in the bytes_read, we compute that
+ binary_format='<HI'
+
+ def __init__(self):
+ self.ID = 0
+ self.length = 0
+ self.bytes_read = 0
+
+ def dump(self):
+ print('ID: ', self.ID)
+ print('ID in hex: ', hex(self.ID))
+ print('length: ', self.length)
+ print('bytes_read: ', self.bytes_read)
+
+def read_chunk(file, chunk):
+ temp_data = file.read(struct.calcsize(chunk.binary_format))
+ data = struct.unpack(chunk.binary_format, temp_data)
+ chunk.ID = data[0]
+ chunk.length = data[1]
+ #update the bytes read function
+ chunk.bytes_read = 6
+
+ #if debugging
+ #chunk.dump()
+
+def read_string(file):
+ #read in the characters till we get a null character
+ s = b''
+ while True:
+ c = struct.unpack('<c', file.read(1))[0]
+ if c == b'\x00':
+ break
+ s += c
+ #print 'string: ',s
+
+ #remove the null character from the string
+# print("read string", s)
+ return str(s, "utf-8", "replace"), len(s) + 1
+
+######################################################
+# IMPORT
+######################################################
+def process_next_object_chunk(file, previous_chunk):
+ new_chunk = chunk()
+ temp_chunk = chunk()
+
+ while (previous_chunk.bytes_read < previous_chunk.length):
+ #read the next chunk
+ read_chunk(file, new_chunk)
+
+def skip_to_end(file, skip_chunk):
+ buffer_size = skip_chunk.length - skip_chunk.bytes_read
+ binary_format='%ic' % buffer_size
+ temp_data = file.read(struct.calcsize(binary_format))
+ skip_chunk.bytes_read += buffer_size
+
+
+def add_texture_to_material(image, texture, material, mapto):
+ #print('assigning %s to %s' % (texture, material))
+
+ if mapto not in ("COLOR", "SPECULARITY", "ALPHA", "NORMAL"):
+ print('/tError: Cannot map to "%s"\n\tassuming diffuse color. modify material "%s" later.' % (mapto, material.name))
+ mapto = "COLOR"
+
+ if image:
+ texture.image = image
+
+ mtex = material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_color_diffuse = False
+
+ if mapto == 'COLOR':
+ mtex.use_map_color_diffuse = True
+ elif mapto == 'SPECULARITY':
+ mtex.use_map_specular = True
+ elif mapto == 'ALPHA':
+ mtex.use_map_alpha = True
+ elif mapto == 'NORMAL':
+ mtex.use_map_normal = True
+
+
+def process_next_chunk(file, previous_chunk, importedObjects, IMAGE_SEARCH):
+ #print previous_chunk.bytes_read, 'BYTES READ'
+ contextObName = None
+ contextLamp = [None, None] # object, Data
+ contextMaterial = None
+ contextMatrix_rot = None # Blender.mathutils.Matrix(); contextMatrix.identity()
+ #contextMatrix_tx = None # Blender.mathutils.Matrix(); contextMatrix.identity()
+ contextMesh_vertls = None # flat array: (verts * 3)
+ contextMesh_facels = None
+ contextMeshMaterials = {} # matname:[face_idxs]
+ contextMeshUV = None # flat array (verts * 2)
+
+ TEXTURE_DICT = {}
+ MATDICT = {}
+# TEXMODE = Mesh.FaceModes['TEX']
+
+ # Localspace variable names, faster.
+ STRUCT_SIZE_1CHAR = struct.calcsize('c')
+ STRUCT_SIZE_2FLOAT = struct.calcsize('2f')
+ STRUCT_SIZE_3FLOAT = struct.calcsize('3f')
+ STRUCT_SIZE_4FLOAT = struct.calcsize('4f')
+ STRUCT_SIZE_UNSIGNED_SHORT = struct.calcsize('H')
+ STRUCT_SIZE_4UNSIGNED_SHORT = struct.calcsize('4H')
+ STRUCT_SIZE_4x3MAT = struct.calcsize('ffffffffffff')
+ _STRUCT_SIZE_4x3MAT = struct.calcsize('fffffffffffff')
+ # STRUCT_SIZE_4x3MAT = calcsize('ffffffffffff')
+ # print STRUCT_SIZE_4x3MAT, ' STRUCT_SIZE_4x3MAT'
+ # only init once
+ object_list = [] # for hierarchy
+ object_parent = [] # index of parent in hierarchy, 0xFFFF = no parent
+
+ def putContextMesh(myContextMesh_vertls, myContextMesh_facels, myContextMeshMaterials):
+ bmesh = bpy.data.meshes.new(contextObName)
+
+ if myContextMesh_facels is None:
+ myContextMesh_facels = []
+
+ if myContextMesh_vertls:
+
+ bmesh.vertices.add(len(myContextMesh_vertls)//3)
+ bmesh.faces.add(len(myContextMesh_facels))
+ bmesh.vertices.foreach_set("co", myContextMesh_vertls)
+
+ eekadoodle_faces = []
+ for v1, v2, v3 in myContextMesh_facels:
+ eekadoodle_faces.extend([v3, v1, v2, 0] if v3 == 0 else [v1, v2, v3, 0])
+ bmesh.faces.foreach_set("vertices_raw", eekadoodle_faces)
+
+ if bmesh.faces and contextMeshUV:
+ bmesh.uv_textures.new()
+ uv_faces = bmesh.uv_textures.active.data[:]
+ else:
+ uv_faces = None
+
+ for mat_idx, (matName, faces) in enumerate(myContextMeshMaterials.items()):
+ if matName is None:
+ bmat = None
+ else:
+ bmat = MATDICT[matName][1]
+ img = TEXTURE_DICT.get(bmat.name)
+
+ bmesh.materials.append(bmat) # can be None
+
+ if uv_faces and img:
+ for fidx in faces:
+ bmesh.faces[fidx].material_index = mat_idx
+ uf = uv_faces[fidx]
+ uf.image = img
+ uf.use_image = True
+ else:
+ for fidx in faces:
+ bmesh.faces[fidx].material_index = mat_idx
+
+ if uv_faces:
+ for fidx, uf in enumerate(uv_faces):
+ face = myContextMesh_facels[fidx]
+ v1, v2, v3 = face
+
+ # eekadoodle
+ if v3 == 0:
+ v1, v2, v3 = v3, v1, v2
+
+ uf.uv1 = contextMeshUV[v1 * 2:(v1 * 2) + 2]
+ uf.uv2 = contextMeshUV[v2 * 2:(v2 * 2) + 2]
+ uf.uv3 = contextMeshUV[v3 * 2:(v3 * 2) + 2]
+ # always a tri
+
+ ob = bpy.data.objects.new(contextObName, bmesh)
+ object_dictionary[contextObName] = ob
+ SCN.objects.link(ob)
+
+ '''
+ if contextMatrix_tx:
+ ob.setMatrix(contextMatrix_tx)
+ '''
+
+ if contextMatrix_rot:
+ ob.matrix_local = contextMatrix_rot
+
+ importedObjects.append(ob)
+ bmesh.update()
+
+ #a spare chunk
+ new_chunk = chunk()
+ temp_chunk = chunk()
+
+ CreateBlenderObject = False
+
+ def read_float_color(temp_chunk):
+ temp_data = file.read(struct.calcsize('3f'))
+ temp_chunk.bytes_read += 12
+ return [float(col) for col in struct.unpack('<3f', temp_data)]
+
+ def read_byte_color(temp_chunk):
+ temp_data = file.read(struct.calcsize('3B'))
+ temp_chunk.bytes_read += 3
+ return [float(col)/255 for col in struct.unpack('<3B', temp_data)] # data [0,1,2] == rgb
+
+ def read_texture(new_chunk, temp_chunk, name, mapto):
+ new_texture = bpy.data.textures.new(name, type='IMAGE')
+
+ img = None
+ while (new_chunk.bytes_read < new_chunk.length):
+ #print 'MAT_TEXTURE_MAP..while', new_chunk.bytes_read, new_chunk.length
+ read_chunk(file, temp_chunk)
+
+ if (temp_chunk.ID == MAT_MAP_FILEPATH):
+ texture_name, read_str_len = read_string(file)
+ img = TEXTURE_DICT[contextMaterial.name] = load_image(texture_name, dirname)
+ new_chunk.bytes_read += read_str_len #plus one for the null character that gets removed
+
+ else:
+ skip_to_end(file, temp_chunk)
+
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+ # add the map to the material in the right channel
+ if img:
+ add_texture_to_material(img, new_texture, contextMaterial, mapto)
+
+ dirname = os.path.dirname(file.name)
+
+ #loop through all the data for this chunk (previous chunk) and see what it is
+ while (previous_chunk.bytes_read < previous_chunk.length):
+ #print '\t', previous_chunk.bytes_read, 'keep going'
+ #read the next chunk
+ #print 'reading a chunk'
+ read_chunk(file, new_chunk)
+
+ #is it a Version chunk?
+ if (new_chunk.ID == VERSION):
+ #print 'if (new_chunk.ID == VERSION):'
+ #print 'found a VERSION chunk'
+ #read in the version of the file
+ #it's an unsigned short (H)
+ temp_data = file.read(struct.calcsize('I'))
+ version = struct.unpack('<I', temp_data)[0]
+ new_chunk.bytes_read += 4 #read the 4 bytes for the version number
+ #this loader works with version 3 and below, but may not with 4 and above
+ if (version > 3):
+ print('\tNon-Fatal Error: Version greater than 3, may not load correctly: ', version)
+
+ #is it an object info chunk?
+ elif (new_chunk.ID == OBJECTINFO):
+ #print 'elif (new_chunk.ID == OBJECTINFO):'
+ # print 'found an OBJECTINFO chunk'
+ process_next_chunk(file, new_chunk, importedObjects, IMAGE_SEARCH)
+
+ #keep track of how much we read in the main chunk
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+ #is it an object chunk?
+ elif (new_chunk.ID == OBJECT):
+
+ if CreateBlenderObject:
+ putContextMesh(contextMesh_vertls, contextMesh_facels, contextMeshMaterials)
+ contextMesh_vertls = []; contextMesh_facels = []
+
+ ## preparando para receber o proximo objeto
+ contextMeshMaterials = {} # matname:[face_idxs]
+ contextMeshUV = None
+ #contextMesh.vertexUV = 1 # Make sticky coords.
+ # Reset matrix
+ contextMatrix_rot = None
+ #contextMatrix_tx = None
+
+ CreateBlenderObject = True
+ contextObName, read_str_len = read_string(file)
+ new_chunk.bytes_read += read_str_len
+
+ #is it a material chunk?
+ elif (new_chunk.ID == MATERIAL):
+
+# print("read material")
+
+ #print 'elif (new_chunk.ID == MATERIAL):'
+ contextMaterial = bpy.data.materials.new('Material')
+
+ elif (new_chunk.ID == MAT_NAME):
+ #print 'elif (new_chunk.ID == MAT_NAME):'
+ material_name, read_str_len = read_string(file)
+
+# print("material name", material_name)
+
+ #plus one for the null character that ended the string
+ new_chunk.bytes_read += read_str_len
+
+ contextMaterial.name = material_name.rstrip() # remove trailing whitespace
+ MATDICT[material_name]= (contextMaterial.name, contextMaterial)
+
+ elif (new_chunk.ID == MAT_AMBIENT):
+ #print 'elif (new_chunk.ID == MAT_AMBIENT):'
+ read_chunk(file, temp_chunk)
+ if (temp_chunk.ID == MAT_FLOAT_COLOR):
+ contextMaterial.mirror_color = read_float_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3f'))
+# temp_chunk.bytes_read += 12
+# contextMaterial.mirCol = [float(col) for col in struct.unpack('<3f', temp_data)]
+ elif (temp_chunk.ID == MAT_24BIT_COLOR):
+ contextMaterial.mirror_color = read_byte_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3B'))
+# temp_chunk.bytes_read += 3
+# contextMaterial.mirCol = [float(col)/255 for col in struct.unpack('<3B', temp_data)] # data [0,1,2] == rgb
+ else:
+ skip_to_end(file, temp_chunk)
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+ elif (new_chunk.ID == MAT_DIFFUSE):
+ #print 'elif (new_chunk.ID == MAT_DIFFUSE):'
+ read_chunk(file, temp_chunk)
+ if (temp_chunk.ID == MAT_FLOAT_COLOR):
+ contextMaterial.diffuse_color = read_float_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3f'))
+# temp_chunk.bytes_read += 12
+# contextMaterial.rgbCol = [float(col) for col in struct.unpack('<3f', temp_data)]
+ elif (temp_chunk.ID == MAT_24BIT_COLOR):
+ contextMaterial.diffuse_color = read_byte_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3B'))
+# temp_chunk.bytes_read += 3
+# contextMaterial.rgbCol = [float(col)/255 for col in struct.unpack('<3B', temp_data)] # data [0,1,2] == rgb
+ else:
+ skip_to_end(file, temp_chunk)
+
+# print("read material diffuse color", contextMaterial.diffuse_color)
+
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+ elif (new_chunk.ID == MAT_SPECULAR):
+ #print 'elif (new_chunk.ID == MAT_SPECULAR):'
+ read_chunk(file, temp_chunk)
+ if (temp_chunk.ID == MAT_FLOAT_COLOR):
+ contextMaterial.specular_color = read_float_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3f'))
+# temp_chunk.bytes_read += 12
+# contextMaterial.mirCol = [float(col) for col in struct.unpack('<3f', temp_data)]
+ elif (temp_chunk.ID == MAT_24BIT_COLOR):
+ contextMaterial.specular_color = read_byte_color(temp_chunk)
+# temp_data = file.read(struct.calcsize('3B'))
+# temp_chunk.bytes_read += 3
+# contextMaterial.mirCol = [float(col)/255 for col in struct.unpack('<3B', temp_data)] # data [0,1,2] == rgb
+ else:
+ skip_to_end(file, temp_chunk)
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+ elif (new_chunk.ID == MAT_TEXTURE_MAP):
+ read_texture(new_chunk, temp_chunk, "Diffuse", "COLOR")
+
+ elif (new_chunk.ID == MAT_SPECULAR_MAP):
+ read_texture(new_chunk, temp_chunk, "Specular", "SPECULARITY")
+
+ elif (new_chunk.ID == MAT_OPACITY_MAP):
+ read_texture(new_chunk, temp_chunk, "Opacity", "ALPHA")
+
+ elif (new_chunk.ID == MAT_BUMP_MAP):
+ read_texture(new_chunk, temp_chunk, "Bump", "NORMAL")
+
+ elif (new_chunk.ID == MAT_TRANSPARENCY):
+ #print 'elif (new_chunk.ID == MAT_TRANSPARENCY):'
+ read_chunk(file, temp_chunk)
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+
+ temp_chunk.bytes_read += 2
+ contextMaterial.alpha = 1-(float(struct.unpack('<H', temp_data)[0])/100)
+ new_chunk.bytes_read += temp_chunk.bytes_read
+
+
+ elif (new_chunk.ID == OBJECT_LAMP): # Basic lamp support.
+
+ temp_data = file.read(STRUCT_SIZE_3FLOAT)
+
+ x,y,z = struct.unpack('<3f', temp_data)
+ new_chunk.bytes_read += STRUCT_SIZE_3FLOAT
+
+ # no lamp in dict that would be confusing
+ contextLamp[1] = bpy.data.lamps.new("Lamp", 'POINT')
+ contextLamp[0] = ob = bpy.data.objects.new("Lamp", contextLamp[1])
+
+ SCN.objects.link(ob)
+ importedObjects.append(contextLamp[0])
+
+ #print 'number of faces: ', num_faces
+ #print x,y,z
+ contextLamp[0].location = (x, y, z)
+# contextLamp[0].setLocation(x,y,z)
+
+ # Reset matrix
+ contextMatrix_rot = None
+ #contextMatrix_tx = None
+ #print contextLamp.name,
+
+ elif (new_chunk.ID == OBJECT_MESH):
+ # print 'Found an OBJECT_MESH chunk'
+ pass
+ elif (new_chunk.ID == OBJECT_VERTICES):
+ '''
+ Worldspace vertex locations
+ '''
+ # print 'elif (new_chunk.ID == OBJECT_VERTICES):'
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ num_verts = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += 2
+
+ # print 'number of verts: ', num_verts
+ contextMesh_vertls = struct.unpack('<%df' % (num_verts * 3), file.read(STRUCT_SIZE_3FLOAT * num_verts))
+ new_chunk.bytes_read += STRUCT_SIZE_3FLOAT * num_verts
+ # dummyvert is not used atm!
+
+ #print 'object verts: bytes read: ', new_chunk.bytes_read
+
+ elif (new_chunk.ID == OBJECT_FACES):
+ # print 'elif (new_chunk.ID == OBJECT_FACES):'
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ num_faces = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += 2
+ #print 'number of faces: ', num_faces
+
+ # print '\ngetting a face'
+ temp_data = file.read(STRUCT_SIZE_4UNSIGNED_SHORT * num_faces)
+ new_chunk.bytes_read += STRUCT_SIZE_4UNSIGNED_SHORT * num_faces #4 short ints x 2 bytes each
+ contextMesh_facels = struct.unpack('<%dH' % (num_faces * 4), temp_data)
+ contextMesh_facels = [contextMesh_facels[i - 3:i] for i in range(3, (num_faces * 4) + 3, 4)]
+
+ elif (new_chunk.ID == OBJECT_MATERIAL):
+ # print 'elif (new_chunk.ID == OBJECT_MATERIAL):'
+ material_name, read_str_len = read_string(file)
+ new_chunk.bytes_read += read_str_len # remove 1 null character.
+
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ num_faces_using_mat = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+
+
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * num_faces_using_mat)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * num_faces_using_mat
+
+ contextMeshMaterials[material_name]= struct.unpack("<%dH" % (num_faces_using_mat), temp_data)
+
+ #look up the material in all the materials
+
+ elif (new_chunk.ID == OBJECT_UV):
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ num_uv = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += 2
+
+ temp_data = file.read(STRUCT_SIZE_2FLOAT * num_uv)
+ new_chunk.bytes_read += STRUCT_SIZE_2FLOAT * num_uv
+ contextMeshUV = struct.unpack('<%df' % (num_uv * 2), temp_data)
+
+ elif (new_chunk.ID == OBJECT_TRANS_MATRIX):
+ # How do we know the matrix size? 54 == 4x4 48 == 4x3
+ temp_data = file.read(STRUCT_SIZE_4x3MAT)
+ data = list( struct.unpack('<ffffffffffff', temp_data) )
+ new_chunk.bytes_read += STRUCT_SIZE_4x3MAT
+
+ contextMatrix_rot = mathutils.Matrix((data[:3] + [0], \
+ data[3:6] + [0], \
+ data[6:9] + [0], \
+ data[9:] + [1], \
+ ))
+
+ elif (new_chunk.ID == MAT_MAP_FILEPATH):
+ texture_name, read_str_len = read_string(file)
+ try:
+ TEXTURE_DICT[contextMaterial.name]
+ except:
+ #img = TEXTURE_DICT[contextMaterial.name]= BPyImage.comprehensiveImageLoad(texture_name, FILEPATH)
+ img = TEXTURE_DICT[contextMaterial.name] = load_image(texture_name, dirname)
+# img = TEXTURE_DICT[contextMaterial.name]= BPyImage.comprehensiveImageLoad(texture_name, FILEPATH, PLACE_HOLDER=False, RECURSIVE=IMAGE_SEARCH)
+
+ new_chunk.bytes_read += read_str_len #plus one for the null character that gets removed
+ elif new_chunk.ID == EDITKEYFRAME:
+ pass
+
+ elif new_chunk.ID == ED_KEY_OBJECT_NODE: #another object is being processed
+ child = None
+
+ elif new_chunk.ID == EK_OB_NODE_HEADER:
+ object_name, read_str_len = read_string(file)
+ new_chunk.bytes_read += read_str_len
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 2)
+ new_chunk.bytes_read += 4
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ hierarchy = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += 2
+
+ child = object_dictionary.get(object_name)
+
+ if child is None:
+ child = bpy.data.objects.new(object_name, None) # create an empty object
+ SCN.objects.link(child)
+
+ object_list.append(child)
+ object_parent.append(hierarchy)
+
+ elif new_chunk.ID == EK_OB_INSTANCE_NAME:
+ object_name, read_str_len = read_string(file)
+ child.name = object_name
+ object_dictionary[object_name] = child
+ new_chunk.bytes_read += read_str_len
+
+ elif new_chunk.ID == EK_OB_POSITION_TRACK: # translation
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 5
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 5)
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nkeys = struct.unpack('<H', temp_data)[0]
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ for i in range(nkeys):
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nframe = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 2)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ temp_data = file.read(STRUCT_SIZE_3FLOAT)
+ loc = struct.unpack('<3f', temp_data)
+ new_chunk.bytes_read += STRUCT_SIZE_3FLOAT
+ if nframe == 0:
+ child.location = loc
+
+ elif new_chunk.ID == EK_OB_ROTATION_TRACK: # rotation
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 5
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 5)
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nkeys = struct.unpack('<H', temp_data)[0]
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ for i in range(nkeys):
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nframe = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 2)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ temp_data = file.read(STRUCT_SIZE_4FLOAT)
+ rad,axis_x,axis_y,axis_z = struct.unpack('<4f', temp_data)
+ new_chunk.bytes_read += STRUCT_SIZE_4FLOAT
+ if nframe == 0:
+ child.rotation_euler = mathutils.Quaternion((axis_x, axis_y, axis_z), -rad).to_euler() # why negative?
+
+ elif new_chunk.ID == EK_OB_SCALE_TRACK: # translation
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 5
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 5)
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nkeys = struct.unpack('<H', temp_data)[0]
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ for i in range(nkeys):
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+ nframe = struct.unpack('<H', temp_data)[0]
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+ temp_data = file.read(STRUCT_SIZE_UNSIGNED_SHORT * 2)
+ new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT * 2
+ temp_data = file.read(STRUCT_SIZE_3FLOAT)
+ sca = struct.unpack('<3f', temp_data)
+ new_chunk.bytes_read += STRUCT_SIZE_3FLOAT
+ if nframe == 0:
+ child.scale = sca
+
+ else: #(new_chunk.ID!=VERSION or new_chunk.ID!=OBJECTINFO or new_chunk.ID!=OBJECT or new_chunk.ID!=MATERIAL):
+ # print 'skipping to end of this chunk'
+ #print("unknown chunk: "+hex(new_chunk.ID))
+ buffer_size = new_chunk.length - new_chunk.bytes_read
+ binary_format='%ic' % buffer_size
+ temp_data = file.read(struct.calcsize(binary_format))
+ new_chunk.bytes_read += buffer_size
+
+
+ #update the previous chunk bytes read
+ # print 'previous_chunk.bytes_read += new_chunk.bytes_read'
+ # print previous_chunk.bytes_read, new_chunk.bytes_read
+ previous_chunk.bytes_read += new_chunk.bytes_read
+ ## print 'Bytes left in this chunk: ', previous_chunk.length - previous_chunk.bytes_read
+
+ # FINISHED LOOP
+ # There will be a number of objects still not added
+ if CreateBlenderObject:
+ putContextMesh(contextMesh_vertls, contextMesh_facels, contextMeshMaterials)
+
+
+ # Assign parents to objects
+ for ind, ob in enumerate(object_list):
+ parent = object_parent[ind]
+ if parent == ROOT_OBJECT:
+ ob.parent = None
+ else:
+ ob.parent = object_list[parent]
+
+
+def load_3ds(filepath, context, IMPORT_CONSTRAIN_BOUNDS=10.0, IMAGE_SEARCH=True, APPLY_MATRIX=True):
+ global SCN
+
+ # XXX
+# if BPyMessages.Error_NoFile(filepath):
+# return
+
+ print("importing 3DS: %r..." % (filepath), end="")
+
+ time1 = time.clock()
+# time1 = Blender.sys.time()
+
+ current_chunk = chunk()
+
+ file = open(filepath, 'rb')
+
+ #here we go!
+ # print 'reading the first chunk'
+ read_chunk(file, current_chunk)
+ if (current_chunk.ID!=PRIMARY):
+ print('\tFatal Error: Not a valid 3ds file: %r' % filepath)
+ file.close()
+ return
+
+
+ # IMPORT_AS_INSTANCE = Blender.Draw.Create(0)
+# IMPORT_CONSTRAIN_BOUNDS = Blender.Draw.Create(10.0)
+# IMAGE_SEARCH = Blender.Draw.Create(1)
+# APPLY_MATRIX = Blender.Draw.Create(0)
+
+ # Get USER Options
+# pup_block = [\
+# ('Size Constraint:', IMPORT_CONSTRAIN_BOUNDS, 0.0, 1000.0, 'Scale the model by 10 until it reacehs the size constraint. Zero Disables.'),\
+# ('Image Search', IMAGE_SEARCH, 'Search subdirs for any assosiated images (Warning, may be slow)'),\
+# ('Transform Fix', APPLY_MATRIX, 'Workaround for object transformations importing incorrectly'),\
+# #('Group Instance', IMPORT_AS_INSTANCE, 'Import objects into a new scene and group, creating an instance in the current scene.'),\
+# ]
+
+# if PREF_UI:
+# if not Blender.Draw.PupBlock('Import 3DS...', pup_block):
+# return
+
+# Blender.Window.WaitCursor(1)
+
+# IMPORT_CONSTRAIN_BOUNDS = IMPORT_CONSTRAIN_BOUNDS.val
+# # IMPORT_AS_INSTANCE = IMPORT_AS_INSTANCE.val
+# IMAGE_SEARCH = IMAGE_SEARCH.val
+# APPLY_MATRIX = APPLY_MATRIX.val
+
+ if IMPORT_CONSTRAIN_BOUNDS:
+ BOUNDS_3DS[:]= [1<<30, 1<<30, 1<<30, -1<<30, -1<<30, -1<<30]
+ else:
+ BOUNDS_3DS[:]= []
+
+ ##IMAGE_SEARCH
+
+ # fixme, make unglobal, clear incase
+ object_dictionary.clear()
+
+ scn = context.scene
+# scn = bpy.data.scenes.active
+ SCN = scn
+# SCN_OBJECTS = scn.objects
+# SCN_OBJECTS.selected = [] # de select all
+
+ importedObjects = [] # Fill this list with objects
+ process_next_chunk(file, current_chunk, importedObjects, IMAGE_SEARCH)
+
+ # fixme, make unglobal
+ object_dictionary.clear()
+
+ # Link the objects into this scene.
+ # Layers = scn.Layers
+
+ # REMOVE DUMMYVERT, - remove this in the next release when blenders internal are fixed.
+
+ if APPLY_MATRIX:
+ for ob in importedObjects:
+ if ob.type == 'MESH':
+ me = ob.data
+ me.transform(ob.matrix_local.copy().invert())
+
+ # Done DUMMYVERT
+ """
+ if IMPORT_AS_INSTANCE:
+ name = filepath.split('\\')[-1].split('/')[-1]
+ # Create a group for this import.
+ group_scn = Scene.New(name)
+ for ob in importedObjects:
+ group_scn.link(ob) # dont worry about the layers
+
+ grp = Blender.Group.New(name)
+ grp.objects = importedObjects
+
+ grp_ob = Object.New('Empty', name)
+ grp_ob.enableDupGroup = True
+ grp_ob.DupGroup = grp
+ scn.link(grp_ob)
+ grp_ob.Layers = Layers
+ grp_ob.sel = 1
+ else:
+ # Select all imported objects.
+ for ob in importedObjects:
+ scn.link(ob)
+ ob.Layers = Layers
+ ob.sel = 1
+ """
+
+ if 0:
+# if IMPORT_CONSTRAIN_BOUNDS!=0.0:
+ # Set bounds from objecyt bounding box
+ for ob in importedObjects:
+ if ob.type == 'MESH':
+# if ob.type=='Mesh':
+ ob.makeDisplayList() # Why dosnt this update the bounds?
+ for v in ob.getBoundBox():
+ for i in (0,1,2):
+ if v[i] < BOUNDS_3DS[i]:
+ BOUNDS_3DS[i]= v[i] # min
+
+ if v[i] > BOUNDS_3DS[i + 3]:
+ BOUNDS_3DS[i + 3]= v[i] # min
+
+ # Get the max axis x/y/z
+ max_axis = max(BOUNDS_3DS[3]-BOUNDS_3DS[0], BOUNDS_3DS[4]-BOUNDS_3DS[1], BOUNDS_3DS[5]-BOUNDS_3DS[2])
+ # print max_axis
+ if max_axis < 1 << 30: # Should never be false but just make sure.
+
+ # Get a new scale factor if set as an option
+ SCALE = 1.0
+ while (max_axis * SCALE) > IMPORT_CONSTRAIN_BOUNDS:
+ SCALE/=10
+
+ # SCALE Matrix
+ SCALE_MAT = mathutils.Matrix.Scale(SCALE, 4)
+
+ for ob in importedObjects:
+ if ob.parent is None:
+ ob.matrix_world = ob.matrix_world * SCALE_MAT
+
+ # Done constraining to bounds.
+
+ # Select all new objects.
+ print(" done in %.4f sec." % (time.clock()-time1))
+ file.close()
+
+
+def load(operator, context, filepath="", constrain_size=0.0, use_image_search=True, use_apply_transform=True):
+ load_3ds(filepath, context, IMPORT_CONSTRAIN_BOUNDS=constrain_size, IMAGE_SEARCH=use_image_search, APPLY_MATRIX=use_apply_transform)
+ return {'FINISHED'}
diff --git a/io_scene_fbx/__init__.py b/io_scene_fbx/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0544e44239b7b7ab27aad7ced7e759a8028bce5
--- /dev/null
+++ b/io_scene_fbx/__init__.py
@@ -0,0 +1,121 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "Autodesk FBX format",
+ "author": "Campbell Barton",
+ "location": "File > Import-Export",
+ "description": "Import-Export FBX meshes, UV's, vertex colors, materials, textures, cameras and lamps",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/Autodesk_FBX",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "export_fbx" in locals():
+ imp.reload(export_fbx)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ExportHelper
+
+
+class ExportFBX(bpy.types.Operator, ExportHelper):
+ '''Selection to an ASCII Autodesk FBX'''
+ bl_idname = "export_scene.fbx"
+ bl_label = "Export FBX"
+ bl_options = {'PRESET'}
+
+ filename_ext = ".fbx"
+ filter_glob = StringProperty(default="*.fbx", options={'HIDDEN'})
+
+ # List of operator properties, the attributes will be assigned
+ # to the class instance from the operator settings before calling.
+
+ EXP_OBS_SELECTED = BoolProperty(name="Selected Objects", description="Export selected objects on visible layers", default=True)
+# EXP_OBS_SCENE = BoolProperty(name="Scene Objects", description="Export all objects in this scene", default=True)
+ TX_SCALE = FloatProperty(name="Scale", description="Scale all data, (Note! some imports dont support scaled armatures)", min=0.01, max=1000.0, soft_min=0.01, soft_max=1000.0, default=1.0)
+ TX_XROT90 = BoolProperty(name="Rot X90", description="Rotate all objects 90 degrees about the X axis", default=True)
+ TX_YROT90 = BoolProperty(name="Rot Y90", description="Rotate all objects 90 degrees about the Y axis", default=False)
+ TX_ZROT90 = BoolProperty(name="Rot Z90", description="Rotate all objects 90 degrees about the Z axis", default=False)
+ EXP_EMPTY = BoolProperty(name="Empties", description="Export empty objects", default=True)
+ EXP_CAMERA = BoolProperty(name="Cameras", description="Export camera objects", default=True)
+ EXP_LAMP = BoolProperty(name="Lamps", description="Export lamp objects", default=True)
+ EXP_ARMATURE = BoolProperty(name="Armatures", description="Export armature objects", default=True)
+ EXP_MESH = BoolProperty(name="Meshes", description="Export mesh objects", default=True)
+ EXP_MESH_APPLY_MOD = BoolProperty(name="Modifiers", description="Apply modifiers to mesh objects", default=True)
+# EXP_MESH_HQ_NORMALS = BoolProperty(name="HQ Normals", description="Generate high quality normals", default=True)
+ EXP_IMAGE_COPY = BoolProperty(name="Copy Image Files", description="Copy image files to the destination path", default=False)
+ # armature animation
+ ANIM_ENABLE = BoolProperty(name="Enable Animation", description="Export keyframe animation", default=True)
+ ANIM_OPTIMIZE = BoolProperty(name="Optimize Keyframes", description="Remove double keyframes", default=True)
+ ANIM_OPTIMIZE_PRECISSION = FloatProperty(name="Precision", description="Tolerence for comparing double keyframes (higher for greater accuracy)", min=1, max=16, soft_min=1, soft_max=16, default=6.0)
+# ANIM_ACTION_ALL = BoolProperty(name="Current Action", description="Use actions currently applied to the armatures (use scene start/end frame)", default=True)
+ ANIM_ACTION_ALL = BoolProperty(name="All Actions", description="Use all actions for armatures, if false, use current action", default=False)
+ # batch
+ BATCH_ENABLE = BoolProperty(name="Enable Batch", description="Automate exporting multiple scenes or groups to files", default=False)
+ BATCH_GROUP = BoolProperty(name="Group > File", description="Export each group as an FBX file, if false, export each scene as an FBX file", default=False)
+ BATCH_OWN_DIR = BoolProperty(name="Own Dir", description="Create a dir for each exported file", default=True)
+ BATCH_FILE_PREFIX = StringProperty(name="Prefix", description="Prefix each file with this name", maxlen=1024, default="")
+
+ def execute(self, context):
+ import math
+ from mathutils import Matrix
+ if not self.filepath:
+ raise Exception("filepath not set")
+
+ mtx4_x90n = Matrix.Rotation(-math.pi / 2.0, 4, 'X')
+ mtx4_y90n = Matrix.Rotation(-math.pi / 2.0, 4, 'Y')
+ mtx4_z90n = Matrix.Rotation(-math.pi / 2.0, 4, 'Z')
+
+ GLOBAL_MATRIX = Matrix()
+ GLOBAL_MATRIX[0][0] = GLOBAL_MATRIX[1][1] = GLOBAL_MATRIX[2][2] = self.TX_SCALE
+ if self.TX_XROT90:
+ GLOBAL_MATRIX = mtx4_x90n * GLOBAL_MATRIX
+ if self.TX_YROT90:
+ GLOBAL_MATRIX = mtx4_y90n * GLOBAL_MATRIX
+ if self.TX_ZROT90:
+ GLOBAL_MATRIX = mtx4_z90n * GLOBAL_MATRIX
+
+ keywords = self.as_keywords(ignore=("TX_XROT90", "TX_YROT90", "TX_ZROT90", "TX_SCALE", "check_existing", "filter_glob"))
+ keywords["GLOBAL_MATRIX"] = GLOBAL_MATRIX
+
+ import io_scene_fbx.export_fbx
+ return io_scene_fbx.export_fbx.save(self, context, **keywords)
+
+
+def menu_func(self, context):
+ self.layout.operator(ExportFBX.bl_idname, text="Autodesk FBX (.fbx)")
+
+
+def register():
+ bpy.types.INFO_MT_file_export.append(menu_func)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_export.remove(menu_func)
+
+if __name__ == "__main__":
+ register()
diff --git a/io_scene_fbx/export_fbx.py b/io_scene_fbx/export_fbx.py
new file mode 100644
index 0000000000000000000000000000000000000000..40cac6ddb4dac72409f145e5db8a6c450f060225
--- /dev/null
+++ b/io_scene_fbx/export_fbx.py
@@ -0,0 +1,2910 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Campbell Barton
+
+"""
+This script is an exporter to the FBX file format.
+
+http://wiki.blender.org/index.php/Scripts/Manual/Export/autodesk_fbx
+"""
+
+import os
+import time
+import math # math.pi
+import shutil # for file copying
+
+import bpy
+from mathutils import Vector, Euler, Matrix
+
+
+# XXX not used anymore, images are copied one at a time
+def copy_images(dest_dir, textures):
+ import shutil
+
+ if not dest_dir.endswith(os.sep):
+ dest_dir += os.sep
+
+ image_paths = set()
+ for tex in textures:
+ image_paths.add(bpy.path.abspath(tex.filepath))
+
+ # Now copy images
+ copyCount = 0
+ for image_path in image_paths:
+ if Blender.sys.exists(image_path):
+ # Make a name for the target path.
+ dest_image_path = dest_dir + image_path.split('\\')[-1].split('/')[-1]
+ if not Blender.sys.exists(dest_image_path): # Image isnt already there
+ print("\tCopying %r > %r" % (image_path, dest_image_path))
+ try:
+ shutil.copy(image_path, dest_image_path)
+ copyCount += 1
+ except:
+ print("\t\tWarning, file failed to copy, skipping.")
+
+ print('\tCopied %d images' % copyCount)
+
+
+# I guess FBX uses degrees instead of radians (Arystan).
+# Call this function just before writing to FBX.
+# 180 / math.pi == 57.295779513
+def tuple_rad_to_deg(eul):
+ return eul[0] * 57.295779513, eul[1] * 57.295779513, eul[2] * 57.295779513
+
+# def strip_path(p):
+# return p.split('\\')[-1].split('/')[-1]
+
+# Used to add the scene name into the filepath without using odd chars
+sane_name_mapping_ob = {}
+sane_name_mapping_mat = {}
+sane_name_mapping_tex = {}
+sane_name_mapping_take = {}
+sane_name_mapping_group = {}
+
+# Make sure reserved names are not used
+sane_name_mapping_ob['Scene'] = 'Scene_'
+sane_name_mapping_ob['blend_root'] = 'blend_root_'
+
+
+def increment_string(t):
+ name = t
+ num = ''
+ while name and name[-1].isdigit():
+ num = name[-1] + num
+ name = name[:-1]
+ if num:
+ return '%s%d' % (name, int(num) + 1)
+ else:
+ return name + '_0'
+
+
+# todo - Disallow the name 'Scene' and 'blend_root' - it will bugger things up.
+def sane_name(data, dct):
+ #if not data: return None
+
+ if type(data) == tuple: # materials are paired up with images
+ data, other = data
+ use_other = True
+ else:
+ other = None
+ use_other = False
+
+ name = data.name if data else None
+ orig_name = name
+
+ if other:
+ orig_name_other = other.name
+ name = '%s #%s' % (name, orig_name_other)
+ else:
+ orig_name_other = None
+
+ # dont cache, only ever call once for each data type now,
+ # so as to avoid namespace collision between types - like with objects <-> bones
+ #try: return dct[name]
+ #except: pass
+
+ if not name:
+ name = 'unnamed' # blank string, ASKING FOR TROUBLE!
+ else:
+
+ name = bpy.path.clean_name(name) # use our own
+
+ while name in iter(dct.values()):
+ name = increment_string(name)
+
+ if use_other: # even if other is None - orig_name_other will be a string or None
+ dct[orig_name, orig_name_other] = name
+ else:
+ dct[orig_name] = name
+
+ return name
+
+
+def sane_obname(data):
+ return sane_name(data, sane_name_mapping_ob)
+
+
+def sane_matname(data):
+ return sane_name(data, sane_name_mapping_mat)
+
+
+def sane_texname(data):
+ return sane_name(data, sane_name_mapping_tex)
+
+
+def sane_takename(data):
+ return sane_name(data, sane_name_mapping_take)
+
+
+def sane_groupname(data):
+ return sane_name(data, sane_name_mapping_group)
+
+# def derived_paths(fname_orig, basepath, FORCE_CWD=False):
+# '''
+# fname_orig - blender path, can be relative
+# basepath - fname_rel will be relative to this
+# FORCE_CWD - dont use the basepath, just add a ./ to the filepath.
+# use when we know the file will be in the basepath.
+# '''
+# fname = bpy.path.abspath(fname_orig)
+# # fname = Blender.sys.expandpath(fname_orig)
+# fname_strip = os.path.basename(fname)
+# # fname_strip = strip_path(fname)
+# if FORCE_CWD:
+# fname_rel = '.' + os.sep + fname_strip
+# else:
+# fname_rel = bpy.path.relpath(fname, basepath)
+# # fname_rel = Blender.sys.relpath(fname, basepath)
+# if fname_rel.startswith('//'): fname_rel = '.' + os.sep + fname_rel[2:]
+# return fname, fname_strip, fname_rel
+
+
+def mat4x4str(mat):
+ return '%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f,%.15f' % tuple([f for v in mat for f in v])
+
+
+# XXX not used
+# duplicated in OBJ exporter
+def getVertsFromGroup(me, group_index):
+ ret = []
+
+ for i, v in enumerate(me.vertices):
+ for g in v.groups:
+ if g.group == group_index:
+ ret.append((i, g.weight))
+
+ return ret
+
+
+# ob must be OB_MESH
+def BPyMesh_meshWeight2List(ob, me):
+ ''' Takes a mesh and return its group names and a list of lists, one list per vertex.
+ aligning the each vert list with the group names, each list contains float value for the weight.
+ These 2 lists can be modified and then used with list2MeshWeight to apply the changes.
+ '''
+
+ # Clear the vert group.
+ groupNames = [g.name for g in ob.vertex_groups]
+ len_groupNames = len(groupNames)
+
+ if not len_groupNames:
+ # no verts? return a vert aligned empty list
+ return [[] for i in range(len(me.vertices))], []
+ else:
+ vWeightList = [[0.0] * len_groupNames for i in range(len(me.vertices))]
+
+ for i, v in enumerate(me.vertices):
+ for g in v.groups:
+ vWeightList[i][g.group] = g.weight
+
+ return groupNames, vWeightList
+
+
+def meshNormalizedWeights(ob, me):
+ try: # account for old bad BPyMesh
+ groupNames, vWeightList = BPyMesh_meshWeight2List(ob, me)
+ except:
+ return [], []
+
+ if not groupNames:
+ return [], []
+
+ for i, vWeights in enumerate(vWeightList):
+ tot = 0.0
+ for w in vWeights:
+ tot += w
+
+ if tot:
+ for j, w in enumerate(vWeights):
+ vWeights[j] = w / tot
+
+ return groupNames, vWeightList
+
+header_comment = \
+'''; FBX 6.1.0 project file
+; Created by Blender FBX Exporter
+; for support mail: ideasman42@gmail.com
+; ----------------------------------------------------
+
+'''
+
+
+# This func can be called with just the filepath
+def save(operator, context, filepath="",
+ GLOBAL_MATRIX=None,
+ EXP_OBS_SELECTED=True,
+ EXP_MESH=True,
+ EXP_MESH_APPLY_MOD=True,
+ EXP_ARMATURE=True,
+ EXP_LAMP=True,
+ EXP_CAMERA=True,
+ EXP_EMPTY=True,
+ EXP_IMAGE_COPY=False,
+ ANIM_ENABLE=True,
+ ANIM_OPTIMIZE=True,
+ ANIM_OPTIMIZE_PRECISSION=6,
+ ANIM_ACTION_ALL=False,
+ BATCH_ENABLE=False,
+ BATCH_GROUP=True,
+ BATCH_FILE_PREFIX='',
+ BATCH_OWN_DIR=False
+ ):
+
+ #XXX, missing arg
+ batch_objects = None
+
+ # testing
+ mtx_x90 = Matrix.Rotation(math.pi / 2.0, 3, 'X') # used
+ mtx4_z90 = Matrix.Rotation(math.pi / 2.0, 4, 'Z')
+
+ if GLOBAL_MATRIX is None:
+ GLOBAL_MATRIX = Matrix()
+
+ if bpy.ops.object.mode_set.poll():
+ bpy.ops.object.mode_set(mode='OBJECT')
+
+ # ----------------- Batch support!
+ if BATCH_ENABLE:
+ fbxpath = filepath
+
+ # get the path component of filepath
+ tmp_exists = bpy.utils.exists(fbxpath)
+
+ if tmp_exists != 2: # a file, we want a path
+ fbxpath = os.path.dirname(fbxpath)
+# while fbxpath and fbxpath[-1] not in ('/', '\\'):
+# fbxpath = fbxpath[:-1]
+ if not fbxpath:
+ # XXX
+ print('Error%t|Directory does not exist!')
+# Draw.PupMenu('Error%t|Directory does not exist!')
+ return
+
+ tmp_exists = bpy.utils.exists(fbxpath)
+
+ if tmp_exists != 2:
+ # XXX
+ print('Error%t|Directory does not exist!')
+# Draw.PupMenu('Error%t|Directory does not exist!')
+ return
+
+ if not fbxpath.endswith(os.sep):
+ fbxpath += os.sep
+ del tmp_exists
+
+ if BATCH_GROUP:
+ data_seq = bpy.data.groups
+ else:
+ data_seq = bpy.data.scenes
+
+ # call this function within a loop with BATCH_ENABLE == False
+ orig_sce = context.scene
+
+ new_fbxpath = fbxpath # own dir option modifies, we need to keep an original
+ for data in data_seq: # scene or group
+ newname = BATCH_FILE_PREFIX + bpy.path.clean_name(data.name)
+
+ if BATCH_OWN_DIR:
+ new_fbxpath = fbxpath + newname + os.sep
+ # path may already exist
+ # TODO - might exist but be a file. unlikely but should probably account for it.
+
+ if bpy.utils.exists(new_fbxpath) == 0:
+# if Blender.sys.exists(new_fbxpath) == 0:
+ os.mkdir(new_fbxpath)
+
+ filepath = new_fbxpath + newname + '.fbx'
+
+ print('\nBatch exporting %s as...\n\t%r' % (data, filepath))
+
+ # XXX don't know what to do with this, probably do the same? (Arystan)
+ if BATCH_GROUP: # group
+ # group, so objects update properly, add a dummy scene.
+ scene = bpy.data.scenes.new()
+ scene.Layers = (1 << 20) - 1
+ bpy.data.scenes.active = scene
+ for ob_base in data.objects:
+ scene.objects.link(ob_base)
+
+ scene.update(1)
+
+ # TODO - BUMMER! Armatures not in the group wont animate the mesh
+
+ else: # scene
+ data_seq.active = data
+
+ # Call self with modified args
+ # Dont pass batch options since we already usedt them
+ write(filepath, data.objects,
+ context,
+ False,
+ EXP_MESH,
+ EXP_MESH_APPLY_MOD,
+ EXP_ARMATURE,
+ EXP_LAMP,
+ EXP_CAMERA,
+ EXP_EMPTY,
+ EXP_IMAGE_COPY,
+ GLOBAL_MATRIX,
+ ANIM_ENABLE,
+ ANIM_OPTIMIZE,
+ ANIM_OPTIMIZE_PRECISSION,
+ ANIM_ACTION_ALL
+ )
+
+ if BATCH_GROUP:
+ # remove temp group scene
+ bpy.data.scenes.unlink(scene)
+
+ bpy.data.scenes.active = orig_sce
+
+ return # so the script wont run after we have batch exported.
+
+ # end batch support
+
+ # Use this for working out paths relative to the export location
+ basepath = os.path.dirname(filepath) or '.'
+ basepath += os.sep
+# basepath = Blender.sys.dirname(filepath)
+
+ # ----------------------------------------------
+ # storage classes
+ class my_bone_class(object):
+ __slots__ = ("blenName",
+ "blenBone",
+ "blenMeshes",
+ "restMatrix",
+ "parent",
+ "blenName",
+ "fbxName",
+ "fbxArm",
+ "__pose_bone",
+ "__anim_poselist")
+
+ def __init__(self, blenBone, fbxArm):
+
+ # This is so 2 armatures dont have naming conflicts since FBX bones use object namespace
+ self.fbxName = sane_obname(blenBone)
+
+ self.blenName = blenBone.name
+ self.blenBone = blenBone
+ self.blenMeshes = {} # fbxMeshObName : mesh
+ self.fbxArm = fbxArm
+ self.restMatrix = blenBone.matrix_local
+# self.restMatrix = blenBone.matrix['ARMATURESPACE']
+
+ # not used yet
+ # self.restMatrixInv = self.restMatrix.copy().invert()
+ # self.restMatrixLocal = None # set later, need parent matrix
+
+ self.parent = None
+
+ # not public
+ pose = fbxArm.blenObject.pose
+ self.__pose_bone = pose.bones[self.blenName]
+
+ # store a list if matricies here, (poseMatrix, head, tail)
+ # {frame:posematrix, frame:posematrix, ...}
+ self.__anim_poselist = {}
+
+ '''
+ def calcRestMatrixLocal(self):
+ if self.parent:
+ self.restMatrixLocal = self.restMatrix * self.parent.restMatrix.copy().invert()
+ else:
+ self.restMatrixLocal = self.restMatrix.copy()
+ '''
+ def setPoseFrame(self, f):
+ # cache pose info here, frame must be set beforehand
+
+ # Didnt end up needing head or tail, if we do - here it is.
+ '''
+ self.__anim_poselist[f] = (\
+ self.__pose_bone.poseMatrix.copy(),\
+ self.__pose_bone.head.copy(),\
+ self.__pose_bone.tail.copy() )
+ '''
+
+ self.__anim_poselist[f] = self.__pose_bone.matrix.copy()
+
+ # get pose from frame.
+ def getPoseMatrix(self, f): # ----------------------------------------------
+ return self.__anim_poselist[f]
+ '''
+ def getPoseHead(self, f):
+ #return self.__pose_bone.head.copy()
+ return self.__anim_poselist[f][1].copy()
+ def getPoseTail(self, f):
+ #return self.__pose_bone.tail.copy()
+ return self.__anim_poselist[f][2].copy()
+ '''
+ # end
+
+ def getAnimParRelMatrix(self, frame):
+ #arm_mat = self.fbxArm.matrixWorld
+ #arm_mat = self.fbxArm.parRelMatrix()
+ if not self.parent:
+ #return mtx4_z90 * (self.getPoseMatrix(frame) * arm_mat) # dont apply arm matrix anymore
+ return self.getPoseMatrix(frame) * mtx4_z90
+ else:
+ #return (mtx4_z90 * ((self.getPoseMatrix(frame) * arm_mat))) * (mtx4_z90 * (self.parent.getPoseMatrix(frame) * arm_mat)).invert()
+ return (self.parent.getPoseMatrix(frame) * mtx4_z90).invert() * ((self.getPoseMatrix(frame)) * mtx4_z90)
+
+ # we need thes because cameras and lights modified rotations
+ def getAnimParRelMatrixRot(self, frame):
+ return self.getAnimParRelMatrix(frame)
+
+ def flushAnimData(self):
+ self.__anim_poselist.clear()
+
+ class my_object_generic(object):
+ __slots__ = ("fbxName",
+ "blenObject",
+ "blenData",
+ "origData",
+ "blenTextures",
+ "blenMaterials",
+ "blenMaterialList",
+ "blenAction",
+ "blenActionList",
+ "fbxGroupNames",
+ "fbxParent",
+ "fbxBoneParent",
+ "fbxBones",
+ "fbxArm",
+ "matrixWorld",
+ "__anim_poselist",
+ )
+
+ # Other settings can be applied for each type - mesh, armature etc.
+ def __init__(self, ob, matrixWorld=None):
+ self.fbxName = sane_obname(ob)
+ self.blenObject = ob
+ self.fbxGroupNames = []
+ self.fbxParent = None # set later on IF the parent is in the selection.
+ if matrixWorld:
+ self.matrixWorld = GLOBAL_MATRIX * matrixWorld
+ else:
+ self.matrixWorld = GLOBAL_MATRIX * ob.matrix_world
+
+ self.__anim_poselist = {} # we should only access this
+
+ def parRelMatrix(self):
+ if self.fbxParent:
+ return self.fbxParent.matrixWorld.copy().invert() * self.matrixWorld
+ else:
+ return self.matrixWorld
+
+ def setPoseFrame(self, f, fake=False):
+ if fake:
+ # annoying, have to clear GLOBAL_MATRIX
+ self.__anim_poselist[f] = self.matrixWorld * GLOBAL_MATRIX.copy().invert()
+ else:
+ self.__anim_poselist[f] = self.blenObject.matrix_world.copy()
+
+ def getAnimParRelMatrix(self, frame):
+ if self.fbxParent:
+ #return (self.__anim_poselist[frame] * self.fbxParent.__anim_poselist[frame].copy().invert() ) * GLOBAL_MATRIX
+ return (GLOBAL_MATRIX * self.fbxParent.__anim_poselist[frame]).invert() * (GLOBAL_MATRIX * self.__anim_poselist[frame])
+ else:
+ return GLOBAL_MATRIX * self.__anim_poselist[frame]
+
+ def getAnimParRelMatrixRot(self, frame):
+ obj_type = self.blenObject.type
+ if self.fbxParent:
+ matrix_rot = ((GLOBAL_MATRIX * self.fbxParent.__anim_poselist[frame]).invert() * (GLOBAL_MATRIX * self.__anim_poselist[frame])).rotation_part()
+ else:
+ matrix_rot = (GLOBAL_MATRIX * self.__anim_poselist[frame]).rotation_part()
+
+ # Lamps need to be rotated
+ if obj_type == 'LAMP':
+ matrix_rot = matrix_rot * mtx_x90
+ elif obj_type == 'CAMERA':
+ y = Vector((0.0, 1.0, 0.0)) * matrix_rot
+ matrix_rot = Matrix.Rotation(math.pi / 2.0, 3, y) * matrix_rot
+
+ return matrix_rot
+
+ # ----------------------------------------------
+
+ print('\nFBX export starting... %r' % filepath)
+ start_time = time.clock()
+ try:
+ file = open(filepath, 'w', encoding='utf8')
+ except:
+ return False
+
+ scene = context.scene
+ world = scene.world
+
+ # ---------------------------- Write the header first
+ file.write(header_comment)
+ if time:
+ curtime = time.localtime()[0:6]
+ else:
+ curtime = (0, 0, 0, 0, 0, 0)
+ #
+ file.write(\
+'''FBXHeaderExtension: {
+ FBXHeaderVersion: 1003
+ FBXVersion: 6100
+ CreationTimeStamp: {
+ Version: 1000
+ Year: %.4i
+ Month: %.2i
+ Day: %.2i
+ Hour: %.2i
+ Minute: %.2i
+ Second: %.2i
+ Millisecond: 0
+ }
+ Creator: "FBX SDK/FBX Plugins build 20070228"
+ OtherFlags: {
+ FlagPLE: 0
+ }
+}''' % (curtime))
+
+ file.write('\nCreationTime: "%.4i-%.2i-%.2i %.2i:%.2i:%.2i:000"' % curtime)
+ file.write('\nCreator: "Blender version %s"' % bpy.app.version_string)
+
+ pose_items = [] # list of (fbxName, matrix) to write pose data for, easier to collect allong the way
+
+ # --------------- funcs for exporting
+ def object_tx(ob, loc, matrix, matrix_mod=None):
+ '''
+ Matrix mod is so armature objects can modify their bone matricies
+ '''
+ if isinstance(ob, bpy.types.Bone):
+# if isinstance(ob, Blender.Types.BoneType):
+
+ # we know we have a matrix
+ # matrix = mtx4_z90 * (ob.matrix['ARMATURESPACE'] * matrix_mod)
+ matrix = ob.matrix_local * mtx4_z90 # dont apply armature matrix anymore
+# matrix = mtx4_z90 * ob.matrix['ARMATURESPACE'] # dont apply armature matrix anymore
+
+ parent = ob.parent
+ if parent:
+ #par_matrix = mtx4_z90 * (parent.matrix['ARMATURESPACE'] * matrix_mod)
+ par_matrix = parent.matrix_local * mtx4_z90 # dont apply armature matrix anymore
+# par_matrix = mtx4_z90 * parent.matrix['ARMATURESPACE'] # dont apply armature matrix anymore
+ matrix = par_matrix.copy().invert() * matrix
+
+ loc, rot, scale = matrix.decompose()
+ matrix_rot = rot.to_matrix()
+
+ loc = tuple(loc)
+ rot = tuple(rot.to_euler()) # quat -> euler
+ scale = tuple(scale)
+ else:
+ # This is bad because we need the parent relative matrix from the fbx parent (if we have one), dont use anymore
+ #if ob and not matrix: matrix = ob.matrix_world * GLOBAL_MATRIX
+ if ob and not matrix:
+ raise Exception("error: this should never happen!")
+
+ matrix_rot = matrix
+ #if matrix:
+ # matrix = matrix_scale * matrix
+
+ if matrix:
+ loc, rot, scale = matrix.decompose()
+ matrix_rot = rot.to_matrix()
+
+ # Lamps need to be rotated
+ if ob and ob.type == 'LAMP':
+ matrix_rot = matrix_rot * mtx_x90
+ elif ob and ob.type == 'CAMERA':
+ y = Vector((0.0, 1.0, 0.0)) * matrix_rot
+ matrix_rot = Matrix.Rotation(math.pi / 2.0, 3, y) * matrix_rot
+ # else do nothing.
+
+ loc = tuple(loc)
+ rot = tuple(matrix_rot.to_euler())
+ scale = tuple(scale)
+ else:
+ if not loc:
+ loc = 0.0, 0.0, 0.0
+ scale = 1.0, 1.0, 1.0
+ rot = 0.0, 0.0, 0.0
+
+ return loc, rot, scale, matrix, matrix_rot
+
+ def write_object_tx(ob, loc, matrix, matrix_mod=None):
+ '''
+ We have loc to set the location if non blender objects that have a location
+
+ matrix_mod is only used for bones at the moment
+ '''
+ loc, rot, scale, matrix, matrix_rot = object_tx(ob, loc, matrix, matrix_mod)
+
+ file.write('\n\t\t\tProperty: "Lcl Translation", "Lcl Translation", "A+",%.15f,%.15f,%.15f' % loc)
+ file.write('\n\t\t\tProperty: "Lcl Rotation", "Lcl Rotation", "A+",%.15f,%.15f,%.15f' % tuple_rad_to_deg(rot))
+# file.write('\n\t\t\tProperty: "Lcl Rotation", "Lcl Rotation", "A+",%.15f,%.15f,%.15f' % rot)
+ file.write('\n\t\t\tProperty: "Lcl Scaling", "Lcl Scaling", "A+",%.15f,%.15f,%.15f' % scale)
+ return loc, rot, scale, matrix, matrix_rot
+
+ def write_object_props(ob=None, loc=None, matrix=None, matrix_mod=None):
+ # if the type is 0 its an empty otherwise its a mesh
+ # only difference at the moment is one has a color
+ file.write('''
+ Properties60: {
+ Property: "QuaternionInterpolate", "bool", "",0
+ Property: "Visibility", "Visibility", "A+",1''')
+
+ loc, rot, scale, matrix, matrix_rot = write_object_tx(ob, loc, matrix, matrix_mod)
+
+ # Rotation order, note, for FBX files Iv loaded normal order is 1
+ # setting to zero.
+ # eEULER_XYZ = 0
+ # eEULER_XZY
+ # eEULER_YZX
+ # eEULER_YXZ
+ # eEULER_ZXY
+ # eEULER_ZYX
+
+ file.write('''
+ Property: "RotationOffset", "Vector3D", "",0,0,0
+ Property: "RotationPivot", "Vector3D", "",0,0,0
+ Property: "ScalingOffset", "Vector3D", "",0,0,0
+ Property: "ScalingPivot", "Vector3D", "",0,0,0
+ Property: "TranslationActive", "bool", "",0
+ Property: "TranslationMin", "Vector3D", "",0,0,0
+ Property: "TranslationMax", "Vector3D", "",0,0,0
+ Property: "TranslationMinX", "bool", "",0
+ Property: "TranslationMinY", "bool", "",0
+ Property: "TranslationMinZ", "bool", "",0
+ Property: "TranslationMaxX", "bool", "",0
+ Property: "TranslationMaxY", "bool", "",0
+ Property: "TranslationMaxZ", "bool", "",0
+ Property: "RotationOrder", "enum", "",0
+ Property: "RotationSpaceForLimitOnly", "bool", "",0
+ Property: "AxisLen", "double", "",10
+ Property: "PreRotation", "Vector3D", "",0,0,0
+ Property: "PostRotation", "Vector3D", "",0,0,0
+ Property: "RotationActive", "bool", "",0
+ Property: "RotationMin", "Vector3D", "",0,0,0
+ Property: "RotationMax", "Vector3D", "",0,0,0
+ Property: "RotationMinX", "bool", "",0
+ Property: "RotationMinY", "bool", "",0
+ Property: "RotationMinZ", "bool", "",0
+ Property: "RotationMaxX", "bool", "",0
+ Property: "RotationMaxY", "bool", "",0
+ Property: "RotationMaxZ", "bool", "",0
+ Property: "RotationStiffnessX", "double", "",0
+ Property: "RotationStiffnessY", "double", "",0
+ Property: "RotationStiffnessZ", "double", "",0
+ Property: "MinDampRangeX", "double", "",0
+ Property: "MinDampRangeY", "double", "",0
+ Property: "MinDampRangeZ", "double", "",0
+ Property: "MaxDampRangeX", "double", "",0
+ Property: "MaxDampRangeY", "double", "",0
+ Property: "MaxDampRangeZ", "double", "",0
+ Property: "MinDampStrengthX", "double", "",0
+ Property: "MinDampStrengthY", "double", "",0
+ Property: "MinDampStrengthZ", "double", "",0
+ Property: "MaxDampStrengthX", "double", "",0
+ Property: "MaxDampStrengthY", "double", "",0
+ Property: "MaxDampStrengthZ", "double", "",0
+ Property: "PreferedAngleX", "double", "",0
+ Property: "PreferedAngleY", "double", "",0
+ Property: "PreferedAngleZ", "double", "",0
+ Property: "InheritType", "enum", "",0
+ Property: "ScalingActive", "bool", "",0
+ Property: "ScalingMin", "Vector3D", "",1,1,1
+ Property: "ScalingMax", "Vector3D", "",1,1,1
+ Property: "ScalingMinX", "bool", "",0
+ Property: "ScalingMinY", "bool", "",0
+ Property: "ScalingMinZ", "bool", "",0
+ Property: "ScalingMaxX", "bool", "",0
+ Property: "ScalingMaxY", "bool", "",0
+ Property: "ScalingMaxZ", "bool", "",0
+ Property: "GeometricTranslation", "Vector3D", "",0,0,0
+ Property: "GeometricRotation", "Vector3D", "",0,0,0
+ Property: "GeometricScaling", "Vector3D", "",1,1,1
+ Property: "LookAtProperty", "object", ""
+ Property: "UpVectorProperty", "object", ""
+ Property: "Show", "bool", "",1
+ Property: "NegativePercentShapeSupport", "bool", "",1
+ Property: "DefaultAttributeIndex", "int", "",0''')
+ if ob and not isinstance(ob, bpy.types.Bone):
+ # Only mesh objects have color
+ file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
+ file.write('\n\t\t\tProperty: "Size", "double", "",100')
+ file.write('\n\t\t\tProperty: "Look", "enum", "",1')
+
+ return loc, rot, scale, matrix, matrix_rot
+
+ # -------------------------------------------- Armatures
+ #def write_bone(bone, name, matrix_mod):
+ def write_bone(my_bone):
+ file.write('\n\tModel: "Model::%s", "Limb" {' % my_bone.fbxName)
+ file.write('\n\t\tVersion: 232')
+
+ #poseMatrix = write_object_props(my_bone.blenBone, None, None, my_bone.fbxArm.parRelMatrix())[3]
+ poseMatrix = write_object_props(my_bone.blenBone)[3] # dont apply bone matricies anymore
+ pose_items.append((my_bone.fbxName, poseMatrix))
+
+ # file.write('\n\t\t\tProperty: "Size", "double", "",%.6f' % ((my_bone.blenData.head['ARMATURESPACE'] - my_bone.blenData.tail['ARMATURESPACE']) * my_bone.fbxArm.parRelMatrix()).length)
+ file.write('\n\t\t\tProperty: "Size", "double", "",1')
+
+ #((my_bone.blenData.head['ARMATURESPACE'] * my_bone.fbxArm.matrixWorld) - (my_bone.blenData.tail['ARMATURESPACE'] * my_bone.fbxArm.parRelMatrix())).length)
+
+ """
+ file.write('\n\t\t\tProperty: "LimbLength", "double", "",%.6f' %\
+ ((my_bone.blenBone.head['ARMATURESPACE'] - my_bone.blenBone.tail['ARMATURESPACE']) * my_bone.fbxArm.parRelMatrix()).length)
+ """
+
+ file.write('\n\t\t\tProperty: "LimbLength", "double", "",%.6f' %
+ (my_bone.blenBone.head_local - my_bone.blenBone.tail_local).length)
+# (my_bone.blenBone.head['ARMATURESPACE'] - my_bone.blenBone.tail['ARMATURESPACE']).length)
+
+ #file.write('\n\t\t\tProperty: "LimbLength", "double", "",1')
+ file.write('\n\t\t\tProperty: "Color", "ColorRGB", "",0.8,0.8,0.8')
+ file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
+ file.write('\n\t\t}')
+ file.write('\n\t\tMultiLayer: 0')
+ file.write('\n\t\tMultiTake: 1')
+ file.write('\n\t\tShading: Y')
+ file.write('\n\t\tCulling: "CullingOff"')
+ file.write('\n\t\tTypeFlags: "Skeleton"')
+ file.write('\n\t}')
+
+ def write_camera_switch():
+ file.write('''
+ Model: "Model::Camera Switcher", "CameraSwitcher" {
+ Version: 232''')
+
+ write_object_props()
+ file.write('''
+ Property: "Color", "Color", "A",0.8,0.8,0.8
+ Property: "Camera Index", "Integer", "A+",100
+ }
+ MultiLayer: 0
+ MultiTake: 1
+ Hidden: "True"
+ Shading: W
+ Culling: "CullingOff"
+ Version: 101
+ Name: "Model::Camera Switcher"
+ CameraId: 0
+ CameraName: 100
+ CameraIndexName:
+ }''')
+
+ def write_camera_dummy(name, loc, near, far, proj_type, up):
+ file.write('\n\tModel: "Model::%s", "Camera" {' % name)
+ file.write('\n\t\tVersion: 232')
+ write_object_props(None, loc)
+
+ file.write('\n\t\t\tProperty: "Color", "Color", "A",0.8,0.8,0.8')
+ file.write('\n\t\t\tProperty: "Roll", "Roll", "A+",0')
+ file.write('\n\t\t\tProperty: "FieldOfView", "FieldOfView", "A+",40')
+ file.write('\n\t\t\tProperty: "FieldOfViewX", "FieldOfView", "A+",1')
+ file.write('\n\t\t\tProperty: "FieldOfViewY", "FieldOfView", "A+",1')
+ file.write('\n\t\t\tProperty: "OpticalCenterX", "Real", "A+",0')
+ file.write('\n\t\t\tProperty: "OpticalCenterY", "Real", "A+",0')
+ file.write('\n\t\t\tProperty: "BackgroundColor", "Color", "A+",0.63,0.63,0.63')
+ file.write('\n\t\t\tProperty: "TurnTable", "Real", "A+",0')
+ file.write('\n\t\t\tProperty: "DisplayTurnTableIcon", "bool", "",1')
+ file.write('\n\t\t\tProperty: "Motion Blur Intensity", "Real", "A+",1')
+ file.write('\n\t\t\tProperty: "UseMotionBlur", "bool", "",0')
+ file.write('\n\t\t\tProperty: "UseRealTimeMotionBlur", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ResolutionMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "ApertureMode", "enum", "",2')
+ file.write('\n\t\t\tProperty: "GateFit", "enum", "",0')
+ file.write('\n\t\t\tProperty: "FocalLength", "Real", "A+",21.3544940948486')
+ file.write('\n\t\t\tProperty: "CameraFormat", "enum", "",0')
+ file.write('\n\t\t\tProperty: "AspectW", "double", "",320')
+ file.write('\n\t\t\tProperty: "AspectH", "double", "",200')
+ file.write('\n\t\t\tProperty: "PixelAspectRatio", "double", "",1')
+ file.write('\n\t\t\tProperty: "UseFrameColor", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FrameColor", "ColorRGB", "",0.3,0.3,0.3')
+ file.write('\n\t\t\tProperty: "ShowName", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowGrid", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowOpticalCenter", "bool", "",0')
+ file.write('\n\t\t\tProperty: "ShowAzimut", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowTimeCode", "bool", "",0')
+ file.write('\n\t\t\tProperty: "NearPlane", "double", "",%.6f' % near)
+ file.write('\n\t\t\tProperty: "FarPlane", "double", "",%.6f' % far)
+ file.write('\n\t\t\tProperty: "FilmWidth", "double", "",0.816')
+ file.write('\n\t\t\tProperty: "FilmHeight", "double", "",0.612')
+ file.write('\n\t\t\tProperty: "FilmAspectRatio", "double", "",1.33333333333333')
+ file.write('\n\t\t\tProperty: "FilmSqueezeRatio", "double", "",1')
+ file.write('\n\t\t\tProperty: "FilmFormatIndex", "enum", "",4')
+ file.write('\n\t\t\tProperty: "ViewFrustum", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ViewFrustumNearFarPlane", "bool", "",0')
+ file.write('\n\t\t\tProperty: "ViewFrustumBackPlaneMode", "enum", "",2')
+ file.write('\n\t\t\tProperty: "BackPlaneDistance", "double", "",100')
+ file.write('\n\t\t\tProperty: "BackPlaneDistanceMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "ViewCameraToLookAt", "bool", "",1')
+ file.write('\n\t\t\tProperty: "LockMode", "bool", "",0')
+ file.write('\n\t\t\tProperty: "LockInterestNavigation", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FitImage", "bool", "",0')
+ file.write('\n\t\t\tProperty: "Crop", "bool", "",0')
+ file.write('\n\t\t\tProperty: "Center", "bool", "",1')
+ file.write('\n\t\t\tProperty: "KeepRatio", "bool", "",1')
+ file.write('\n\t\t\tProperty: "BackgroundMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "BackgroundAlphaTreshold", "double", "",0.5')
+ file.write('\n\t\t\tProperty: "ForegroundTransparent", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DisplaySafeArea", "bool", "",0')
+ file.write('\n\t\t\tProperty: "SafeAreaDisplayStyle", "enum", "",1')
+ file.write('\n\t\t\tProperty: "SafeAreaAspectRatio", "double", "",1.33333333333333')
+ file.write('\n\t\t\tProperty: "Use2DMagnifierZoom", "bool", "",0')
+ file.write('\n\t\t\tProperty: "2D Magnifier Zoom", "Real", "A+",100')
+ file.write('\n\t\t\tProperty: "2D Magnifier X", "Real", "A+",50')
+ file.write('\n\t\t\tProperty: "2D Magnifier Y", "Real", "A+",50')
+ file.write('\n\t\t\tProperty: "CameraProjectionType", "enum", "",%i' % proj_type)
+ file.write('\n\t\t\tProperty: "UseRealTimeDOFAndAA", "bool", "",0')
+ file.write('\n\t\t\tProperty: "UseDepthOfField", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FocusSource", "enum", "",0')
+ file.write('\n\t\t\tProperty: "FocusAngle", "double", "",3.5')
+ file.write('\n\t\t\tProperty: "FocusDistance", "double", "",200')
+ file.write('\n\t\t\tProperty: "UseAntialiasing", "bool", "",0')
+ file.write('\n\t\t\tProperty: "AntialiasingIntensity", "double", "",0.77777')
+ file.write('\n\t\t\tProperty: "UseAccumulationBuffer", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FrameSamplingCount", "int", "",7')
+ file.write('\n\t\t}')
+ file.write('\n\t\tMultiLayer: 0')
+ file.write('\n\t\tMultiTake: 0')
+ file.write('\n\t\tHidden: "True"')
+ file.write('\n\t\tShading: Y')
+ file.write('\n\t\tCulling: "CullingOff"')
+ file.write('\n\t\tTypeFlags: "Camera"')
+ file.write('\n\t\tGeometryVersion: 124')
+ file.write('\n\t\tPosition: %.6f,%.6f,%.6f' % loc)
+ file.write('\n\t\tUp: %i,%i,%i' % up)
+ file.write('\n\t\tLookAt: 0,0,0')
+ file.write('\n\t\tShowInfoOnMoving: 1')
+ file.write('\n\t\tShowAudio: 0')
+ file.write('\n\t\tAudioColor: 0,1,0')
+ file.write('\n\t\tCameraOrthoZoom: 1')
+ file.write('\n\t}')
+
+ def write_camera_default():
+ # This sucks but to match FBX converter its easier to
+ # write the cameras though they are not needed.
+ write_camera_dummy('Producer Perspective', (0, 71.3, 287.5), 10, 4000, 0, (0, 1, 0))
+ write_camera_dummy('Producer Top', (0, 4000, 0), 1, 30000, 1, (0, 0, -1))
+ write_camera_dummy('Producer Bottom', (0, -4000, 0), 1, 30000, 1, (0, 0, -1))
+ write_camera_dummy('Producer Front', (0, 0, 4000), 1, 30000, 1, (0, 1, 0))
+ write_camera_dummy('Producer Back', (0, 0, -4000), 1, 30000, 1, (0, 1, 0))
+ write_camera_dummy('Producer Right', (4000, 0, 0), 1, 30000, 1, (0, 1, 0))
+ write_camera_dummy('Producer Left', (-4000, 0, 0), 1, 30000, 1, (0, 1, 0))
+
+ def write_camera(my_cam):
+ '''
+ Write a blender camera
+ '''
+ render = scene.render
+ width = render.resolution_x
+ height = render.resolution_y
+ aspect = width / height
+
+ data = my_cam.blenObject.data
+
+ file.write('\n\tModel: "Model::%s", "Camera" {' % my_cam.fbxName)
+ file.write('\n\t\tVersion: 232')
+ loc, rot, scale, matrix, matrix_rot = write_object_props(my_cam.blenObject, None, my_cam.parRelMatrix())
+
+ file.write('\n\t\t\tProperty: "Roll", "Roll", "A+",0')
+ file.write('\n\t\t\tProperty: "FieldOfView", "FieldOfView", "A+",%.6f' % math.degrees(data.angle))
+ file.write('\n\t\t\tProperty: "FieldOfViewX", "FieldOfView", "A+",1')
+ file.write('\n\t\t\tProperty: "FieldOfViewY", "FieldOfView", "A+",1')
+ # file.write('\n\t\t\tProperty: "FocalLength", "Real", "A+",14.0323972702026')
+ file.write('\n\t\t\tProperty: "OpticalCenterX", "Real", "A+",%.6f' % data.shift_x) # not sure if this is in the correct units?
+ file.write('\n\t\t\tProperty: "OpticalCenterY", "Real", "A+",%.6f' % data.shift_y) # ditto
+ file.write('\n\t\t\tProperty: "BackgroundColor", "Color", "A+",0,0,0')
+ file.write('\n\t\t\tProperty: "TurnTable", "Real", "A+",0')
+ file.write('\n\t\t\tProperty: "DisplayTurnTableIcon", "bool", "",1')
+ file.write('\n\t\t\tProperty: "Motion Blur Intensity", "Real", "A+",1')
+ file.write('\n\t\t\tProperty: "UseMotionBlur", "bool", "",0')
+ file.write('\n\t\t\tProperty: "UseRealTimeMotionBlur", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ResolutionMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "ApertureMode", "enum", "",2')
+ file.write('\n\t\t\tProperty: "GateFit", "enum", "",2')
+ file.write('\n\t\t\tProperty: "CameraFormat", "enum", "",0')
+ file.write('\n\t\t\tProperty: "AspectW", "double", "",%i' % width)
+ file.write('\n\t\t\tProperty: "AspectH", "double", "",%i' % height)
+
+ '''Camera aspect ratio modes.
+ 0 If the ratio mode is eWINDOW_SIZE, both width and height values aren't relevant.
+ 1 If the ratio mode is eFIXED_RATIO, the height value is set to 1.0 and the width value is relative to the height value.
+ 2 If the ratio mode is eFIXED_RESOLUTION, both width and height values are in pixels.
+ 3 If the ratio mode is eFIXED_WIDTH, the width value is in pixels and the height value is relative to the width value.
+ 4 If the ratio mode is eFIXED_HEIGHT, the height value is in pixels and the width value is relative to the height value.
+
+ Definition at line 234 of file kfbxcamera.h. '''
+
+ file.write('\n\t\t\tProperty: "PixelAspectRatio", "double", "",2')
+
+ file.write('\n\t\t\tProperty: "UseFrameColor", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FrameColor", "ColorRGB", "",0.3,0.3,0.3')
+ file.write('\n\t\t\tProperty: "ShowName", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowGrid", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowOpticalCenter", "bool", "",0')
+ file.write('\n\t\t\tProperty: "ShowAzimut", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ShowTimeCode", "bool", "",0')
+ file.write('\n\t\t\tProperty: "NearPlane", "double", "",%.6f' % data.clip_start)
+ file.write('\n\t\t\tProperty: "FarPlane", "double", "",%.6f' % data.clip_end)
+ file.write('\n\t\t\tProperty: "FilmWidth", "double", "",1.0')
+ file.write('\n\t\t\tProperty: "FilmHeight", "double", "",1.0')
+ file.write('\n\t\t\tProperty: "FilmAspectRatio", "double", "",%.6f' % aspect)
+ file.write('\n\t\t\tProperty: "FilmSqueezeRatio", "double", "",1')
+ file.write('\n\t\t\tProperty: "FilmFormatIndex", "enum", "",0')
+ file.write('\n\t\t\tProperty: "ViewFrustum", "bool", "",1')
+ file.write('\n\t\t\tProperty: "ViewFrustumNearFarPlane", "bool", "",0')
+ file.write('\n\t\t\tProperty: "ViewFrustumBackPlaneMode", "enum", "",2')
+ file.write('\n\t\t\tProperty: "BackPlaneDistance", "double", "",100')
+ file.write('\n\t\t\tProperty: "BackPlaneDistanceMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "ViewCameraToLookAt", "bool", "",1')
+ file.write('\n\t\t\tProperty: "LockMode", "bool", "",0')
+ file.write('\n\t\t\tProperty: "LockInterestNavigation", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FitImage", "bool", "",0')
+ file.write('\n\t\t\tProperty: "Crop", "bool", "",0')
+ file.write('\n\t\t\tProperty: "Center", "bool", "",1')
+ file.write('\n\t\t\tProperty: "KeepRatio", "bool", "",1')
+ file.write('\n\t\t\tProperty: "BackgroundMode", "enum", "",0')
+ file.write('\n\t\t\tProperty: "BackgroundAlphaTreshold", "double", "",0.5')
+ file.write('\n\t\t\tProperty: "ForegroundTransparent", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DisplaySafeArea", "bool", "",0')
+ file.write('\n\t\t\tProperty: "SafeAreaDisplayStyle", "enum", "",1')
+ file.write('\n\t\t\tProperty: "SafeAreaAspectRatio", "double", "",%.6f' % aspect)
+ file.write('\n\t\t\tProperty: "Use2DMagnifierZoom", "bool", "",0')
+ file.write('\n\t\t\tProperty: "2D Magnifier Zoom", "Real", "A+",100')
+ file.write('\n\t\t\tProperty: "2D Magnifier X", "Real", "A+",50')
+ file.write('\n\t\t\tProperty: "2D Magnifier Y", "Real", "A+",50')
+ file.write('\n\t\t\tProperty: "CameraProjectionType", "enum", "",0')
+ file.write('\n\t\t\tProperty: "UseRealTimeDOFAndAA", "bool", "",0')
+ file.write('\n\t\t\tProperty: "UseDepthOfField", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FocusSource", "enum", "",0')
+ file.write('\n\t\t\tProperty: "FocusAngle", "double", "",3.5')
+ file.write('\n\t\t\tProperty: "FocusDistance", "double", "",200')
+ file.write('\n\t\t\tProperty: "UseAntialiasing", "bool", "",0')
+ file.write('\n\t\t\tProperty: "AntialiasingIntensity", "double", "",0.77777')
+ file.write('\n\t\t\tProperty: "UseAccumulationBuffer", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FrameSamplingCount", "int", "",7')
+
+ file.write('\n\t\t}')
+ file.write('\n\t\tMultiLayer: 0')
+ file.write('\n\t\tMultiTake: 0')
+ file.write('\n\t\tShading: Y')
+ file.write('\n\t\tCulling: "CullingOff"')
+ file.write('\n\t\tTypeFlags: "Camera"')
+ file.write('\n\t\tGeometryVersion: 124')
+ file.write('\n\t\tPosition: %.6f,%.6f,%.6f' % loc)
+ file.write('\n\t\tUp: %.6f,%.6f,%.6f' % tuple(Vector((0.0, 1.0, 0.0)) * matrix_rot))
+ file.write('\n\t\tLookAt: %.6f,%.6f,%.6f' % tuple(Vector((0.0, 0.0, -1.0)) * matrix_rot))
+
+ #file.write('\n\t\tUp: 0,0,0' )
+ #file.write('\n\t\tLookAt: 0,0,0' )
+
+ file.write('\n\t\tShowInfoOnMoving: 1')
+ file.write('\n\t\tShowAudio: 0')
+ file.write('\n\t\tAudioColor: 0,1,0')
+ file.write('\n\t\tCameraOrthoZoom: 1')
+ file.write('\n\t}')
+
+ def write_light(my_light):
+ light = my_light.blenObject.data
+ file.write('\n\tModel: "Model::%s", "Light" {' % my_light.fbxName)
+ file.write('\n\t\tVersion: 232')
+
+ write_object_props(my_light.blenObject, None, my_light.parRelMatrix())
+
+ # Why are these values here twice?????? - oh well, follow the holy sdk's output
+
+ # Blender light types match FBX's, funny coincidence, we just need to
+ # be sure that all unsupported types are made into a point light
+ #ePOINT,
+ #eDIRECTIONAL
+ #eSPOT
+ light_type_items = {'POINT': 0, 'SUN': 1, 'SPOT': 2, 'HEMI': 3, 'AREA': 4}
+ light_type = light_type_items[light.type]
+
+ if light_type > 2:
+ light_type = 1 # hemi and area lights become directional
+
+# mode = light.mode
+ if light.shadow_method == 'RAY_SHADOW' or light.shadow_method == 'BUFFER_SHADOW':
+# if mode & Blender.Lamp.Modes.RayShadow or mode & Blender.Lamp.Modes.Shadows:
+ do_shadow = 1
+ else:
+ do_shadow = 0
+
+ if light.use_only_shadow or (not light.use_diffuse and not light.use_specular):
+# if mode & Blender.Lamp.Modes.OnlyShadow or (mode & Blender.Lamp.Modes.NoDiffuse and mode & Blender.Lamp.Modes.NoSpecular):
+ do_light = 0
+ else:
+ do_light = 1
+
+ scale = abs(GLOBAL_MATRIX.scale_part()[0]) # scale is always uniform in this case
+
+ file.write('\n\t\t\tProperty: "LightType", "enum", "",%i' % light_type)
+ file.write('\n\t\t\tProperty: "CastLightOnObject", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DrawVolumetricLight", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DrawGroundProjection", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DrawFrontFacingVolumetricLight", "bool", "",0')
+ file.write('\n\t\t\tProperty: "GoboProperty", "object", ""')
+ file.write('\n\t\t\tProperty: "Color", "Color", "A+",1,1,1')
+ file.write('\n\t\t\tProperty: "Intensity", "Intensity", "A+",%.2f' % (min(light.energy * 100.0, 200.0))) # clamp below 200
+ if light.type == 'SPOT':
+ file.write('\n\t\t\tProperty: "Cone angle", "Cone angle", "A+",%.2f' % math.degrees(light.spot_size))
+ file.write('\n\t\t\tProperty: "Fog", "Fog", "A+",50')
+ file.write('\n\t\t\tProperty: "Color", "Color", "A",%.2f,%.2f,%.2f' % tuple(light.color))
+
+ file.write('\n\t\t\tProperty: "Intensity", "Intensity", "A+",%.2f' % (min(light.energy * 100.0, 200.0))) # clamp below 200
+
+ file.write('\n\t\t\tProperty: "Fog", "Fog", "A+",50')
+ file.write('\n\t\t\tProperty: "LightType", "enum", "",%i' % light_type)
+ file.write('\n\t\t\tProperty: "CastLightOnObject", "bool", "",%i' % do_light)
+ file.write('\n\t\t\tProperty: "DrawGroundProjection", "bool", "",1')
+ file.write('\n\t\t\tProperty: "DrawFrontFacingVolumetricLight", "bool", "",0')
+ file.write('\n\t\t\tProperty: "DrawVolumetricLight", "bool", "",1')
+ file.write('\n\t\t\tProperty: "GoboProperty", "object", ""')
+ file.write('\n\t\t\tProperty: "DecayType", "enum", "",0')
+ file.write('\n\t\t\tProperty: "DecayStart", "double", "",%.2f' % light.distance)
+ file.write('\n\t\t\tProperty: "EnableNearAttenuation", "bool", "",0')
+ file.write('\n\t\t\tProperty: "NearAttenuationStart", "double", "",0')
+ file.write('\n\t\t\tProperty: "NearAttenuationEnd", "double", "",0')
+ file.write('\n\t\t\tProperty: "EnableFarAttenuation", "bool", "",0')
+ file.write('\n\t\t\tProperty: "FarAttenuationStart", "double", "",0')
+ file.write('\n\t\t\tProperty: "FarAttenuationEnd", "double", "",0')
+ file.write('\n\t\t\tProperty: "CastShadows", "bool", "",%i' % do_shadow)
+ file.write('\n\t\t\tProperty: "ShadowColor", "ColorRGBA", "",0,0,0,1')
+ file.write('\n\t\t}')
+ file.write('\n\t\tMultiLayer: 0')
+ file.write('\n\t\tMultiTake: 0')
+ file.write('\n\t\tShading: Y')
+ file.write('\n\t\tCulling: "CullingOff"')
+ file.write('\n\t\tTypeFlags: "Light"')
+ file.write('\n\t\tGeometryVersion: 124')
+ file.write('\n\t}')
+
+ # matrixOnly is not used at the moment
+ def write_null(my_null=None, fbxName=None, matrixOnly=None):
+ # ob can be null
+ if not fbxName:
+ fbxName = my_null.fbxName
+
+ file.write('\n\tModel: "Model::%s", "Null" {' % fbxName)
+ file.write('\n\t\tVersion: 232')
+
+ # only use this for the root matrix at the moment
+ if matrixOnly:
+ poseMatrix = write_object_props(None, None, matrixOnly)[3]
+
+ else: # all other Null's
+ if my_null:
+ poseMatrix = write_object_props(my_null.blenObject, None, my_null.parRelMatrix())[3]
+ else:
+ poseMatrix = write_object_props()[3]
+
+ pose_items.append((fbxName, poseMatrix))
+
+ file.write('''
+ }
+ MultiLayer: 0
+ MultiTake: 1
+ Shading: Y
+ Culling: "CullingOff"
+ TypeFlags: "Null"
+ }''')
+
+ # Material Settings
+ if world:
+ world_amb = world.ambient_color[:]
+ else:
+ world_amb = 0.0, 0.0, 0.0 # default value
+
+ def write_material(matname, mat):
+ file.write('\n\tMaterial: "Material::%s", "" {' % matname)
+
+ # Todo, add more material Properties.
+ if mat:
+ mat_cold = tuple(mat.diffuse_color)
+ mat_cols = tuple(mat.specular_color)
+ #mat_colm = tuple(mat.mirCol) # we wont use the mirror color
+ mat_colamb = world_amb
+
+ mat_dif = mat.diffuse_intensity
+ mat_amb = mat.ambient
+ mat_hard = (float(mat.specular_hardness) - 1.0) / 5.10
+ mat_spec = mat.specular_intensity / 2.0
+ mat_alpha = mat.alpha
+ mat_emit = mat.emit
+ mat_shadeless = mat.use_shadeless
+ if mat_shadeless:
+ mat_shader = 'Lambert'
+ else:
+ if mat.diffuse_shader == 'LAMBERT':
+ mat_shader = 'Lambert'
+ else:
+ mat_shader = 'Phong'
+ else:
+ mat_cols = mat_cold = 0.8, 0.8, 0.8
+ mat_colamb = 0.0, 0.0, 0.0
+ # mat_colm
+ mat_dif = 1.0
+ mat_amb = 0.5
+ mat_hard = 20.0
+ mat_spec = 0.2
+ mat_alpha = 1.0
+ mat_emit = 0.0
+ mat_shadeless = False
+ mat_shader = 'Phong'
+
+ file.write('\n\t\tVersion: 102')
+ file.write('\n\t\tShadingModel: "%s"' % mat_shader.lower())
+ file.write('\n\t\tMultiLayer: 0')
+
+ file.write('\n\t\tProperties60: {')
+ file.write('\n\t\t\tProperty: "ShadingModel", "KString", "", "%s"' % mat_shader)
+ file.write('\n\t\t\tProperty: "MultiLayer", "bool", "",0')
+ file.write('\n\t\t\tProperty: "EmissiveColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cold) # emit and diffuse color are he same in blender
+ file.write('\n\t\t\tProperty: "EmissiveFactor", "double", "",%.4f' % mat_emit)
+
+ file.write('\n\t\t\tProperty: "AmbientColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_colamb)
+ file.write('\n\t\t\tProperty: "AmbientFactor", "double", "",%.4f' % mat_amb)
+ file.write('\n\t\t\tProperty: "DiffuseColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cold)
+ file.write('\n\t\t\tProperty: "DiffuseFactor", "double", "",%.4f' % mat_dif)
+ file.write('\n\t\t\tProperty: "Bump", "Vector3D", "",0,0,0')
+ file.write('\n\t\t\tProperty: "TransparentColor", "ColorRGB", "",1,1,1')
+ file.write('\n\t\t\tProperty: "TransparencyFactor", "double", "",%.4f' % (1.0 - mat_alpha))
+ if not mat_shadeless:
+ file.write('\n\t\t\tProperty: "SpecularColor", "ColorRGB", "",%.4f,%.4f,%.4f' % mat_cols)
+ file.write('\n\t\t\tProperty: "SpecularFactor", "double", "",%.4f' % mat_spec)
+ file.write('\n\t\t\tProperty: "ShininessExponent", "double", "",80.0')
+ file.write('\n\t\t\tProperty: "ReflectionColor", "ColorRGB", "",0,0,0')
+ file.write('\n\t\t\tProperty: "ReflectionFactor", "double", "",1')
+ file.write('\n\t\t\tProperty: "Emissive", "ColorRGB", "",0,0,0')
+ file.write('\n\t\t\tProperty: "Ambient", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_colamb)
+ file.write('\n\t\t\tProperty: "Diffuse", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_cold)
+ if not mat_shadeless:
+ file.write('\n\t\t\tProperty: "Specular", "ColorRGB", "",%.1f,%.1f,%.1f' % mat_cols)
+ file.write('\n\t\t\tProperty: "Shininess", "double", "",%.1f' % mat_hard)
+ file.write('\n\t\t\tProperty: "Opacity", "double", "",%.1f' % mat_alpha)
+ if not mat_shadeless:
+ file.write('\n\t\t\tProperty: "Reflectivity", "double", "",0')
+
+ file.write('\n\t\t}')
+ file.write('\n\t}')
+
+ def copy_image(image):
+ fn = bpy.path.abspath(image.filepath)
+ fn_strip = os.path.basename(fn)
+
+ if EXP_IMAGE_COPY:
+ rel = fn_strip
+ fn_abs_dest = os.path.join(basepath, fn_strip)
+ if not os.path.exists(fn_abs_dest):
+ shutil.copy(fn, fn_abs_dest)
+ elif bpy.path.is_subdir(fn, basepath):
+ rel = os.path.relpath(fn, basepath)
+ else:
+ rel = fn
+
+ return (rel, fn_strip)
+
+ # tex is an Image (Arystan)
+ def write_video(texname, tex):
+ # Same as texture really!
+ file.write('\n\tVideo: "Video::%s", "Clip" {' % texname)
+
+ file.write('''
+ Type: "Clip"
+ Properties60: {
+ Property: "FrameRate", "double", "",0
+ Property: "LastFrame", "int", "",0
+ Property: "Width", "int", "",0
+ Property: "Height", "int", "",0''')
+ if tex:
+ fname_rel, fname_strip = copy_image(tex)
+# fname, fname_strip, fname_rel = derived_paths(tex.filepath, basepath, EXP_IMAGE_COPY)
+ else:
+ fname = fname_strip = fname_rel = ''
+
+ file.write('\n\t\t\tProperty: "Path", "charptr", "", "%s"' % fname_strip)
+
+ file.write('''
+ Property: "StartFrame", "int", "",0
+ Property: "StopFrame", "int", "",0
+ Property: "PlaySpeed", "double", "",1
+ Property: "Offset", "KTime", "",0
+ Property: "InterlaceMode", "enum", "",0
+ Property: "FreeRunning", "bool", "",0
+ Property: "Loop", "bool", "",0
+ Property: "AccessMode", "enum", "",0
+ }
+ UseMipMap: 0''')
+
+ file.write('\n\t\tFilename: "%s"' % fname_strip)
+ if fname_strip:
+ fname_strip = '/' + fname_strip
+ file.write('\n\t\tRelativeFilename: "%s"' % fname_rel) # make relative
+ file.write('\n\t}')
+
+ def write_texture(texname, tex, num):
+ # if tex is None then this is a dummy tex
+ file.write('\n\tTexture: "Texture::%s", "TextureVideoClip" {' % texname)
+ file.write('\n\t\tType: "TextureVideoClip"')
+ file.write('\n\t\tVersion: 202')
+ # TODO, rare case _empty_ exists as a name.
+ file.write('\n\t\tTextureName: "Texture::%s"' % texname)
+
+ file.write('''
+ Properties60: {
+ Property: "Translation", "Vector", "A+",0,0,0
+ Property: "Rotation", "Vector", "A+",0,0,0
+ Property: "Scaling", "Vector", "A+",1,1,1''')
+ file.write('\n\t\t\tProperty: "Texture alpha", "Number", "A+",%i' % num)
+
+ # WrapModeU/V 0==rep, 1==clamp, TODO add support
+ file.write('''
+ Property: "TextureTypeUse", "enum", "",0
+ Property: "CurrentTextureBlendMode", "enum", "",1
+ Property: "UseMaterial", "bool", "",0
+ Property: "UseMipMap", "bool", "",0
+ Property: "CurrentMappingType", "enum", "",0
+ Property: "UVSwap", "bool", "",0''')
+
+ file.write('\n\t\t\tProperty: "WrapModeU", "enum", "",%i' % tex.use_clamp_x)
+ file.write('\n\t\t\tProperty: "WrapModeV", "enum", "",%i' % tex.use_clamp_y)
+
+ file.write('''
+ Property: "TextureRotationPivot", "Vector3D", "",0,0,0
+ Property: "TextureScalingPivot", "Vector3D", "",0,0,0
+ Property: "VideoProperty", "object", ""
+ }''')
+
+ file.write('\n\t\tMedia: "Video::%s"' % texname)
+
+ if tex:
+ fname_rel, fname_strip = copy_image(tex)
+# fname, fname_strip, fname_rel = derived_paths(tex.filepath, basepath, EXP_IMAGE_COPY)
+ else:
+ fname = fname_strip = fname_rel = ''
+
+ file.write('\n\t\tFileName: "%s"' % fname_strip)
+ file.write('\n\t\tRelativeFilename: "%s"' % fname_rel) # need some make relative command
+
+ file.write('''
+ ModelUVTranslation: 0,0
+ ModelUVScaling: 1,1
+ Texture_Alpha_Source: "None"
+ Cropping: 0,0,0,0
+ }''')
+
+ def write_deformer_skin(obname):
+ '''
+ Each mesh has its own deformer
+ '''
+ file.write('\n\tDeformer: "Deformer::Skin %s", "Skin" {' % obname)
+ file.write('''
+ Version: 100
+ MultiLayer: 0
+ Type: "Skin"
+ Properties60: {
+ }
+ Link_DeformAcuracy: 50
+ }''')
+
+ # in the example was 'Bip01 L Thigh_2'
+ def write_sub_deformer_skin(my_mesh, my_bone, weights):
+
+ '''
+ Each subdeformer is spesific to a mesh, but the bone it links to can be used by many sub-deformers
+ So the SubDeformer needs the mesh-object name as a prefix to make it unique
+
+ Its possible that there is no matching vgroup in this mesh, in that case no verts are in the subdeformer,
+ a but silly but dosnt really matter
+ '''
+ file.write('\n\tDeformer: "SubDeformer::Cluster %s %s", "Cluster" {' % (my_mesh.fbxName, my_bone.fbxName))
+
+ file.write('''
+ Version: 100
+ MultiLayer: 0
+ Type: "Cluster"
+ Properties60: {
+ Property: "SrcModel", "object", ""
+ Property: "SrcModelReference", "object", ""
+ }
+ UserData: "", ""''')
+
+ # Support for bone parents
+ if my_mesh.fbxBoneParent:
+ if my_mesh.fbxBoneParent == my_bone:
+ # TODO - this is a bit lazy, we could have a simple write loop
+ # for this case because all weights are 1.0 but for now this is ok
+ # Parent Bones arent used all that much anyway.
+ vgroup_data = [(j, 1.0) for j in range(len(my_mesh.blenData.vertices))]
+ else:
+ # This bone is not a parent of this mesh object, no weights
+ vgroup_data = []
+
+ else:
+ # Normal weight painted mesh
+ if my_bone.blenName in weights[0]:
+ # Before we used normalized wright list
+ #vgroup_data = me.getVertsFromGroup(bone.name, 1)
+ group_index = weights[0].index(my_bone.blenName)
+ vgroup_data = [(j, weight[group_index]) for j, weight in enumerate(weights[1]) if weight[group_index]]
+ else:
+ vgroup_data = []
+
+ file.write('\n\t\tIndexes: ')
+
+ i = -1
+ for vg in vgroup_data:
+ if i == -1:
+ file.write('%i' % vg[0])
+ i = 0
+ else:
+ if i == 23:
+ file.write('\n\t\t')
+ i = 0
+ file.write(',%i' % vg[0])
+ i += 1
+
+ file.write('\n\t\tWeights: ')
+ i = -1
+ for vg in vgroup_data:
+ if i == -1:
+ file.write('%.8f' % vg[1])
+ i = 0
+ else:
+ if i == 38:
+ file.write('\n\t\t')
+ i = 0
+ file.write(',%.8f' % vg[1])
+ i += 1
+
+ if my_mesh.fbxParent:
+ # TODO FIXME, this case is broken in some cases. skinned meshes just shouldnt have parents where possible!
+ m = (my_mesh.matrixWorld.copy().invert() * my_bone.fbxArm.matrixWorld.copy() * my_bone.restMatrix) * mtx4_z90
+ else:
+ # Yes! this is it... - but dosnt work when the mesh is a.
+ m = (my_mesh.matrixWorld.copy().invert() * my_bone.fbxArm.matrixWorld.copy() * my_bone.restMatrix) * mtx4_z90
+
+ #m = mtx4_z90 * my_bone.restMatrix
+ matstr = mat4x4str(m)
+ matstr_i = mat4x4str(m.invert())
+
+ file.write('\n\t\tTransform: %s' % matstr_i) # THIS IS __NOT__ THE GLOBAL MATRIX AS DOCUMENTED :/
+ file.write('\n\t\tTransformLink: %s' % matstr)
+ file.write('\n\t}')
+
+ def write_mesh(my_mesh):
+
+ me = my_mesh.blenData
+
+ # if there are non NULL materials on this mesh
+ do_materials = bool(my_mesh.blenMaterials)
+ do_textures = bool(my_mesh.blenTextures)
+ do_uvs = bool(me.uv_textures)
+
+ file.write('\n\tModel: "Model::%s", "Mesh" {' % my_mesh.fbxName)
+ file.write('\n\t\tVersion: 232') # newline is added in write_object_props
+
+ # convert into lists once.
+ me_vertices = me.vertices[:]
+ me_edges = me.edges[:]
+ me_faces = me.faces[:]
+
+ poseMatrix = write_object_props(my_mesh.blenObject, None, my_mesh.parRelMatrix())[3]
+ pose_items.append((my_mesh.fbxName, poseMatrix))
+
+ file.write('\n\t\t}')
+ file.write('\n\t\tMultiLayer: 0')
+ file.write('\n\t\tMultiTake: 1')
+ file.write('\n\t\tShading: Y')
+ file.write('\n\t\tCulling: "CullingOff"')
+
+ # Write the Real Mesh data here
+ file.write('\n\t\tVertices: ')
+ i = -1
+
+ for v in me_vertices:
+ if i == -1:
+ file.write('%.6f,%.6f,%.6f' % v.co[:])
+ i = 0
+ else:
+ if i == 7:
+ file.write('\n\t\t')
+ i = 0
+ file.write(',%.6f,%.6f,%.6f' % v.co[:])
+ i += 1
+
+ file.write('\n\t\tPolygonVertexIndex: ')
+ i = -1
+ for f in me_faces:
+ fi = f.vertices[:]
+
+ # last index XORd w. -1 indicates end of face
+ if i == -1:
+ if len(fi) == 3:
+ file.write('%i,%i,%i' % (fi[0], fi[1], fi[2] ^ -1))
+ else:
+ file.write('%i,%i,%i,%i' % (fi[0], fi[1], fi[2], fi[3] ^ -1))
+ i = 0
+ else:
+ if i == 13:
+ file.write('\n\t\t')
+ i = 0
+ if len(fi) == 3:
+ file.write(',%i,%i,%i' % (fi[0], fi[1], fi[2] ^ -1))
+ else:
+ file.write(',%i,%i,%i,%i' % (fi[0], fi[1], fi[2], fi[3] ^ -1))
+ i += 1
+
+ # write loose edges as faces.
+ for ed in me_edges:
+ if ed.is_loose:
+ ed_val = ed.vertices[:]
+ ed_val = ed_val[0], ed_val[-1] ^ -1
+
+ if i == -1:
+ file.write('%i,%i' % ed_val)
+ i = 0
+ else:
+ if i == 13:
+ file.write('\n\t\t')
+ i = 0
+ file.write(',%i,%i' % ed_val)
+ i += 1
+
+ file.write('\n\t\tEdges: ')
+ i = -1
+ for ed in me_edges:
+ if i == -1:
+ file.write('%i,%i' % (ed.vertices[0], ed.vertices[1]))
+ i = 0
+ else:
+ if i == 13:
+ file.write('\n\t\t')
+ i = 0
+ file.write(',%i,%i' % (ed.vertices[0], ed.vertices[1]))
+ i += 1
+
+ file.write('\n\t\tGeometryVersion: 124')
+
+ file.write('''
+ LayerElementNormal: 0 {
+ Version: 101
+ Name: ""
+ MappingInformationType: "ByVertice"
+ ReferenceInformationType: "Direct"
+ Normals: ''')
+
+ i = -1
+ for v in me_vertices:
+ if i == -1:
+ file.write('%.15f,%.15f,%.15f' % v.normal[:])
+ i = 0
+ else:
+ if i == 2:
+ file.write('\n\t\t\t ')
+ i = 0
+ file.write(',%.15f,%.15f,%.15f' % v.normal[:])
+ i += 1
+ file.write('\n\t\t}')
+
+ # Write Face Smoothing
+ file.write('''
+ LayerElementSmoothing: 0 {
+ Version: 102
+ Name: ""
+ MappingInformationType: "ByPolygon"
+ ReferenceInformationType: "Direct"
+ Smoothing: ''')
+
+ i = -1
+ for f in me_faces:
+ if i == -1:
+ file.write('%i' % f.use_smooth)
+ i = 0
+ else:
+ if i == 54:
+ file.write('\n\t\t\t ')
+ i = 0
+ file.write(',%i' % f.use_smooth)
+ i += 1
+
+ file.write('\n\t\t}')
+
+ # Write Edge Smoothing
+ file.write('''
+ LayerElementSmoothing: 0 {
+ Version: 101
+ Name: ""
+ MappingInformationType: "ByEdge"
+ ReferenceInformationType: "Direct"
+ Smoothing: ''')
+
+ i = -1
+ for ed in me_edges:
+ if i == -1:
+ file.write('%i' % (ed.use_edge_sharp))
+ i = 0
+ else:
+ if i == 54:
+ file.write('\n\t\t\t ')
+ i = 0
+ file.write(',%i' % (ed.use_edge_sharp))
+ i += 1
+
+ file.write('\n\t\t}')
+
+ # Write VertexColor Layers
+ # note, no programs seem to use this info :/
+ collayers = []
+ if len(me.vertex_colors):
+ collayers = me.vertex_colors
+ for colindex, collayer in enumerate(collayers):
+ file.write('\n\t\tLayerElementColor: %i {' % colindex)
+ file.write('\n\t\t\tVersion: 101')
+ file.write('\n\t\t\tName: "%s"' % collayer.name)
+
+ file.write('''
+ MappingInformationType: "ByPolygonVertex"
+ ReferenceInformationType: "IndexToDirect"
+ Colors: ''')
+
+ i = -1
+ ii = 0 # Count how many Colors we write
+
+ for fi, cf in enumerate(collayer.data):
+ if len(me_faces[fi].vertices) == 4:
+ colors = cf.color1[:], cf.color2[:], cf.color3[:], cf.color4[:]
+ else:
+ colors = cf.color1[:], cf.color2[:], cf.color3[:]
+
+ for col in colors:
+ if i == -1:
+ file.write('%.4f,%.4f,%.4f,1' % col)
+ i = 0
+ else:
+ if i == 7:
+ file.write('\n\t\t\t\t')
+ i = 0
+ file.write(',%.4f,%.4f,%.4f,1' % col)
+ i += 1
+ ii += 1 # One more Color
+
+ file.write('\n\t\t\tColorIndex: ')
+ i = -1
+ for j in range(ii):
+ if i == -1:
+ file.write('%i' % j)
+ i = 0
+ else:
+ if i == 55:
+ file.write('\n\t\t\t\t')
+ i = 0
+ file.write(',%i' % j)
+ i += 1
+
+ file.write('\n\t\t}')
+
+ # Write UV and texture layers.
+ uvlayers = []
+ if do_uvs:
+ uvlayers = me.uv_textures
+ uvlayer_orig = me.uv_textures.active
+ for uvindex, uvlayer in enumerate(me.uv_textures):
+ file.write('\n\t\tLayerElementUV: %i {' % uvindex)
+ file.write('\n\t\t\tVersion: 101')
+ file.write('\n\t\t\tName: "%s"' % uvlayer.name)
+
+ file.write('''
+ MappingInformationType: "ByPolygonVertex"
+ ReferenceInformationType: "IndexToDirect"
+ UV: ''')
+
+ i = -1
+ ii = 0 # Count how many UVs we write
+
+ for uf in uvlayer.data:
+ # workaround, since uf.uv iteration is wrong atm
+ for uv in uf.uv:
+ if i == -1:
+ file.write('%.6f,%.6f' % uv[:])
+ i = 0
+ else:
+ if i == 7:
+ file.write('\n\t\t\t ')
+ i = 0
+ file.write(',%.6f,%.6f' % uv[:])
+ i += 1
+ ii += 1 # One more UV
+
+ file.write('\n\t\t\tUVIndex: ')
+ i = -1
+ for j in range(ii):
+ if i == -1:
+ file.write('%i' % j)
+ i = 0
+ else:
+ if i == 55:
+ file.write('\n\t\t\t\t')
+ i = 0
+ file.write(',%i' % j)
+ i += 1
+
+ file.write('\n\t\t}')
+
+ if do_textures:
+ file.write('\n\t\tLayerElementTexture: %i {' % uvindex)
+ file.write('\n\t\t\tVersion: 101')
+ file.write('\n\t\t\tName: "%s"' % uvlayer.name)
+
+ if len(my_mesh.blenTextures) == 1:
+ file.write('\n\t\t\tMappingInformationType: "AllSame"')
+ else:
+ file.write('\n\t\t\tMappingInformationType: "ByPolygon"')
+
+ file.write('\n\t\t\tReferenceInformationType: "IndexToDirect"')
+ file.write('\n\t\t\tBlendMode: "Translucent"')
+ file.write('\n\t\t\tTextureAlpha: 1')
+ file.write('\n\t\t\tTextureId: ')
+
+ if len(my_mesh.blenTextures) == 1:
+ file.write('0')
+ else:
+ texture_mapping_local = {None: -1}
+
+ i = 0 # 1 for dummy
+ for tex in my_mesh.blenTextures:
+ if tex: # None is set above
+ texture_mapping_local[tex] = i
+ i += 1
+
+ i = -1
+ for f in uvlayer.data:
+ img_key = f.image
+
+ if i == -1:
+ i = 0
+ file.write('%s' % texture_mapping_local[img_key])
+ else:
+ if i == 55:
+ file.write('\n ')
+ i = 0
+
+ file.write(',%s' % texture_mapping_local[img_key])
+ i += 1
+
+ else:
+ file.write('''
+ LayerElementTexture: 0 {
+ Version: 101
+ Name: ""
+ MappingInformationType: "NoMappingInformation"
+ ReferenceInformationType: "IndexToDirect"
+ BlendMode: "Translucent"
+ TextureAlpha: 1
+ TextureId: ''')
+ file.write('\n\t\t}')
+
+ # Done with UV/textures.
+ if do_materials:
+ file.write('\n\t\tLayerElementMaterial: 0 {')
+ file.write('\n\t\t\tVersion: 101')
+ file.write('\n\t\t\tName: ""')
+
+ if len(my_mesh.blenMaterials) == 1:
+ file.write('\n\t\t\tMappingInformationType: "AllSame"')
+ else:
+ file.write('\n\t\t\tMappingInformationType: "ByPolygon"')
+
+ file.write('\n\t\t\tReferenceInformationType: "IndexToDirect"')
+ file.write('\n\t\t\tMaterials: ')
+
+ if len(my_mesh.blenMaterials) == 1:
+ file.write('0')
+ else:
+ # Build a material mapping for this
+ material_mapping_local = {} # local-mat & tex : global index.
+
+ for j, mat_tex_pair in enumerate(my_mesh.blenMaterials):
+ material_mapping_local[mat_tex_pair] = j
+
+ len_material_mapping_local = len(material_mapping_local)
+
+ mats = my_mesh.blenMaterialList
+
+ if me.uv_textures.active:
+ uv_faces = me.uv_textures.active.data
+ else:
+ uv_faces = [None] * len(me_faces)
+
+ i = -1
+ for f, uf in zip(me_faces, uv_faces):
+# for f in me_faces:
+ try:
+ mat = mats[f.material_index]
+ except:
+ mat = None
+
+ if do_uvs:
+ tex = uf.image # WARNING - MULTI UV LAYER IMAGES NOT SUPPORTED :/
+ else:
+ tex = None
+
+ if i == -1:
+ i = 0
+ file.write('%s' % (material_mapping_local[mat, tex])) # None for mat or tex is ok
+ else:
+ if i == 55:
+ file.write('\n\t\t\t\t')
+ i = 0
+
+ file.write(',%s' % (material_mapping_local[mat, tex]))
+ i += 1
+
+ file.write('\n\t\t}')
+
+ file.write('''
+ Layer: 0 {
+ Version: 100
+ LayerElement: {
+ Type: "LayerElementNormal"
+ TypedIndex: 0
+ }''')
+
+ if do_materials:
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementMaterial"
+ TypedIndex: 0
+ }''')
+
+ # Always write this
+ if do_textures:
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementTexture"
+ TypedIndex: 0
+ }''')
+
+ if me.vertex_colors:
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementColor"
+ TypedIndex: 0
+ }''')
+
+ if do_uvs: # same as me.faceUV
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementUV"
+ TypedIndex: 0
+ }''')
+
+ file.write('\n\t\t}')
+
+ if len(uvlayers) > 1:
+ for i in range(1, len(uvlayers)):
+
+ file.write('\n\t\tLayer: %i {' % i)
+ file.write('\n\t\t\tVersion: 100')
+
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementUV"''')
+
+ file.write('\n\t\t\t\tTypedIndex: %i' % i)
+ file.write('\n\t\t\t}')
+
+ if do_textures:
+
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementTexture"''')
+
+ file.write('\n\t\t\t\tTypedIndex: %i' % i)
+ file.write('\n\t\t\t}')
+
+ file.write('\n\t\t}')
+
+ if len(collayers) > 1:
+ # Take into account any UV layers
+ layer_offset = 0
+ if uvlayers:
+ layer_offset = len(uvlayers) - 1
+
+ for i in range(layer_offset, len(collayers) + layer_offset):
+ file.write('\n\t\tLayer: %i {' % i)
+ file.write('\n\t\t\tVersion: 100')
+
+ file.write('''
+ LayerElement: {
+ Type: "LayerElementColor"''')
+
+ file.write('\n\t\t\t\tTypedIndex: %i' % i)
+ file.write('\n\t\t\t}')
+ file.write('\n\t\t}')
+ file.write('\n\t}')
+
+ def write_group(name):
+ file.write('\n\tGroupSelection: "GroupSelection::%s", "Default" {' % name)
+
+ file.write('''
+ Properties60: {
+ Property: "MultiLayer", "bool", "",0
+ Property: "Pickable", "bool", "",1
+ Property: "Transformable", "bool", "",1
+ Property: "Show", "bool", "",1
+ }
+ MultiLayer: 0
+ }''')
+
+ # add meshes here to clear because they are not used anywhere.
+ meshes_to_clear = []
+
+ ob_meshes = []
+ ob_lights = []
+ ob_cameras = []
+ # in fbx we export bones as children of the mesh
+ # armatures not a part of a mesh, will be added to ob_arms
+ ob_bones = []
+ ob_arms = []
+ ob_null = [] # emptys
+
+ # List of types that have blender objects (not bones)
+ ob_all_typegroups = [ob_meshes, ob_lights, ob_cameras, ob_arms, ob_null]
+
+ groups = [] # blender groups, only add ones that have objects in the selections
+ materials = {} # (mat, image) keys, should be a set()
+ textures = {} # should be a set()
+
+ tmp_ob_type = ob_type = None # incase no objects are exported, so as not to raise an error
+
+ # if EXP_OBS_SELECTED is false, use sceens objects
+ if not batch_objects:
+ if EXP_OBS_SELECTED:
+ tmp_objects = context.selected_objects
+ else:
+ tmp_objects = scene.objects
+ else:
+ tmp_objects = batch_objects
+
+ if EXP_ARMATURE:
+ # This is needed so applying modifiers dosnt apply the armature deformation, its also needed
+ # ...so mesh objects return their rest worldspace matrix when bone-parents are exported as weighted meshes.
+ # set every armature to its rest, backup the original values so we done mess up the scene
+ ob_arms_orig_rest = [arm.pose_position for arm in bpy.data.armatures]
+
+ for arm in bpy.data.armatures:
+ arm.pose_position = 'REST'
+
+ if ob_arms_orig_rest:
+ for ob_base in bpy.data.objects:
+ if ob_base.type == 'ARMATURE':
+ ob_base.update()
+
+ # This causes the makeDisplayList command to effect the mesh
+ scene.frame_set(scene.frame_current)
+
+ for ob_base in tmp_objects:
+
+ # ignore dupli children
+ if ob_base.parent and ob_base.parent.dupli_type != 'NONE':
+ continue
+
+ obs = [(ob_base, ob_base.matrix_world)]
+ if ob_base.dupli_type != 'NONE':
+ ob_base.create_dupli_list(scene)
+ obs = [(dob.object, dob.matrix) for dob in ob_base.dupli_list]
+
+ for ob, mtx in obs:
+# for ob, mtx in BPyObject.getDerivedObjects(ob_base):
+ tmp_ob_type = ob.type
+ if tmp_ob_type == 'CAMERA':
+ if EXP_CAMERA:
+ ob_cameras.append(my_object_generic(ob, mtx))
+ elif tmp_ob_type == 'LAMP':
+ if EXP_LAMP:
+ ob_lights.append(my_object_generic(ob, mtx))
+ elif tmp_ob_type == 'ARMATURE':
+ if EXP_ARMATURE:
+ # TODO - armatures dont work in dupligroups!
+ if ob not in ob_arms:
+ ob_arms.append(ob)
+ # ob_arms.append(ob) # replace later. was "ob_arms.append(sane_obname(ob), ob)"
+ elif tmp_ob_type == 'EMPTY':
+ if EXP_EMPTY:
+ ob_null.append(my_object_generic(ob, mtx))
+ elif EXP_MESH:
+ origData = True
+ if tmp_ob_type != 'MESH':
+ try:
+ me = ob.create_mesh(scene, True, 'PREVIEW')
+ except:
+ me = None
+
+ if me:
+ meshes_to_clear.append(me)
+ mats = me.materials
+ origData = False
+ else:
+ # Mesh Type!
+ if EXP_MESH_APPLY_MOD:
+ me = ob.create_mesh(scene, True, 'PREVIEW')
+
+ # print ob, me, me.getVertGroupNames()
+ meshes_to_clear.append(me)
+ origData = False
+ mats = me.materials
+ else:
+ me = ob.data
+ mats = me.materials
+
+# # Support object colors
+# tmp_colbits = ob.colbits
+# if tmp_colbits:
+# tmp_ob_mats = ob.getMaterials(1) # 1 so we get None's too.
+# for i in xrange(16):
+# if tmp_colbits & (1<<i):
+# mats[i] = tmp_ob_mats[i]
+# del tmp_ob_mats
+# del tmp_colbits
+
+ if me:
+# # This WILL modify meshes in blender if EXP_MESH_APPLY_MOD is disabled.
+# # so strictly this is bad. but only in rare cases would it have negative results
+# # say with dupliverts the objects would rotate a bit differently
+# if EXP_MESH_HQ_NORMALS:
+# BPyMesh.meshCalcNormals(me) # high quality normals nice for realtime engines.
+
+ texture_mapping_local = {}
+ material_mapping_local = {}
+ if me.uv_textures:
+ for uvlayer in me.uv_textures:
+ for f, uf in zip(me.faces, uvlayer.data):
+ tex = uf.image
+ textures[tex] = texture_mapping_local[tex] = None
+
+ try:
+ mat = mats[f.material_index]
+ except:
+ mat = None
+
+ materials[mat, tex] = material_mapping_local[mat, tex] = None # should use sets, wait for blender 2.5
+
+ else:
+ for mat in mats:
+ # 2.44 use mat.lib too for uniqueness
+ materials[mat, None] = material_mapping_local[mat, None] = None
+ else:
+ materials[None, None] = None
+
+ if EXP_ARMATURE:
+ armob = ob.find_armature()
+ blenParentBoneName = None
+
+ # parent bone - special case
+ if (not armob) and ob.parent and ob.parent.type == 'ARMATURE' and \
+ ob.parent_type == 'BONE':
+ armob = ob.parent
+ blenParentBoneName = ob.parent_bone
+
+ if armob and armob not in ob_arms:
+ ob_arms.append(armob)
+
+ # Warning for scaled, mesh objects with armatures
+ if abs(ob.scale[0] - 1.0) > 0.05 or abs(ob.scale[1] - 1.0) > 0.05 or abs(ob.scale[1] - 1.0) > 0.05:
+ operator.report('WARNING', "Object '%s' has a scale of (%.3f, %.3f, %.3f), Armature deformation will not work as expected!, Apply Scale to fix." % ((ob.name,) + tuple(ob.scale)))
+
+ else:
+ blenParentBoneName = armob = None
+
+ my_mesh = my_object_generic(ob, mtx)
+ my_mesh.blenData = me
+ my_mesh.origData = origData
+ my_mesh.blenMaterials = list(material_mapping_local.keys())
+ my_mesh.blenMaterialList = mats
+ my_mesh.blenTextures = list(texture_mapping_local.keys())
+
+ # if only 1 null texture then empty the list
+ if len(my_mesh.blenTextures) == 1 and my_mesh.blenTextures[0] is None:
+ my_mesh.blenTextures = []
+
+ my_mesh.fbxArm = armob # replace with my_object_generic armature instance later
+ my_mesh.fbxBoneParent = blenParentBoneName # replace with my_bone instance later
+
+ ob_meshes.append(my_mesh)
+
+ # not forgetting to free dupli_list
+ if ob_base.dupli_list:
+ ob_base.free_dupli_list()
+
+ if EXP_ARMATURE:
+ # now we have the meshes, restore the rest arm position
+ for i, arm in enumerate(bpy.data.armatures):
+ arm.pose_position = ob_arms_orig_rest[i]
+
+ if ob_arms_orig_rest:
+ for ob_base in bpy.data.objects:
+ if ob_base.type == 'ARMATURE':
+ ob_base.update()
+ # This causes the makeDisplayList command to effect the mesh
+ scene.frame_set(scene.frame_current)
+
+ del tmp_ob_type, tmp_objects
+
+ # now we have collected all armatures, add bones
+ for i, ob in enumerate(ob_arms):
+
+ ob_arms[i] = my_arm = my_object_generic(ob)
+
+ my_arm.fbxBones = []
+ my_arm.blenData = ob.data
+ if ob.animation_data:
+ my_arm.blenAction = ob.animation_data.action
+ else:
+ my_arm.blenAction = None
+# my_arm.blenAction = ob.action
+ my_arm.blenActionList = []
+
+ # fbxName, blenderObject, my_bones, blenderActions
+ #ob_arms[i] = fbxArmObName, ob, arm_my_bones, (ob.action, [])
+
+ for bone in my_arm.blenData.bones:
+ my_bone = my_bone_class(bone, my_arm)
+ my_arm.fbxBones.append(my_bone)
+ ob_bones.append(my_bone)
+
+ # add the meshes to the bones and replace the meshes armature with own armature class
+ #for obname, ob, mtx, me, mats, arm, armname in ob_meshes:
+ for my_mesh in ob_meshes:
+ # Replace
+ # ...this could be sped up with dictionary mapping but its unlikely for
+ # it ever to be a bottleneck - (would need 100+ meshes using armatures)
+ if my_mesh.fbxArm:
+ for my_arm in ob_arms:
+ if my_arm.blenObject == my_mesh.fbxArm:
+ my_mesh.fbxArm = my_arm
+ break
+
+ for my_bone in ob_bones:
+
+ # The mesh uses this bones armature!
+ if my_bone.fbxArm == my_mesh.fbxArm:
+ if my_bone.blenBone.use_deform:
+ my_bone.blenMeshes[my_mesh.fbxName] = me
+
+ # parent bone: replace bone names with our class instances
+ # my_mesh.fbxBoneParent is None or a blender bone name initialy, replacing if the names match.
+ if my_mesh.fbxBoneParent == my_bone.blenName:
+ my_mesh.fbxBoneParent = my_bone
+
+ bone_deformer_count = 0 # count how many bones deform a mesh
+ my_bone_blenParent = None
+ for my_bone in ob_bones:
+ my_bone_blenParent = my_bone.blenBone.parent
+ if my_bone_blenParent:
+ for my_bone_parent in ob_bones:
+ # Note 2.45rc2 you can compare bones normally
+ if my_bone_blenParent.name == my_bone_parent.blenName and my_bone.fbxArm == my_bone_parent.fbxArm:
+ my_bone.parent = my_bone_parent
+ break
+
+ # Not used at the moment
+ # my_bone.calcRestMatrixLocal()
+ bone_deformer_count += len(my_bone.blenMeshes)
+
+ del my_bone_blenParent
+
+ # Build blenObject -> fbxObject mapping
+ # this is needed for groups as well as fbxParenting
+ bpy.data.objects.tag(False)
+
+ # using a list of object names for tagging (Arystan)
+
+ tmp_obmapping = {}
+ for ob_generic in ob_all_typegroups:
+ for ob_base in ob_generic:
+ ob_base.blenObject.tag = True
+ tmp_obmapping[ob_base.blenObject] = ob_base
+
+ # Build Groups from objects we export
+ for blenGroup in bpy.data.groups:
+ fbxGroupName = None
+ for ob in blenGroup.objects:
+ if ob.tag:
+ if fbxGroupName is None:
+ fbxGroupName = sane_groupname(blenGroup)
+ groups.append((fbxGroupName, blenGroup))
+
+ tmp_obmapping[ob].fbxGroupNames.append(fbxGroupName) # also adds to the objects fbxGroupNames
+
+ groups.sort() # not really needed
+
+ # Assign parents using this mapping
+ for ob_generic in ob_all_typegroups:
+ for my_ob in ob_generic:
+ parent = my_ob.blenObject.parent
+ if parent and parent.tag: # does it exist and is it in the mapping
+ my_ob.fbxParent = tmp_obmapping[parent]
+
+ del tmp_obmapping
+ # Finished finding groups we use
+
+ materials = [(sane_matname(mat_tex_pair), mat_tex_pair) for mat_tex_pair in materials.keys()]
+ textures = [(sane_texname(tex), tex) for tex in textures.keys() if tex]
+ materials.sort() # sort by name
+ textures.sort()
+
+ camera_count = 8
+ file.write('''
+
+; Object definitions
+;------------------------------------------------------------------
+
+Definitions: {
+ Version: 100
+ Count: %i''' % (\
+ 1 + 1 + camera_count + \
+ len(ob_meshes) + \
+ len(ob_lights) + \
+ len(ob_cameras) + \
+ len(ob_arms) + \
+ len(ob_null) + \
+ len(ob_bones) + \
+ bone_deformer_count + \
+ len(materials) + \
+ (len(textures) * 2))) # add 1 for the root model 1 for global settings
+
+ del bone_deformer_count
+
+ file.write('''
+ ObjectType: "Model" {
+ Count: %i
+ }''' % (\
+ 1 + camera_count + \
+ len(ob_meshes) + \
+ len(ob_lights) + \
+ len(ob_cameras) + \
+ len(ob_arms) + \
+ len(ob_null) + \
+ len(ob_bones))) # add 1 for the root model
+
+ file.write('''
+ ObjectType: "Geometry" {
+ Count: %i
+ }''' % len(ob_meshes))
+
+ if materials:
+ file.write('''
+ ObjectType: "Material" {
+ Count: %i
+ }''' % len(materials))
+
+ if textures:
+ file.write('''
+ ObjectType: "Texture" {
+ Count: %i
+ }''' % len(textures)) # add 1 for an empty tex
+ file.write('''
+ ObjectType: "Video" {
+ Count: %i
+ }''' % len(textures)) # add 1 for an empty tex
+
+ tmp = 0
+ # Add deformer nodes
+ for my_mesh in ob_meshes:
+ if my_mesh.fbxArm:
+ tmp += 1
+
+ # Add subdeformers
+ for my_bone in ob_bones:
+ tmp += len(my_bone.blenMeshes)
+
+ if tmp:
+ file.write('''
+ ObjectType: "Deformer" {
+ Count: %i
+ }''' % tmp)
+ del tmp
+
+ # we could avoid writing this possibly but for now just write it
+
+ file.write('''
+ ObjectType: "Pose" {
+ Count: 1
+ }''')
+
+ if groups:
+ file.write('''
+ ObjectType: "GroupSelection" {
+ Count: %i
+ }''' % len(groups))
+
+ file.write('''
+ ObjectType: "GlobalSettings" {
+ Count: 1
+ }
+}''')
+
+ file.write('''
+
+; Object properties
+;------------------------------------------------------------------
+
+Objects: {''')
+
+ # To comply with other FBX FILES
+ write_camera_switch()
+
+ # Write the null object
+ write_null(None, 'blend_root') # , GLOBAL_MATRIX)
+
+ for my_null in ob_null:
+ write_null(my_null)
+
+ for my_arm in ob_arms:
+ write_null(my_arm)
+
+ for my_cam in ob_cameras:
+ write_camera(my_cam)
+
+ for my_light in ob_lights:
+ write_light(my_light)
+
+ for my_mesh in ob_meshes:
+ write_mesh(my_mesh)
+
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ write_bone(my_bone)
+
+ write_camera_default()
+
+ for matname, (mat, tex) in materials:
+ write_material(matname, mat) # We only need to have a material per image pair, but no need to write any image info into the material (dumb fbx standard)
+
+ # each texture uses a video, odd
+ for texname, tex in textures:
+ write_video(texname, tex)
+ i = 0
+ for texname, tex in textures:
+ write_texture(texname, tex, i)
+ i += 1
+
+ for groupname, group in groups:
+ write_group(groupname)
+
+ # NOTE - c4d and motionbuilder dont need normalized weights, but deep-exploration 5 does and (max?) do.
+
+ # Write armature modifiers
+ # TODO - add another MODEL? - because of this skin definition.
+ for my_mesh in ob_meshes:
+ if my_mesh.fbxArm:
+ write_deformer_skin(my_mesh.fbxName)
+
+ # Get normalized weights for temorary use
+ if my_mesh.fbxBoneParent:
+ weights = None
+ else:
+ weights = meshNormalizedWeights(my_mesh.blenObject, my_mesh.blenData)
+
+ #for bonename, bone, obname, bone_mesh, armob in ob_bones:
+ for my_bone in ob_bones:
+ if me in iter(my_bone.blenMeshes.values()):
+ write_sub_deformer_skin(my_mesh, my_bone, weights)
+
+ # Write pose's really weired, only needed when an armature and mesh are used together
+ # each by themselves dont need pose data. for now only pose meshes and bones
+
+ file.write('''
+ Pose: "Pose::BIND_POSES", "BindPose" {
+ Type: "BindPose"
+ Version: 100
+ Properties60: {
+ }
+ NbPoseNodes: ''')
+ file.write(str(len(pose_items)))
+
+ for fbxName, matrix in pose_items:
+ file.write('\n\t\tPoseNode: {')
+ file.write('\n\t\t\tNode: "Model::%s"' % fbxName)
+ file.write('\n\t\t\tMatrix: %s' % mat4x4str(matrix if matrix else Matrix()))
+ file.write('\n\t\t}')
+
+ file.write('\n\t}')
+
+ # Finish Writing Objects
+ # Write global settings
+ file.write('''
+ GlobalSettings: {
+ Version: 1000
+ Properties60: {
+ Property: "UpAxis", "int", "",1
+ Property: "UpAxisSign", "int", "",1
+ Property: "FrontAxis", "int", "",2
+ Property: "FrontAxisSign", "int", "",1
+ Property: "CoordAxis", "int", "",0
+ Property: "CoordAxisSign", "int", "",1
+ Property: "UnitScaleFactor", "double", "",100
+ }
+ }
+''')
+ file.write('}')
+
+ file.write('''
+
+; Object relations
+;------------------------------------------------------------------
+
+Relations: {''')
+
+ file.write('\n\tModel: "Model::blend_root", "Null" {\n\t}')
+
+ for my_null in ob_null:
+ file.write('\n\tModel: "Model::%s", "Null" {\n\t}' % my_null.fbxName)
+
+ for my_arm in ob_arms:
+ file.write('\n\tModel: "Model::%s", "Null" {\n\t}' % my_arm.fbxName)
+
+ for my_mesh in ob_meshes:
+ file.write('\n\tModel: "Model::%s", "Mesh" {\n\t}' % my_mesh.fbxName)
+
+ # TODO - limbs can have the same name for multiple armatures, should prefix.
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ file.write('\n\tModel: "Model::%s", "Limb" {\n\t}' % my_bone.fbxName)
+
+ for my_cam in ob_cameras:
+ file.write('\n\tModel: "Model::%s", "Camera" {\n\t}' % my_cam.fbxName)
+
+ for my_light in ob_lights:
+ file.write('\n\tModel: "Model::%s", "Light" {\n\t}' % my_light.fbxName)
+
+ file.write('''
+ Model: "Model::Producer Perspective", "Camera" {
+ }
+ Model: "Model::Producer Top", "Camera" {
+ }
+ Model: "Model::Producer Bottom", "Camera" {
+ }
+ Model: "Model::Producer Front", "Camera" {
+ }
+ Model: "Model::Producer Back", "Camera" {
+ }
+ Model: "Model::Producer Right", "Camera" {
+ }
+ Model: "Model::Producer Left", "Camera" {
+ }
+ Model: "Model::Camera Switcher", "CameraSwitcher" {
+ }''')
+
+ for matname, (mat, tex) in materials:
+ file.write('\n\tMaterial: "Material::%s", "" {\n\t}' % matname)
+
+ if textures:
+ for texname, tex in textures:
+ file.write('\n\tTexture: "Texture::%s", "TextureVideoClip" {\n\t}' % texname)
+ for texname, tex in textures:
+ file.write('\n\tVideo: "Video::%s", "Clip" {\n\t}' % texname)
+
+ # deformers - modifiers
+ for my_mesh in ob_meshes:
+ if my_mesh.fbxArm:
+ file.write('\n\tDeformer: "Deformer::Skin %s", "Skin" {\n\t}' % my_mesh.fbxName)
+
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ for fbxMeshObName in my_bone.blenMeshes: # .keys() - fbxMeshObName
+ # is this bone effecting a mesh?
+ file.write('\n\tDeformer: "SubDeformer::Cluster %s %s", "Cluster" {\n\t}' % (fbxMeshObName, my_bone.fbxName))
+
+ # This should be at the end
+ # file.write('\n\tPose: "Pose::BIND_POSES", "BindPose" {\n\t}')
+
+ for groupname, group in groups:
+ file.write('\n\tGroupSelection: "GroupSelection::%s", "Default" {\n\t}' % groupname)
+
+ file.write('\n}')
+ file.write('''
+
+; Object connections
+;------------------------------------------------------------------
+
+Connections: {''')
+
+ # NOTE - The FBX SDK dosnt care about the order but some importers DO!
+ # for instance, defining the material->mesh connection
+ # before the mesh->blend_root crashes cinema4d
+
+ # write the fake root node
+ file.write('\n\tConnect: "OO", "Model::blend_root", "Model::Scene"')
+
+ for ob_generic in ob_all_typegroups: # all blender 'Object's we support
+ for my_ob in ob_generic:
+ if my_ob.fbxParent:
+ file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_ob.fbxName, my_ob.fbxParent.fbxName))
+ else:
+ file.write('\n\tConnect: "OO", "Model::%s", "Model::blend_root"' % my_ob.fbxName)
+
+ if materials:
+ for my_mesh in ob_meshes:
+ # Connect all materials to all objects, not good form but ok for now.
+ for mat, tex in my_mesh.blenMaterials:
+ mat_name = mat.name if mat else None
+ tex_name = tex.name if tex else None
+
+ file.write('\n\tConnect: "OO", "Material::%s", "Model::%s"' % (sane_name_mapping_mat[mat_name, tex_name], my_mesh.fbxName))
+
+ if textures:
+ for my_mesh in ob_meshes:
+ if my_mesh.blenTextures:
+ # file.write('\n\tConnect: "OO", "Texture::_empty_", "Model::%s"' % my_mesh.fbxName)
+ for tex in my_mesh.blenTextures:
+ if tex:
+ file.write('\n\tConnect: "OO", "Texture::%s", "Model::%s"' % (sane_name_mapping_tex[tex.name], my_mesh.fbxName))
+
+ for texname, tex in textures:
+ file.write('\n\tConnect: "OO", "Video::%s", "Texture::%s"' % (texname, texname))
+
+ for my_mesh in ob_meshes:
+ if my_mesh.fbxArm:
+ file.write('\n\tConnect: "OO", "Deformer::Skin %s", "Model::%s"' % (my_mesh.fbxName, my_mesh.fbxName))
+
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ for fbxMeshObName in my_bone.blenMeshes: # .keys()
+ file.write('\n\tConnect: "OO", "SubDeformer::Cluster %s %s", "Deformer::Skin %s"' % (fbxMeshObName, my_bone.fbxName, fbxMeshObName))
+
+ # limbs -> deformers
+ # for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ for fbxMeshObName in my_bone.blenMeshes: # .keys()
+ file.write('\n\tConnect: "OO", "Model::%s", "SubDeformer::Cluster %s %s"' % (my_bone.fbxName, fbxMeshObName, my_bone.fbxName))
+
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for my_bone in ob_bones:
+ # Always parent to armature now
+ if my_bone.parent:
+ file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_bone.fbxName, my_bone.parent.fbxName))
+ else:
+ # the armature object is written as an empty and all root level bones connect to it
+ file.write('\n\tConnect: "OO", "Model::%s", "Model::%s"' % (my_bone.fbxName, my_bone.fbxArm.fbxName))
+
+ # groups
+ if groups:
+ for ob_generic in ob_all_typegroups:
+ for ob_base in ob_generic:
+ for fbxGroupName in ob_base.fbxGroupNames:
+ file.write('\n\tConnect: "OO", "Model::%s", "GroupSelection::%s"' % (ob_base.fbxName, fbxGroupName))
+
+ for my_arm in ob_arms:
+ file.write('\n\tConnect: "OO", "Model::%s", "Model::blend_root"' % my_arm.fbxName)
+
+ file.write('\n}')
+
+ # Needed for scene footer as well as animation
+ render = scene.render
+
+ # from the FBX sdk
+ #define KTIME_ONE_SECOND KTime (K_LONGLONG(46186158000))
+ def fbx_time(t):
+ # 0.5 + val is the same as rounding.
+ return int(0.5 + ((t / fps) * 46186158000))
+
+ fps = float(render.fps)
+ start = scene.frame_start
+ end = scene.frame_end
+ if end < start:
+ start, end = end, st
+
+ # comment the following line, otherwise we dont get the pose
+ # if start==end: ANIM_ENABLE = False
+
+ # animations for these object types
+ ob_anim_lists = ob_bones, ob_meshes, ob_null, ob_cameras, ob_lights, ob_arms
+
+ if ANIM_ENABLE and [tmp for tmp in ob_anim_lists if tmp]:
+
+ frame_orig = scene.frame_current
+
+ if ANIM_OPTIMIZE:
+ ANIM_OPTIMIZE_PRECISSION_FLOAT = 0.1 ** ANIM_OPTIMIZE_PRECISSION
+
+ # default action, when no actions are avaioable
+ tmp_actions = []
+ blenActionDefault = None
+ action_lastcompat = None
+
+ # instead of tagging
+ tagged_actions = []
+
+ if ANIM_ACTION_ALL:
+# bpy.data.actions.tag = False
+ tmp_actions = bpy.data.actions[:]
+
+ # find which actions are compatible with the armatures
+ # blenActions is not yet initialized so do it now.
+ tmp_act_count = 0
+ for my_arm in ob_arms:
+
+ # get the default name
+ if not blenActionDefault:
+ blenActionDefault = my_arm.blenAction
+
+ arm_bone_names = set([my_bone.blenName for my_bone in my_arm.fbxBones])
+
+ for action in tmp_actions:
+
+ action_chan_names = arm_bone_names.intersection(set([g.name for g in action.groups]))
+# action_chan_names = arm_bone_names.intersection( set(action.getChannelNames()) )
+
+ if action_chan_names: # at least one channel matches.
+ my_arm.blenActionList.append(action)
+ tagged_actions.append(action.name)
+# action.tag = True
+ tmp_act_count += 1
+
+ # incase there is no actions applied to armatures
+ action_lastcompat = action
+
+ if tmp_act_count:
+ # unlikely to ever happen but if no actions applied to armatures, just use the last compatible armature.
+ if not blenActionDefault:
+ blenActionDefault = action_lastcompat
+
+ del action_lastcompat
+
+ tmp_actions.insert(0, None) # None is the default action
+
+ file.write('''
+;Takes and animation section
+;----------------------------------------------------
+
+Takes: {''')
+
+ if blenActionDefault:
+ file.write('\n\tCurrent: "%s"' % sane_takename(blenActionDefault))
+ else:
+ file.write('\n\tCurrent: "Default Take"')
+
+ for blenAction in tmp_actions:
+ # we have tagged all actious that are used be selected armatures
+ if blenAction:
+ if blenAction.name in tagged_actions:
+# if blenAction.tag:
+ print('\taction: "%s" exporting...' % blenAction.name)
+ else:
+ print('\taction: "%s" has no armature using it, skipping' % blenAction.name)
+ continue
+
+ if blenAction is None:
+ # Warning, this only accounts for tmp_actions being [None]
+ file.write('\n\tTake: "Default Take" {')
+ act_start = start
+ act_end = end
+ else:
+ # use existing name
+ if blenAction == blenActionDefault: # have we already got the name
+ file.write('\n\tTake: "%s" {' % sane_name_mapping_take[blenAction.name])
+ else:
+ file.write('\n\tTake: "%s" {' % sane_takename(blenAction))
+
+ act_start, act_end = blenAction.frame_range
+ act_start = int(act_start)
+ act_end = int(act_end)
+
+ # Set the action active
+ for my_arm in ob_arms:
+ if my_arm.blenObject.animation_data and blenAction in my_arm.blenActionList:
+ my_arm.blenObject.animation_data.action = blenAction
+ # print('\t\tSetting Action!', blenAction)
+ # scene.update(1)
+
+ file.write('\n\t\tFileName: "Default_Take.tak"') # ??? - not sure why this is needed
+ file.write('\n\t\tLocalTime: %i,%i' % (fbx_time(act_start - 1), fbx_time(act_end - 1))) # ??? - not sure why this is needed
+ file.write('\n\t\tReferenceTime: %i,%i' % (fbx_time(act_start - 1), fbx_time(act_end - 1))) # ??? - not sure why this is needed
+
+ file.write('''
+
+ ;Models animation
+ ;----------------------------------------------------''')
+
+ # set pose data for all bones
+ # do this here incase the action changes
+ '''
+ for my_bone in ob_bones:
+ my_bone.flushAnimData()
+ '''
+ i = act_start
+ while i <= act_end:
+ scene.frame_set(i)
+ for ob_generic in ob_anim_lists:
+ for my_ob in ob_generic:
+ #Blender.Window.RedrawAll()
+ if ob_generic == ob_meshes and my_ob.fbxArm:
+ # We cant animate armature meshes!
+ my_ob.setPoseFrame(i, fake=True)
+ else:
+ my_ob.setPoseFrame(i)
+
+ i += 1
+
+ #for bonename, bone, obname, me, armob in ob_bones:
+ for ob_generic in (ob_bones, ob_meshes, ob_null, ob_cameras, ob_lights, ob_arms):
+
+ for my_ob in ob_generic:
+
+ if ob_generic == ob_meshes and my_ob.fbxArm:
+ # do nothing,
+ pass
+ else:
+
+ file.write('\n\t\tModel: "Model::%s" {' % my_ob.fbxName) # ??? - not sure why this is needed
+ file.write('\n\t\t\tVersion: 1.1')
+ file.write('\n\t\t\tChannel: "Transform" {')
+
+ context_bone_anim_mats = [(my_ob.getAnimParRelMatrix(frame), my_ob.getAnimParRelMatrixRot(frame)) for frame in range(act_start, act_end + 1)]
+
+ # ----------------
+ # ----------------
+ for TX_LAYER, TX_CHAN in enumerate('TRS'): # transform, rotate, scale
+
+ if TX_CHAN == 'T':
+ context_bone_anim_vecs = [mtx[0].translation_part() for mtx in context_bone_anim_mats]
+ elif TX_CHAN == 'S':
+ context_bone_anim_vecs = [mtx[0].scale_part() for mtx in context_bone_anim_mats]
+ elif TX_CHAN == 'R':
+ # Was....
+ # elif TX_CHAN=='R': context_bone_anim_vecs = [mtx[1].to_euler() for mtx in context_bone_anim_mats]
+ #
+ # ...but we need to use the previous euler for compatible conversion.
+ context_bone_anim_vecs = []
+ prev_eul = None
+ for mtx in context_bone_anim_mats:
+ if prev_eul:
+ prev_eul = mtx[1].to_euler('XYZ', prev_eul)
+ else:
+ prev_eul = mtx[1].to_euler()
+ context_bone_anim_vecs.append(tuple_rad_to_deg(prev_eul))
+
+ file.write('\n\t\t\t\tChannel: "%s" {' % TX_CHAN) # translation
+
+ for i in range(3):
+ # Loop on each axis of the bone
+ file.write('\n\t\t\t\t\tChannel: "%s" {' % ('XYZ'[i])) # translation
+ file.write('\n\t\t\t\t\t\tDefault: %.15f' % context_bone_anim_vecs[0][i])
+ file.write('\n\t\t\t\t\t\tKeyVer: 4005')
+
+ if not ANIM_OPTIMIZE:
+ # Just write all frames, simple but in-eficient
+ file.write('\n\t\t\t\t\t\tKeyCount: %i' % (1 + act_end - act_start))
+ file.write('\n\t\t\t\t\t\tKey: ')
+ frame = act_start
+ while frame <= act_end:
+ if frame != act_start:
+ file.write(',')
+
+ # Curve types are 'C,n' for constant, 'L' for linear
+ # C,n is for bezier? - linear is best for now so we can do simple keyframe removal
+ file.write('\n\t\t\t\t\t\t\t%i,%.15f,L' % (fbx_time(frame - 1), context_bone_anim_vecs[frame - act_start][i]))
+ frame += 1
+ else:
+ # remove unneeded keys, j is the frame, needed when some frames are removed.
+ context_bone_anim_keys = [(vec[i], j) for j, vec in enumerate(context_bone_anim_vecs)]
+
+ # last frame to fisrt frame, missing 1 frame on either side.
+ # removeing in a backwards loop is faster
+ #for j in xrange( (act_end-act_start)-1, 0, -1 ):
+ # j = (act_end-act_start)-1
+ j = len(context_bone_anim_keys) - 2
+ while j > 0 and len(context_bone_anim_keys) > 2:
+ # print j, len(context_bone_anim_keys)
+ # Is this key the same as the ones next to it?
+
+ # co-linear horizontal...
+ if abs(context_bone_anim_keys[j][0] - context_bone_anim_keys[j - 1][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT and \
+ abs(context_bone_anim_keys[j][0] - context_bone_anim_keys[j + 1][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT:
+
+ del context_bone_anim_keys[j]
+
+ else:
+ frame_range = float(context_bone_anim_keys[j + 1][1] - context_bone_anim_keys[j - 1][1])
+ frame_range_fac1 = (context_bone_anim_keys[j + 1][1] - context_bone_anim_keys[j][1]) / frame_range
+ frame_range_fac2 = 1.0 - frame_range_fac1
+
+ if abs(((context_bone_anim_keys[j - 1][0] * frame_range_fac1 + context_bone_anim_keys[j + 1][0] * frame_range_fac2)) - context_bone_anim_keys[j][0]) < ANIM_OPTIMIZE_PRECISSION_FLOAT:
+ del context_bone_anim_keys[j]
+ else:
+ j -= 1
+
+ # keep the index below the list length
+ if j > len(context_bone_anim_keys) - 2:
+ j = len(context_bone_anim_keys) - 2
+
+ if len(context_bone_anim_keys) == 2 and context_bone_anim_keys[0][0] == context_bone_anim_keys[1][0]:
+
+ # This axis has no moton, its okay to skip KeyCount and Keys in this case
+ # pass
+
+ # better write one, otherwise we loose poses with no animation
+ file.write('\n\t\t\t\t\t\tKeyCount: 1')
+ file.write('\n\t\t\t\t\t\tKey: ')
+ file.write('\n\t\t\t\t\t\t\t%i,%.15f,L' % (fbx_time(start), context_bone_anim_keys[0][0]))
+ else:
+ # We only need to write these if there is at least one
+ file.write('\n\t\t\t\t\t\tKeyCount: %i' % len(context_bone_anim_keys))
+ file.write('\n\t\t\t\t\t\tKey: ')
+ for val, frame in context_bone_anim_keys:
+ if frame != context_bone_anim_keys[0][1]: # not the first
+ file.write(',')
+ # frame is already one less then blenders frame
+ file.write('\n\t\t\t\t\t\t\t%i,%.15f,L' % (fbx_time(frame), val))
+
+ if i == 0:
+ file.write('\n\t\t\t\t\t\tColor: 1,0,0')
+ elif i == 1:
+ file.write('\n\t\t\t\t\t\tColor: 0,1,0')
+ elif i == 2:
+ file.write('\n\t\t\t\t\t\tColor: 0,0,1')
+
+ file.write('\n\t\t\t\t\t}')
+ file.write('\n\t\t\t\t\tLayerType: %i' % (TX_LAYER + 1))
+ file.write('\n\t\t\t\t}')
+
+ # ---------------
+
+ file.write('\n\t\t\t}')
+ file.write('\n\t\t}')
+
+ # end the take
+ file.write('\n\t}')
+
+ # end action loop. set original actions
+ # do this after every loop incase actions effect eachother.
+ for my_arm in ob_arms:
+ if my_arm.blenObject.animation_data:
+ my_arm.blenObject.animation_data.action = my_arm.blenAction
+
+ file.write('\n}')
+
+ scene.frame_set(frame_orig)
+
+ else:
+ # no animation
+ file.write('\n;Takes and animation section')
+ file.write('\n;----------------------------------------------------')
+ file.write('\n')
+ file.write('\nTakes: {')
+ file.write('\n\tCurrent: ""')
+ file.write('\n}')
+
+ # write meshes animation
+ #for obname, ob, mtx, me, mats, arm, armname in ob_meshes:
+
+ # Clear mesh data Only when writing with modifiers applied
+ for me in meshes_to_clear:
+ bpy.data.meshes.remove(me)
+
+ # --------------------------- Footer
+ if world:
+ m = world.mist_settings
+ has_mist = m.use_mist
+ mist_intense = m.intensity
+ mist_start = m.start
+ mist_end = m.depth
+ mist_height = m.height
+ world_hor = world.horizon_color
+ else:
+ has_mist = mist_intense = mist_start = mist_end = mist_height = 0
+ world_hor = 0, 0, 0
+
+ file.write('\n;Version 5 settings')
+ file.write('\n;------------------------------------------------------------------')
+ file.write('\n')
+ file.write('\nVersion5: {')
+ file.write('\n\tAmbientRenderSettings: {')
+ file.write('\n\t\tVersion: 101')
+ file.write('\n\t\tAmbientLightColor: %.1f,%.1f,%.1f,0' % tuple(world_amb))
+ file.write('\n\t}')
+ file.write('\n\tFogOptions: {')
+ file.write('\n\t\tFlogEnable: %i' % has_mist)
+ file.write('\n\t\tFogMode: 0')
+ file.write('\n\t\tFogDensity: %.3f' % mist_intense)
+ file.write('\n\t\tFogStart: %.3f' % mist_start)
+ file.write('\n\t\tFogEnd: %.3f' % mist_end)
+ file.write('\n\t\tFogColor: %.1f,%.1f,%.1f,1' % tuple(world_hor))
+ file.write('\n\t}')
+ file.write('\n\tSettings: {')
+ file.write('\n\t\tFrameRate: "%i"' % int(fps))
+ file.write('\n\t\tTimeFormat: 1')
+ file.write('\n\t\tSnapOnFrames: 0')
+ file.write('\n\t\tReferenceTimeIndex: -1')
+ file.write('\n\t\tTimeLineStartTime: %i' % fbx_time(start - 1))
+ file.write('\n\t\tTimeLineStopTime: %i' % fbx_time(end - 1))
+ file.write('\n\t}')
+ file.write('\n\tRendererSetting: {')
+ file.write('\n\t\tDefaultCamera: "Producer Perspective"')
+ file.write('\n\t\tDefaultViewingMode: 0')
+ file.write('\n\t}')
+ file.write('\n}')
+ file.write('\n')
+
+ # XXX, shouldnt be global!
+ sane_name_mapping_ob.clear()
+ sane_name_mapping_mat.clear()
+ sane_name_mapping_tex.clear()
+ sane_name_mapping_take.clear()
+ sane_name_mapping_group.clear()
+
+ ob_arms[:] = []
+ ob_bones[:] = []
+ ob_cameras[:] = []
+ ob_lights[:] = []
+ ob_meshes[:] = []
+ ob_null[:] = []
+
+ # copy images if enabled
+# if EXP_IMAGE_COPY:
+# # copy_images( basepath, [ tex[1] for tex in textures if tex[1] != None ])
+# bpy.util.copy_images( [ tex[1] for tex in textures if tex[1] != None ], basepath)
+ file.close()
+
+ print('export finished in %.4f sec.' % (time.clock() - start_time))
+ return {'FINISHED'}
+
+
+# NOTES (all line numbers correspond to original export_fbx.py (under release/scripts)
+# - Draw.PupMenu alternative in 2.5?, temporarily replaced PupMenu with print
+# - get rid of bpy.path.clean_name somehow
+# + fixed: isinstance(inst, bpy.types.*) doesn't work on RNA objects: line 565
+# + get rid of BPyObject_getObjectArmature, move it in RNA?
+# - BATCH_ENABLE and BATCH_GROUP options: line 327
+# - implement all BPyMesh_* used here with RNA
+# - getDerivedObjects is not fully replicated with .dupli* funcs
+# - talk to Campbell, this code won't work? lines 1867-1875
+# - don't know what those colbits are, do we need them? they're said to be deprecated in DNA_object_types.h: 1886-1893
+# - no hq normals: 1900-1901
+
+# TODO
+
+# - bpy.data.remove_scene: line 366
+# - bpy.sys.time move to bpy.sys.util?
+# - new scene creation, activation: lines 327-342, 368
+# - uses bpy.path.abspath, *.relpath - replace at least relpath
diff --git a/io_scene_obj/__init__.py b/io_scene_obj/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc7422d376ff92f9b6684133ead175092923b844
--- /dev/null
+++ b/io_scene_obj/__init__.py
@@ -0,0 +1,143 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "Wavefront OBJ format",
+ "author": "Campbell Barton",
+ "location": "File > Import-Export",
+ "description": "Import-Export X3D, Import OBJ mesh, UV's, materials and textures",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/Wavefront_OBJ",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "import_obj" in locals():
+ imp.reload(import_obj)
+ if "export_obj" in locals():
+ imp.reload(export_obj)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ExportHelper, ImportHelper
+
+
+class ImportOBJ(bpy.types.Operator, ImportHelper):
+ '''Load a Wavefront OBJ File'''
+ bl_idname = "import_scene.obj"
+ bl_label = "Import OBJ"
+
+ filename_ext = ".obj"
+ filter_glob = StringProperty(default="*.obj;*.mtl", options={'HIDDEN'})
+
+ CREATE_SMOOTH_GROUPS = BoolProperty(name="Smooth Groups", description="Surround smooth groups by sharp edges", default=True)
+ CREATE_FGONS = BoolProperty(name="NGons as FGons", description="Import faces with more then 4 verts as fgons", default=True)
+ CREATE_EDGES = BoolProperty(name="Lines as Edges", description="Import lines and faces with 2 verts as edge", default=True)
+ SPLIT_OBJECTS = BoolProperty(name="Object", description="Import OBJ Objects into Blender Objects", default=True)
+ SPLIT_GROUPS = BoolProperty(name="Group", description="Import OBJ Groups into Blender Objects", default=True)
+ # old comment: only used for user feedback
+ # disabled this option because in old code a handler for it disabled SPLIT* params, it's not passed to load_obj
+ # KEEP_VERT_ORDER = BoolProperty(name="Keep Vert Order", description="Keep vert and face order, disables split options, enable for morph targets", default= True)
+ ROTATE_X90 = BoolProperty(name="-X90", description="Rotate X 90.", default=True)
+ CLAMP_SIZE = FloatProperty(name="Clamp Scale", description="Clamp the size to this maximum (Zero to Disable)", min=0.0, max=1000.0, soft_min=0.0, soft_max=1000.0, default=0.0)
+ POLYGROUPS = BoolProperty(name="Poly Groups", description="Import OBJ groups as vertex groups.", default=True)
+ IMAGE_SEARCH = BoolProperty(name="Image Search", description="Search subdirs for any assosiated images (Warning, may be slow)", default=True)
+
+ def execute(self, context):
+ # print("Selected: " + context.active_object.name)
+ from . import import_obj
+ return import_obj.load(self, context, **self.as_keywords(ignore=("filter_glob",)))
+
+
+class ExportOBJ(bpy.types.Operator, ExportHelper):
+ '''Save a Wavefront OBJ File'''
+
+ bl_idname = "export_scene.obj"
+ bl_label = 'Export OBJ'
+ bl_options = {'PRESET'}
+
+ filename_ext = ".obj"
+ filter_glob = StringProperty(default="*.obj;*.mtl", options={'HIDDEN'})
+
+ # List of operator properties, the attributes will be assigned
+ # to the class instance from the operator settings before calling.
+
+ # context group
+ use_selection = BoolProperty(name="Selection Only", description="Export selected objects only", default=False)
+ use_all_scenes = BoolProperty(name="All Scenes", description="", default=False)
+ use_animation = BoolProperty(name="Animation", description="", default=False)
+
+ # object group
+ use_modifiers = BoolProperty(name="Apply Modifiers", description="Apply modifiers (preview resolution)", default=True)
+ use_rotate_x90 = BoolProperty(name="Rotate X90", description="", default=True)
+
+ # extra data group
+ use_edges = BoolProperty(name="Edges", description="", default=True)
+ use_normals = BoolProperty(name="Normals", description="", default=False)
+ use_hq_normals = BoolProperty(name="High Quality Normals", description="", default=True)
+ use_uvs = BoolProperty(name="UVs", description="", default=True)
+ use_materials = BoolProperty(name="Materials", description="", default=True)
+ copy_images = BoolProperty(name="Copy Images", description="", default=False)
+ use_triangles = BoolProperty(name="Triangulate", description="", default=False)
+ use_vertex_groups = BoolProperty(name="Polygroups", description="", default=False)
+ use_nurbs = BoolProperty(name="Nurbs", description="", default=False)
+
+ # grouping group
+ use_blen_objects = BoolProperty(name="Objects as OBJ Objects", description="", default=True)
+ group_by_object = BoolProperty(name="Objects as OBJ Groups ", description="", default=False)
+ group_by_material = BoolProperty(name="Material Groups", description="", default=False)
+ keep_vertex_order = BoolProperty(name="Keep Vertex Order", description="", default=False)
+
+ def execute(self, context):
+ from . import export_obj
+ return export_obj.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob")))
+
+
+def menu_func_import(self, context):
+ self.layout.operator(ImportOBJ.bl_idname, text="Wavefront (.obj)")
+
+
+def menu_func_export(self, context):
+ self.layout.operator(ExportOBJ.bl_idname, text="Wavefront (.obj)")
+
+
+def register():
+ bpy.types.INFO_MT_file_import.append(menu_func_import)
+ bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_import.remove(menu_func_import)
+ bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+
+# CONVERSION ISSUES
+# - matrix problem
+# - duplis - only tested dupliverts
+# - all scenes export
+# + normals calculation
+
+if __name__ == "__main__":
+ register()
diff --git a/io_scene_obj/export_obj.py b/io_scene_obj/export_obj.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b80b52f21df499b0fb919951105796859a32f5d
--- /dev/null
+++ b/io_scene_obj/export_obj.py
@@ -0,0 +1,836 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+import os
+import time
+import shutil
+
+import bpy
+import mathutils
+
+def fixName(name):
+ if name is None:
+ return 'None'
+ else:
+ return name.replace(' ', '_')
+
+def write_mtl(scene, filepath, copy_images, mtl_dict):
+
+ world = scene.world
+ if world:
+ worldAmb = world.ambient_color[:]
+ else:
+ worldAmb = 0.0, 0.0, 0.0
+
+ dest_dir = os.path.dirname(filepath)
+
+ def copy_image(image):
+ fn = bpy.path.abspath(image.filepath)
+ fn = os.path.normpath(fn)
+ fn_strip = os.path.basename(fn)
+
+ if copy_images:
+ rel = fn_strip
+ fn_abs_dest = os.path.join(dest_dir, fn_strip)
+ if not os.path.exists(fn_abs_dest):
+ shutil.copy(fn, fn_abs_dest)
+ elif bpy.path.is_subdir(fn, dest_dir):
+ rel = os.path.relpath(fn, dest_dir)
+ else:
+ rel = fn
+
+ return rel
+
+
+ file = open(filepath, "w", encoding='utf8')
+ file.write('# Blender MTL File: %r\n' % os.path.basename(bpy.data.filepath))
+ file.write('# Material Count: %i\n' % len(mtl_dict))
+ # Write material/image combinations we have used.
+ for key, (mtl_mat_name, mat, img) in mtl_dict.items():
+
+ # Get the Blender data for the material and the image.
+ # Having an image named None will make a bug, dont do it :)
+
+ file.write('newmtl %s\n' % mtl_mat_name) # Define a new material: matname_imgname
+
+ if mat:
+ file.write('Ns %.6f\n' % ((mat.specular_hardness-1) * 1.9607843137254901)) # Hardness, convert blenders 1-511 to MTL's
+ file.write('Ka %.6f %.6f %.6f\n' % tuple(c * mat.ambient for c in worldAmb)) # Ambient, uses mirror colour,
+ file.write('Kd %.6f %.6f %.6f\n' % tuple(c * mat.diffuse_intensity for c in mat.diffuse_color)) # Diffuse
+ file.write('Ks %.6f %.6f %.6f\n' % tuple(c * mat.specular_intensity for c in mat.specular_color)) # Specular
+ if hasattr(mat, "ior"):
+ file.write('Ni %.6f\n' % mat.ior) # Refraction index
+ else:
+ file.write('Ni %.6f\n' % 1.0)
+ file.write('d %.6f\n' % mat.alpha) # Alpha (obj uses 'd' for dissolve)
+
+ # 0 to disable lighting, 1 for ambient & diffuse only (specular color set to black), 2 for full lighting.
+ if mat.use_shadeless:
+ file.write('illum 0\n') # ignore lighting
+ elif mat.specular_intensity == 0:
+ file.write('illum 1\n') # no specular.
+ else:
+ file.write('illum 2\n') # light normaly
+
+ else:
+ #write a dummy material here?
+ file.write('Ns 0\n')
+ file.write('Ka %.6f %.6f %.6f\n' % tuple(c for c in worldAmb)) # Ambient, uses mirror colour,
+ file.write('Kd 0.8 0.8 0.8\n')
+ file.write('Ks 0.8 0.8 0.8\n')
+ file.write('d 1\n') # No alpha
+ file.write('illum 2\n') # light normaly
+
+ # Write images!
+ if img: # We have an image on the face!
+ # write relative image path
+ rel = copy_image(img)
+ file.write('map_Kd %s\n' % rel) # Diffuse mapping image
+# file.write('map_Kd %s\n' % img.filepath.split('\\')[-1].split('/')[-1]) # Diffuse mapping image
+
+ elif mat: # No face image. if we havea material search for MTex image.
+ for mtex in mat.texture_slots:
+ if mtex and mtex.texture.type == 'IMAGE':
+ try:
+ filepath = copy_image(mtex.texture.image)
+# filepath = mtex.texture.image.filepath.split('\\')[-1].split('/')[-1]
+ file.write('map_Kd %s\n' % repr(filepath)[1:-1]) # Diffuse mapping image
+ break
+ except:
+ # Texture has no image though its an image type, best ignore.
+ pass
+
+ file.write('\n\n')
+
+ file.close()
+
+# XXX not used
+def copy_file(source, dest):
+ file = open(source, 'rb')
+ data = file.read()
+ file.close()
+
+ file = open(dest, 'wb')
+ file.write(data)
+ file.close()
+
+
+# XXX not used
+def copy_images(dest_dir):
+ if dest_dir[-1] != os.sep:
+ dest_dir += os.sep
+
+ # Get unique image names
+ uniqueImages = {}
+ for matname, mat, image in mtl_dict.values(): # Only use image name
+ # Get Texface images
+ if image:
+ uniqueImages[image] = image # Should use sets here. wait until Python 2.4 is default.
+
+ # Get MTex images
+ if mat:
+ for mtex in mat.texture_slots:
+ if mtex and mtex.texture.type == 'IMAGE':
+ image_tex = mtex.texture.image
+ if image_tex:
+ try:
+ uniqueImages[image_tex] = image_tex
+ except:
+ pass
+
+ # Now copy images
+ copyCount = 0
+
+# for bImage in uniqueImages.values():
+# image_path = bpy.path.abspath(bImage.filepath)
+# if bpy.sys.exists(image_path):
+# # Make a name for the target path.
+# dest_image_path = dest_dir + image_path.split('\\')[-1].split('/')[-1]
+# if not bpy.utils.exists(dest_image_path): # Image isnt already there
+# print('\tCopying "%s" > "%s"' % (image_path, dest_image_path))
+# copy_file(image_path, dest_image_path)
+# copyCount+=1
+
+# paths= bpy.util.copy_images(uniqueImages.values(), dest_dir)
+
+ print('\tCopied %d images' % copyCount)
+
+
+def test_nurbs_compat(ob):
+ if ob.type != 'CURVE':
+ return False
+
+ for nu in ob.data.splines:
+ if nu.point_count_v == 1 and nu.type != 'BEZIER': # not a surface and not bezier
+ return True
+
+ return False
+
+
+def write_nurb(file, ob, ob_mat):
+ tot_verts = 0
+ cu = ob.data
+
+ # use negative indices
+ for nu in cu.splines:
+ if nu.type == 'POLY':
+ DEG_ORDER_U = 1
+ else:
+ DEG_ORDER_U = nu.order_u - 1 # odd but tested to be correct
+
+ if nu.type == 'BEZIER':
+ print("\tWarning, bezier curve:", ob.name, "only poly and nurbs curves supported")
+ continue
+
+ if nu.point_count_v > 1:
+ print("\tWarning, surface:", ob.name, "only poly and nurbs curves supported")
+ continue
+
+ if len(nu.points) <= DEG_ORDER_U:
+ print("\tWarning, order_u is lower then vert count, skipping:", ob.name)
+ continue
+
+ pt_num = 0
+ do_closed = nu.use_cyclic_u
+ do_endpoints = (do_closed == 0) and nu.use_endpoint_u
+
+ for pt in nu.points:
+ pt = ob_mat * pt.co.copy().resize3D()
+ file.write('v %.6f %.6f %.6f\n' % (pt[0], pt[1], pt[2]))
+ pt_num += 1
+ tot_verts += pt_num
+
+ file.write('g %s\n' % (fixName(ob.name))) # fixName(ob.getData(1)) could use the data name too
+ file.write('cstype bspline\n') # not ideal, hard coded
+ file.write('deg %d\n' % DEG_ORDER_U) # not used for curves but most files have it still
+
+ curve_ls = [-(i+1) for i in range(pt_num)]
+
+ # 'curv' keyword
+ if do_closed:
+ if DEG_ORDER_U == 1:
+ pt_num += 1
+ curve_ls.append(-1)
+ else:
+ pt_num += DEG_ORDER_U
+ curve_ls = curve_ls + curve_ls[0:DEG_ORDER_U]
+
+ file.write('curv 0.0 1.0 %s\n' % (' '.join([str(i) for i in curve_ls]))) # Blender has no U and V values for the curve
+
+ # 'parm' keyword
+ tot_parm = (DEG_ORDER_U + 1) + pt_num
+ tot_parm_div = float(tot_parm-1)
+ parm_ls = [(i/tot_parm_div) for i in range(tot_parm)]
+
+ if do_endpoints: # end points, force param
+ for i in range(DEG_ORDER_U+1):
+ parm_ls[i] = 0.0
+ parm_ls[-(1+i)] = 1.0
+
+ file.write('parm u %s\n' % ' '.join( [str(i) for i in parm_ls] ))
+
+ file.write('end\n')
+
+ return tot_verts
+
+def write_file(filepath, objects, scene,
+ EXPORT_TRI=False,
+ EXPORT_EDGES=False,
+ EXPORT_NORMALS=False,
+ EXPORT_NORMALS_HQ=False,
+ EXPORT_UV=True,
+ EXPORT_MTL=True,
+ EXPORT_COPY_IMAGES=False,
+ EXPORT_APPLY_MODIFIERS=True,
+ EXPORT_ROTX90=True,
+ EXPORT_BLEN_OBS=True,
+ EXPORT_GROUP_BY_OB=False,
+ EXPORT_GROUP_BY_MAT=False,
+ EXPORT_KEEP_VERT_ORDER=False,
+ EXPORT_POLYGROUPS=False,
+ EXPORT_CURVE_AS_NURBS=True):
+ '''
+ Basic write function. The context and options must be already set
+ This can be accessed externaly
+ eg.
+ write( 'c:\\test\\foobar.obj', Blender.Object.GetSelected() ) # Using default options.
+ '''
+
+ # XXX
+ import math
+
+ def veckey3d(v):
+ return round(v.x, 6), round(v.y, 6), round(v.z, 6)
+
+ def veckey2d(v):
+ return round(v[0], 6), round(v[1], 6)
+
+ def findVertexGroupName(face, vWeightMap):
+ """
+ Searches the vertexDict to see what groups is assigned to a given face.
+ We use a frequency system in order to sort out the name because a given vetex can
+ belong to two or more groups at the same time. To find the right name for the face
+ we list all the possible vertex group names with their frequency and then sort by
+ frequency in descend order. The top element is the one shared by the highest number
+ of vertices is the face's group
+ """
+ weightDict = {}
+ for vert_index in face.vertices:
+# for vert in face:
+ vWeights = vWeightMap[vert_index]
+# vWeights = vWeightMap[vert]
+ for vGroupName, weight in vWeights:
+ weightDict[vGroupName] = weightDict.get(vGroupName, 0) + weight
+
+ if weightDict:
+ alist = [(weight,vGroupName) for vGroupName, weight in weightDict.items()] # sort least to greatest amount of weight
+ alist.sort()
+ return(alist[-1][1]) # highest value last
+ else:
+ return '(null)'
+
+ print('OBJ Export path: %r' % filepath)
+ temp_mesh_name = '~tmp-mesh'
+
+ time1 = time.clock()
+# time1 = sys.time()
+# scn = Scene.GetCurrent()
+
+ file = open(filepath, "w")
+
+ # Write Header
+ file.write('# Blender v%s OBJ File: %r\n' % (bpy.app.version_string, os.path.basename(bpy.data.filepath)))
+ file.write('# www.blender.org\n')
+
+ # Tell the obj file what material file to use.
+ if EXPORT_MTL:
+ mtlfilepath = os.path.splitext(filepath)[0] + ".mtl"
+ file.write('mtllib %s\n' % repr(os.path.basename(mtlfilepath))[1:-1]) # filepath can contain non utf8 chars, use repr
+
+ if EXPORT_ROTX90:
+ mat_xrot90= mathutils.Matrix.Rotation(-math.pi/2, 4, 'X')
+
+ # Initialize totals, these are updated each object
+ totverts = totuvco = totno = 1
+
+ face_vert_index = 1
+
+ globalNormals = {}
+
+ # A Dict of Materials
+ # (material.name, image.name):matname_imagename # matname_imagename has gaps removed.
+ mtl_dict = {}
+
+ # Get all meshes
+ for ob_main in objects:
+
+ # ignore dupli children
+ if ob_main.parent and ob_main.parent.dupli_type != 'NONE':
+ # XXX
+ print(ob_main.name, 'is a dupli child - ignoring')
+ continue
+
+ obs = []
+ if ob_main.dupli_type != 'NONE':
+ # XXX
+ print('creating dupli_list on', ob_main.name)
+ ob_main.create_dupli_list(scene)
+
+ obs = [(dob.object, dob.matrix) for dob in ob_main.dupli_list]
+
+ # XXX debug print
+ print(ob_main.name, 'has', len(obs), 'dupli children')
+ else:
+ obs = [(ob_main, ob_main.matrix_world)]
+
+ for ob, ob_mat in obs:
+
+ # Nurbs curve support
+ if EXPORT_CURVE_AS_NURBS and test_nurbs_compat(ob):
+ if EXPORT_ROTX90:
+ ob_mat = ob_mat * mat_xrot90
+ totverts += write_nurb(file, ob, ob_mat)
+ continue
+ # END NURBS
+
+ if ob.type != 'MESH':
+ continue
+
+ me = ob.create_mesh(scene, EXPORT_APPLY_MODIFIERS, 'PREVIEW')
+
+ if EXPORT_ROTX90:
+ me.transform(mat_xrot90 * ob_mat)
+ else:
+ me.transform(ob_mat)
+
+# # Will work for non meshes now! :)
+# me= BPyMesh.getMeshFromObject(ob, containerMesh, EXPORT_APPLY_MODIFIERS, EXPORT_POLYGROUPS, scn)
+# if not me:
+# continue
+
+ if EXPORT_UV:
+ faceuv = len(me.uv_textures) > 0
+ if faceuv:
+ uv_layer = me.uv_textures.active.data[:]
+ else:
+ faceuv = False
+
+ me_verts = me.vertices[:]
+
+ # Make our own list so it can be sorted to reduce context switching
+ face_index_pairs = [ (face, index) for index, face in enumerate(me.faces)]
+ # faces = [ f for f in me.faces ]
+
+ if EXPORT_EDGES:
+ edges = me.edges
+ else:
+ edges = []
+
+ if not (len(face_index_pairs)+len(edges)+len(me.vertices)): # Make sure there is somthing to write
+
+ # clean up
+ bpy.data.meshes.remove(me)
+
+ continue # dont bother with this mesh.
+
+ # XXX
+ # High Quality Normals
+ if EXPORT_NORMALS and face_index_pairs:
+ me.calc_normals()
+# if EXPORT_NORMALS_HQ:
+# BPyMesh.meshCalcNormals(me)
+# else:
+# # transforming normals is incorrect
+# # when the matrix is scaled,
+# # better to recalculate them
+# me.calcNormals()
+
+ materials = me.materials
+
+ materialNames = []
+ materialItems = [m for m in materials]
+ if materials:
+ for mat in materials:
+ if mat:
+ materialNames.append(mat.name)
+ else:
+ materialNames.append(None)
+ # Cant use LC because some materials are None.
+ # materialNames = map(lambda mat: mat.name, materials) # Bug Blender, dosent account for null materials, still broken.
+
+ # Possible there null materials, will mess up indicies
+ # but at least it will export, wait until Blender gets fixed.
+ materialNames.extend((16-len(materialNames)) * [None])
+ materialItems.extend((16-len(materialItems)) * [None])
+
+ # Sort by Material, then images
+ # so we dont over context switch in the obj file.
+ if EXPORT_KEEP_VERT_ORDER:
+ pass
+ elif faceuv:
+ face_index_pairs.sort(key=lambda a: (a[0].material_index, hash(uv_layer[a[1]].image), a[0].use_smooth))
+ elif len(materials) > 1:
+ face_index_pairs.sort(key = lambda a: (a[0].material_index, a[0].use_smooth))
+ else:
+ # no materials
+ face_index_pairs.sort(key = lambda a: a[0].use_smooth)
+# if EXPORT_KEEP_VERT_ORDER:
+# pass
+# elif faceuv:
+# try: faces.sort(key = lambda a: (a.mat, a.image, a.use_smooth))
+# except: faces.sort(lambda a,b: cmp((a.mat, a.image, a.use_smooth), (b.mat, b.image, b.use_smooth)))
+# elif len(materials) > 1:
+# try: faces.sort(key = lambda a: (a.mat, a.use_smooth))
+# except: faces.sort(lambda a,b: cmp((a.mat, a.use_smooth), (b.mat, b.use_smooth)))
+# else:
+# # no materials
+# try: faces.sort(key = lambda a: a.use_smooth)
+# except: faces.sort(lambda a,b: cmp(a.use_smooth, b.use_smooth))
+
+ # Set the default mat to no material and no image.
+ contextMat = (0, 0) # Can never be this, so we will label a new material teh first chance we get.
+ contextSmooth = None # Will either be true or false, set bad to force initialization switch.
+
+ if EXPORT_BLEN_OBS or EXPORT_GROUP_BY_OB:
+ name1 = ob.name
+ name2 = ob.data.name
+ if name1 == name2:
+ obnamestring = fixName(name1)
+ else:
+ obnamestring = '%s_%s' % (fixName(name1), fixName(name2))
+
+ if EXPORT_BLEN_OBS:
+ file.write('o %s\n' % obnamestring) # Write Object name
+ else: # if EXPORT_GROUP_BY_OB:
+ file.write('g %s\n' % obnamestring)
+
+
+ # Vert
+ for v in me_verts:
+ file.write('v %.6f %.6f %.6f\n' % v.co[:])
+
+ # UV
+ if faceuv:
+ uv_face_mapping = [[0,0,0,0] for i in range(len(face_index_pairs))] # a bit of a waste for tri's :/
+
+ uv_dict = {} # could use a set() here
+ uv_layer = me.uv_textures.active.data
+ for f, f_index in face_index_pairs:
+ for uv_index, uv in enumerate(uv_layer[f_index].uv):
+ uvkey = veckey2d(uv)
+ try:
+ uv_face_mapping[f_index][uv_index] = uv_dict[uvkey]
+ except:
+ uv_face_mapping[f_index][uv_index] = uv_dict[uvkey] = len(uv_dict)
+ file.write('vt %.6f %.6f\n' % uv[:])
+
+ uv_unique_count = len(uv_dict)
+# del uv, uvkey, uv_dict, f_index, uv_index
+ # Only need uv_unique_count and uv_face_mapping
+
+ # NORMAL, Smooth/Non smoothed.
+ if EXPORT_NORMALS:
+ for f, f_index in face_index_pairs:
+ if f.use_smooth:
+ for v_idx in f.vertices:
+ v = me_verts[v_idx]
+ noKey = veckey3d(v.normal)
+ if noKey not in globalNormals:
+ globalNormals[noKey] = totno
+ totno +=1
+ file.write('vn %.6f %.6f %.6f\n' % noKey)
+ else:
+ # Hard, 1 normal from the face.
+ noKey = veckey3d(f.normal)
+ if noKey not in globalNormals:
+ globalNormals[noKey] = totno
+ totno +=1
+ file.write('vn %.6f %.6f %.6f\n' % noKey)
+
+ if not faceuv:
+ f_image = None
+
+ # XXX
+ if EXPORT_POLYGROUPS:
+ # Retrieve the list of vertex groups
+ vertGroupNames = [g.name for g in ob.vertex_groups]
+
+ currentVGroup = ''
+ # Create a dictionary keyed by face id and listing, for each vertex, the vertex groups it belongs to
+ vgroupsMap = [[] for _i in range(len(me_verts))]
+ for v_idx, v in enumerate(me.vertices):
+ for g in v.groups:
+ vgroupsMap[v_idx].append((vertGroupNames[g.group], g.weight))
+
+ for f, f_index in face_index_pairs:
+ f_smooth= f.use_smooth
+ f_mat = min(f.material_index, len(materialNames)-1)
+
+ if faceuv:
+ tface = uv_layer[f_index]
+ f_image = tface.image
+
+ # MAKE KEY
+ if faceuv and f_image: # Object is always true.
+ key = materialNames[f_mat], f_image.name
+ else:
+ key = materialNames[f_mat], None # No image, use None instead.
+
+ # Write the vertex group
+ if EXPORT_POLYGROUPS:
+ if ob.vertex_groups:
+ # find what vertext group the face belongs to
+ theVGroup = findVertexGroupName(f,vgroupsMap)
+ if theVGroup != currentVGroup:
+ currentVGroup = theVGroup
+ file.write('g %s\n' % theVGroup)
+
+ # CHECK FOR CONTEXT SWITCH
+ if key == contextMat:
+ pass # Context already switched, dont do anything
+ else:
+ if key[0] is None and key[1] is None:
+ # Write a null material, since we know the context has changed.
+ if EXPORT_GROUP_BY_MAT:
+ # can be mat_image or (null)
+ file.write('g %s_%s\n' % (fixName(ob.name), fixName(ob.data.name)) ) # can be mat_image or (null)
+ file.write('usemtl (null)\n') # mat, image
+
+ else:
+ mat_data= mtl_dict.get(key)
+ if not mat_data:
+ # First add to global dict so we can export to mtl
+ # Then write mtl
+
+ # Make a new names from the mat and image name,
+ # converting any spaces to underscores with fixName.
+
+ # If none image dont bother adding it to the name
+ if key[1] is None:
+ mat_data = mtl_dict[key] = ('%s'%fixName(key[0])), materialItems[f_mat], f_image
+ else:
+ mat_data = mtl_dict[key] = ('%s_%s' % (fixName(key[0]), fixName(key[1]))), materialItems[f_mat], f_image
+
+ if EXPORT_GROUP_BY_MAT:
+ file.write('g %s_%s_%s\n' % (fixName(ob.name), fixName(ob.data.name), mat_data[0]) ) # can be mat_image or (null)
+
+ file.write('usemtl %s\n' % mat_data[0]) # can be mat_image or (null)
+
+ contextMat = key
+ if f_smooth != contextSmooth:
+ if f_smooth: # on now off
+ file.write('s 1\n')
+ contextSmooth = f_smooth
+ else: # was off now on
+ file.write('s off\n')
+ contextSmooth = f_smooth
+
+ f_v_orig = [(vi, me_verts[v_idx]) for vi, v_idx in enumerate(f.vertices)]
+
+ if not EXPORT_TRI or len(f_v_orig) == 3:
+ f_v_iter = (f_v_orig, )
+ else:
+ f_v_iter = (f_v_orig[0], f_v_orig[1], f_v_orig[2]), (f_v_orig[0], f_v_orig[2], f_v_orig[3])
+
+ # support for triangulation
+ for f_v in f_v_iter:
+ file.write('f')
+
+ if faceuv:
+ if EXPORT_NORMALS:
+ if f_smooth: # Smoothed, use vertex normals
+ for vi, v in f_v:
+ file.write( ' %d/%d/%d' % \
+ (v.index + totverts,
+ totuvco + uv_face_mapping[f_index][vi],
+ globalNormals[ veckey3d(v.normal) ]) ) # vert, uv, normal
+
+ else: # No smoothing, face normals
+ no = globalNormals[ veckey3d(f.normal) ]
+ for vi, v in f_v:
+ file.write( ' %d/%d/%d' % \
+ (v.index + totverts,
+ totuvco + uv_face_mapping[f_index][vi],
+ no) ) # vert, uv, normal
+ else: # No Normals
+ for vi, v in f_v:
+ file.write( ' %d/%d' % (\
+ v.index + totverts,\
+ totuvco + uv_face_mapping[f_index][vi])) # vert, uv
+
+ face_vert_index += len(f_v)
+
+ else: # No UV's
+ if EXPORT_NORMALS:
+ if f_smooth: # Smoothed, use vertex normals
+ for vi, v in f_v:
+ file.write( ' %d//%d' %
+ (v.index + totverts, globalNormals[ veckey3d(v.normal) ]) )
+ else: # No smoothing, face normals
+ no = globalNormals[ veckey3d(f.normal) ]
+ for vi, v in f_v:
+ file.write( ' %d//%d' % (v.index + totverts, no) )
+ else: # No Normals
+ for vi, v in f_v:
+ file.write( ' %d' % (v.index + totverts) )
+
+ file.write('\n')
+
+ # Write edges.
+ if EXPORT_EDGES:
+ for ed in edges:
+ if ed.is_loose:
+ file.write('f %d %d\n' % (ed.vertices[0] + totverts, ed.vertices[1] + totverts))
+
+ # Make the indicies global rather then per mesh
+ totverts += len(me_verts)
+ if faceuv:
+ totuvco += uv_unique_count
+
+ # clean up
+ bpy.data.meshes.remove(me)
+
+ if ob_main.dupli_type != 'NONE':
+ ob_main.free_dupli_list()
+
+ file.close()
+
+
+ # Now we have all our materials, save them
+ if EXPORT_MTL:
+ write_mtl(scene, mtlfilepath, EXPORT_COPY_IMAGES, mtl_dict)
+# if EXPORT_COPY_IMAGES:
+# dest_dir = os.path.basename(filepath)
+# # dest_dir = filepath
+# # # Remove chars until we are just the path.
+# # while dest_dir and dest_dir[-1] not in '\\/':
+# # dest_dir = dest_dir[:-1]
+# if dest_dir:
+# copy_images(dest_dir, mtl_dict)
+# else:
+# print('\tError: "%s" could not be used as a base for an image path.' % filepath)
+
+ print("OBJ Export time: %.2f" % (time.clock() - time1))
+
+#
+def _write(context, filepath,
+ EXPORT_TRI, # ok
+ EXPORT_EDGES,
+ EXPORT_NORMALS, # not yet
+ EXPORT_NORMALS_HQ, # not yet
+ EXPORT_UV, # ok
+ EXPORT_MTL,
+ EXPORT_COPY_IMAGES,
+ EXPORT_APPLY_MODIFIERS, # ok
+ EXPORT_ROTX90, # wrong
+ EXPORT_BLEN_OBS,
+ EXPORT_GROUP_BY_OB,
+ EXPORT_GROUP_BY_MAT,
+ EXPORT_KEEP_VERT_ORDER,
+ EXPORT_POLYGROUPS,
+ EXPORT_CURVE_AS_NURBS,
+ EXPORT_SEL_ONLY, # ok
+ EXPORT_ALL_SCENES, # XXX not working atm
+ EXPORT_ANIMATION): # Not used
+
+ base_name, ext = os.path.splitext(filepath)
+ context_name = [base_name, '', '', ext] # Base name, scene name, frame number, extension
+
+ orig_scene = context.scene
+
+ # Exit edit mode before exporting, so current object states are exported properly.
+ if bpy.ops.object.mode_set.poll():
+ bpy.ops.object.mode_set(mode='OBJECT')
+
+# if EXPORT_ALL_SCENES:
+# export_scenes = bpy.data.scenes
+# else:
+# export_scenes = [orig_scene]
+
+ # XXX only exporting one scene atm since changing
+ # current scene is not possible.
+ # Brecht says that ideally in 2.5 we won't need such a function,
+ # allowing multiple scenes open at once.
+ export_scenes = [orig_scene]
+
+ # Export all scenes.
+ for scene in export_scenes:
+ # scene.makeCurrent() # If already current, this is not slow.
+ # context = scene.getRenderingContext()
+ orig_frame = scene.frame_current
+
+ if EXPORT_ALL_SCENES: # Add scene name into the context_name
+ context_name[1] = '_%s' % bpy.path.clean_name(scene.name) # WARNING, its possible that this could cause a collision. we could fix if were feeling parranoied.
+
+ # Export an animation?
+ if EXPORT_ANIMATION:
+ scene_frames = range(scene.frame_start, scene.frame_end + 1) # Up to and including the end frame.
+ else:
+ scene_frames = [orig_frame] # Dont export an animation.
+
+ # Loop through all frames in the scene and export.
+ for frame in scene_frames:
+ if EXPORT_ANIMATION: # Add frame to the filepath.
+ context_name[2] = '_%.6d' % frame
+
+ scene.frame_set(frame, 0.0)
+ if EXPORT_SEL_ONLY:
+ objects = context.selected_objects
+ else:
+ objects = scene.objects
+
+ full_path = ''.join(context_name)
+
+ # erm... bit of a problem here, this can overwrite files when exporting frames. not too bad.
+ # EXPORT THE FILE.
+ write_file(full_path, objects, scene,
+ EXPORT_TRI,
+ EXPORT_EDGES,
+ EXPORT_NORMALS,
+ EXPORT_NORMALS_HQ,
+ EXPORT_UV,
+ EXPORT_MTL,
+ EXPORT_COPY_IMAGES,
+ EXPORT_APPLY_MODIFIERS,
+ EXPORT_ROTX90,
+ EXPORT_BLEN_OBS,
+ EXPORT_GROUP_BY_OB,
+ EXPORT_GROUP_BY_MAT,
+ EXPORT_KEEP_VERT_ORDER,
+ EXPORT_POLYGROUPS,
+ EXPORT_CURVE_AS_NURBS)
+
+ scene.frame_set(orig_frame, 0.0)
+
+ # Restore old active scene.
+# orig_scene.makeCurrent()
+# Window.WaitCursor(0)
+
+
+'''
+Currently the exporter lacks these features:
+* multiple scene export (only active scene is written)
+* particles
+'''
+
+
+def save(operator, context, filepath="",
+ use_triangles=False,
+ use_edges=True,
+ use_normals=False,
+ use_hq_normals=False,
+ use_uvs=True,
+ use_materials=True,
+ copy_images=False,
+ use_modifiers=True,
+ use_rotate_x90=True,
+ use_blen_objects=True,
+ group_by_object=False,
+ group_by_material=False,
+ keep_vertex_order=False,
+ use_vertex_groups=False,
+ use_nurbs=True,
+ use_selection=True,
+ use_all_scenes=False,
+ use_animation=False,
+ ):
+
+ _write(context, filepath,
+ EXPORT_TRI=use_triangles,
+ EXPORT_EDGES=use_edges,
+ EXPORT_NORMALS=use_normals,
+ EXPORT_NORMALS_HQ=use_hq_normals,
+ EXPORT_UV=use_uvs,
+ EXPORT_MTL=use_materials,
+ EXPORT_COPY_IMAGES=copy_images,
+ EXPORT_APPLY_MODIFIERS=use_modifiers,
+ EXPORT_ROTX90=use_rotate_x90,
+ EXPORT_BLEN_OBS=use_blen_objects,
+ EXPORT_GROUP_BY_OB=group_by_object,
+ EXPORT_GROUP_BY_MAT=group_by_material,
+ EXPORT_KEEP_VERT_ORDER=keep_vertex_order,
+ EXPORT_POLYGROUPS=use_vertex_groups,
+ EXPORT_CURVE_AS_NURBS=use_nurbs,
+ EXPORT_SEL_ONLY=use_selection,
+ EXPORT_ALL_SCENES=use_all_scenes,
+ EXPORT_ANIMATION=use_animation,
+ )
+
+ return {'FINISHED'}
diff --git a/io_scene_obj/import_obj.py b/io_scene_obj/import_obj.py
new file mode 100644
index 0000000000000000000000000000000000000000..c0c64c3d9b4d63c363d8ac4fd4f6d6d7008a5deb
--- /dev/null
+++ b/io_scene_obj/import_obj.py
@@ -0,0 +1,1219 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Script copyright (C) Campbell Barton
+# Contributors: Campbell Barton, Jiri Hnidek, Paolo Ciccone
+
+"""
+This script imports a Wavefront OBJ files to Blender.
+
+Usage:
+Run this script from "File->Import" menu and then load the desired OBJ file.
+Note, This loads mesh objects and materials only, nurbs and curves are not supported.
+
+http://wiki.blender.org/index.php/Scripts/Manual/Import/wavefront_obj
+"""
+
+import os
+import time
+import bpy
+import mathutils
+from mathutils.geometry import tesselate_polygon
+from io_utils import load_image, unpack_list, unpack_face_list
+
+
+def BPyMesh_ngon(from_data, indices, PREF_FIX_LOOPS= True):
+ '''
+ Takes a polyline of indices (fgon)
+ and returns a list of face indicie lists.
+ Designed to be used for importers that need indices for an fgon to create from existing verts.
+
+ from_data: either a mesh, or a list/tuple of vectors.
+ indices: a list of indicies to use this list is the ordered closed polyline to fill, and can be a subset of the data given.
+ PREF_FIX_LOOPS: If this is enabled polylines that use loops to make multiple polylines are delt with correctly.
+ '''
+
+ if not set: # Need sets for this, otherwise do a normal fill.
+ PREF_FIX_LOOPS= False
+
+ Vector= mathutils.Vector
+ if not indices:
+ return []
+
+ # return []
+ def rvec(co): return round(co.x, 6), round(co.y, 6), round(co.z, 6)
+ def mlen(co): return abs(co[0])+abs(co[1])+abs(co[2]) # manhatten length of a vector, faster then length
+
+ def vert_treplet(v, i):
+ return v, rvec(v), i, mlen(v)
+
+ def ed_key_mlen(v1, v2):
+ if v1[3] > v2[3]:
+ return v2[1], v1[1]
+ else:
+ return v1[1], v2[1]
+
+
+ if not PREF_FIX_LOOPS:
+ '''
+ Normal single concave loop filling
+ '''
+ if type(from_data) in (tuple, list):
+ verts= [Vector(from_data[i]) for ii, i in enumerate(indices)]
+ else:
+ verts= [from_data.vertices[i].co for ii, i in enumerate(indices)]
+
+ for i in range(len(verts)-1, 0, -1): # same as reversed(xrange(1, len(verts))):
+ if verts[i][1]==verts[i-1][0]:
+ verts.pop(i-1)
+
+ fill= fill_polygon([verts])
+
+ else:
+ '''
+ Seperate this loop into multiple loops be finding edges that are used twice
+ This is used by lightwave LWO files a lot
+ '''
+
+ if type(from_data) in (tuple, list):
+ verts= [vert_treplet(Vector(from_data[i]), ii) for ii, i in enumerate(indices)]
+ else:
+ verts= [vert_treplet(from_data.vertices[i].co, ii) for ii, i in enumerate(indices)]
+
+ edges= [(i, i-1) for i in range(len(verts))]
+ if edges:
+ edges[0]= (0,len(verts)-1)
+
+ if not verts:
+ return []
+
+
+ edges_used= set()
+ edges_doubles= set()
+ # We need to check if any edges are used twice location based.
+ for ed in edges:
+ edkey= ed_key_mlen(verts[ed[0]], verts[ed[1]])
+ if edkey in edges_used:
+ edges_doubles.add(edkey)
+ else:
+ edges_used.add(edkey)
+
+ # Store a list of unconnected loop segments split by double edges.
+ # will join later
+ loop_segments= []
+
+ v_prev= verts[0]
+ context_loop= [v_prev]
+ loop_segments= [context_loop]
+
+ for v in verts:
+ if v!=v_prev:
+ # Are we crossing an edge we removed?
+ if ed_key_mlen(v, v_prev) in edges_doubles:
+ context_loop= [v]
+ loop_segments.append(context_loop)
+ else:
+ if context_loop and context_loop[-1][1]==v[1]:
+ #raise "as"
+ pass
+ else:
+ context_loop.append(v)
+
+ v_prev= v
+ # Now join loop segments
+
+ def join_seg(s1,s2):
+ if s2[-1][1]==s1[0][1]: #
+ s1,s2= s2,s1
+ elif s1[-1][1]==s2[0][1]:
+ pass
+ else:
+ return False
+
+ # If were stuill here s1 and s2 are 2 segments in the same polyline
+ s1.pop() # remove the last vert from s1
+ s1.extend(s2) # add segment 2 to segment 1
+
+ if s1[0][1]==s1[-1][1]: # remove endpoints double
+ s1.pop()
+
+ s2[:]= [] # Empty this segment s2 so we dont use it again.
+ return True
+
+ joining_segments= True
+ while joining_segments:
+ joining_segments= False
+ segcount= len(loop_segments)
+
+ for j in range(segcount-1, -1, -1): #reversed(range(segcount)):
+ seg_j= loop_segments[j]
+ if seg_j:
+ for k in range(j-1, -1, -1): # reversed(range(j)):
+ if not seg_j:
+ break
+ seg_k= loop_segments[k]
+
+ if seg_k and join_seg(seg_j, seg_k):
+ joining_segments= True
+
+ loop_list= loop_segments
+
+ for verts in loop_list:
+ while verts and verts[0][1]==verts[-1][1]:
+ verts.pop()
+
+ loop_list= [verts for verts in loop_list if len(verts)>2]
+ # DONE DEALING WITH LOOP FIXING
+
+
+ # vert mapping
+ vert_map= [None]*len(indices)
+ ii=0
+ for verts in loop_list:
+ if len(verts)>2:
+ for i, vert in enumerate(verts):
+ vert_map[i+ii]= vert[2]
+ ii+=len(verts)
+
+ fill= tesselate_polygon([ [v[0] for v in loop] for loop in loop_list ])
+ #draw_loops(loop_list)
+ #raise 'done loop'
+ # map to original indicies
+ fill= [[vert_map[i] for i in reversed(f)] for f in fill]
+
+
+ if not fill:
+ print('Warning Cannot scanfill, fallback on a triangle fan.')
+ fill= [ [0, i-1, i] for i in range(2, len(indices)) ]
+ else:
+ # Use real scanfill.
+ # See if its flipped the wrong way.
+ flip= None
+ for fi in fill:
+ if flip != None:
+ break
+ for i, vi in enumerate(fi):
+ if vi==0 and fi[i-1]==1:
+ flip= False
+ break
+ elif vi==1 and fi[i-1]==0:
+ flip= True
+ break
+
+ if not flip:
+ for i, fi in enumerate(fill):
+ fill[i]= tuple([ii for ii in reversed(fi)])
+
+ return fill
+
+def line_value(line_split):
+ '''
+ Returns 1 string represneting the value for this line
+ None will be returned if theres only 1 word
+ '''
+ length= len(line_split)
+ if length == 1:
+ return None
+
+ elif length == 2:
+ return line_split[1]
+
+ elif length > 2:
+ return ' '.join( line_split[1:] )
+
+
+def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
+ if '_' in imagepath:
+ image= load_image(imagepath.replace('_', ' '), DIR)
+ if image:
+ return image
+
+ image = load_image(imagepath, DIR)
+ if image:
+ return image
+
+ print("failed to load '%s' doesn't exist", imagepath)
+ return None
+
+# def obj_image_load(imagepath, DIR, IMAGE_SEARCH):
+# '''
+# Mainly uses comprehensiveImageLoad
+# but tries to replace '_' with ' ' for Max's exporter replaces spaces with underscores.
+# '''
+
+# if '_' in imagepath:
+# image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
+# if image: return image
+# # Did the exporter rename the image?
+# image= BPyImage.comprehensiveImageLoad(imagepath.replace('_', ' '), DIR, PLACE_HOLDER= False, RECURSIVE= IMAGE_SEARCH)
+# if image: return image
+
+# # Return an image, placeholder if it dosnt exist
+# image= BPyImage.comprehensiveImageLoad(imagepath, DIR, PLACE_HOLDER= True, RECURSIVE= IMAGE_SEARCH)
+# return image
+
+
+def create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH):
+ '''
+ Create all the used materials in this obj,
+ assign colors and images to the materials from all referenced material libs
+ '''
+ DIR= os.path.dirname(filepath)
+
+ #==================================================================================#
+ # This function sets textures defined in .mtl file #
+ #==================================================================================#
+ def load_material_image(blender_material, context_material_name, imagepath, type):
+
+ texture= bpy.data.textures.new(name=type, type='IMAGE')
+
+ # Absolute path - c:\.. etc would work here
+ image = obj_image_load(imagepath, DIR, IMAGE_SEARCH)
+ has_data = False
+
+ if image:
+ texture.image = image
+ has_data = image.has_data
+
+ # Adds textures for materials (rendering)
+ if type == 'Kd':
+ if has_data and image.depth == 32:
+ # Image has alpha
+
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_color_diffuse = True
+ mtex.use_map_alpha = True
+
+ texture.mipmap = True
+ texture.interpolation = True
+ texture.use_alpha = True
+ blender_material.use_transparency = True
+ blender_material.alpha = 0.0
+ else:
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_color_diffuse = True
+
+ # adds textures to faces (Textured/Alt-Z mode)
+ # Only apply the diffuse texture to the face if the image has not been set with the inline usemat func.
+ unique_material_images[context_material_name]= image, has_data # set the texface image
+
+ elif type == 'Ka':
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_ambient = True
+
+ elif type == 'Ks':
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_specular = True
+
+ elif type == 'Bump':
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_normal = True
+
+ elif type == 'D':
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_alpha = True
+ blender_material.use_transparency = True
+ blender_material.transparency_method = 'Z_TRANSPARENCY'
+ blender_material.alpha = 0.0
+ # Todo, unset deffuse material alpha if it has an alpha channel
+
+ elif type == 'refl':
+ mtex = blender_material.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_reflect = True
+
+
+ # Add an MTL with the same name as the obj if no MTLs are spesified.
+ temp_mtl = os.path.splitext((os.path.basename(filepath)))[0] + '.mtl'
+
+ if os.path.exists(os.path.join(DIR, temp_mtl)) and temp_mtl not in material_libs:
+ material_libs.append( temp_mtl )
+ del temp_mtl
+
+ #Create new materials
+ for name in unique_materials: # .keys()
+ if name != None:
+ unique_materials[name]= bpy.data.materials.new(name)
+ unique_material_images[name]= None, False # assign None to all material images to start with, add to later.
+
+ unique_materials[None]= None
+ unique_material_images[None]= None, False
+
+ for libname in material_libs:
+ mtlpath= os.path.join(DIR, libname)
+ if not os.path.exists(mtlpath):
+ print ("\tError Missing MTL: '%s'" % mtlpath)
+ else:
+ #print '\t\tloading mtl: "%s"' % mtlpath
+ context_material= None
+ mtl= open(mtlpath, 'rU')
+ for line in mtl: #.xreadlines():
+ if line.startswith('newmtl'):
+ context_material_name= line_value(line.split())
+ if context_material_name in unique_materials:
+ context_material = unique_materials[ context_material_name ]
+ else:
+ context_material = None
+
+ elif context_material:
+ # we need to make a material to assign properties to it.
+ line_split= line.split()
+ line_lower= line.lower().lstrip()
+ if line_lower.startswith('ka'):
+ context_material.mirror_color = float(line_split[1]), float(line_split[2]), float(line_split[3])
+ elif line_lower.startswith('kd'):
+ context_material.diffuse_color = float(line_split[1]), float(line_split[2]), float(line_split[3])
+ elif line_lower.startswith('ks'):
+ context_material.specular_color = float(line_split[1]), float(line_split[2]), float(line_split[3])
+ elif line_lower.startswith('ns'):
+ context_material.specular_hardness = int((float(line_split[1]) * 0.51))
+ elif line_lower.startswith('ni'): # Refraction index
+ context_material.raytrace_transparency.ior = max(1, min(float(line_split[1]), 3)) # between 1 and 3
+ elif line_lower.startswith('d') or line_lower.startswith('tr'):
+ context_material.alpha = float(line_split[1])
+ context_material.use_transparency = True
+ context_material.transparency_method = 'Z_TRANSPARENCY'
+ elif line_lower.startswith('map_ka'):
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'Ka')
+ elif line_lower.startswith('map_ks'):
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'Ks')
+ elif line_lower.startswith('map_kd'):
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'Kd')
+ elif line_lower.startswith('map_bump'):
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'Bump')
+ elif line_lower.startswith('map_d') or line_lower.startswith('map_tr'): # Alpha map - Dissolve
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'D')
+
+ elif line_lower.startswith('refl'): # reflectionmap
+ img_filepath= line_value(line.split())
+ if img_filepath:
+ load_material_image(context_material, context_material_name, img_filepath, 'refl')
+ mtl.close()
+
+
+
+
+def split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP):
+ '''
+ Takes vert_loc and faces, and separates into multiple sets of
+ (verts_loc, faces, unique_materials, dataname)
+ '''
+
+ filename = os.path.splitext((os.path.basename(filepath)))[0]
+
+ if not SPLIT_OB_OR_GROUP:
+ # use the filename for the object name since we arnt chopping up the mesh.
+ return [(verts_loc, faces, unique_materials, filename)]
+
+ def key_to_name(key):
+ # if the key is a tuple, join it to make a string
+ if not key:
+ return filename # assume its a string. make sure this is true if the splitting code is changed
+ else:
+ return key
+
+ # Return a key that makes the faces unique.
+ face_split_dict= {}
+
+ oldkey= -1 # initialize to a value that will never match the key
+
+ for face in faces:
+ key= face[4]
+
+ if oldkey != key:
+ # Check the key has changed.
+ try:
+ verts_split, faces_split, unique_materials_split, vert_remap= face_split_dict[key]
+ except KeyError:
+ faces_split= []
+ verts_split= []
+ unique_materials_split= {}
+ vert_remap= [-1]*len(verts_loc)
+
+ face_split_dict[key]= (verts_split, faces_split, unique_materials_split, vert_remap)
+
+ oldkey= key
+
+ face_vert_loc_indicies= face[0]
+
+ # Remap verts to new vert list and add where needed
+ for enum, i in enumerate(face_vert_loc_indicies):
+ if vert_remap[i] == -1:
+ new_index= len(verts_split)
+ vert_remap[i]= new_index # set the new remapped index so we only add once and can reference next time.
+ face_vert_loc_indicies[enum] = new_index # remap to the local index
+ verts_split.append( verts_loc[i] ) # add the vert to the local verts
+ else:
+ face_vert_loc_indicies[enum] = vert_remap[i] # remap to the local index
+
+ matname= face[2]
+ if matname and matname not in unique_materials_split:
+ unique_materials_split[matname] = unique_materials[matname]
+
+ faces_split.append(face)
+
+ # remove one of the itemas and reorder
+ return [(value[0], value[1], value[2], key_to_name(key)) for key, value in list(face_split_dict.items())]
+
+
+def create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc, verts_tex, faces, unique_materials, unique_material_images, unique_smooth_groups, vertex_groups, dataname):
+ '''
+ Takes all the data gathered and generates a mesh, adding the new object to new_objects
+ deals with fgons, sharp edges and assigning materials
+ '''
+ if not has_ngons:
+ CREATE_FGONS= False
+
+ if unique_smooth_groups:
+ sharp_edges= {}
+ smooth_group_users = {context_smooth_group: {} for context_smooth_group in list(unique_smooth_groups.keys())}
+ context_smooth_group_old= -1
+
+ # Split fgons into tri's
+ fgon_edges= {} # Used for storing fgon keys
+ if CREATE_EDGES:
+ edges= []
+
+ context_object= None
+
+ # reverse loop through face indicies
+ for f_idx in range(len(faces)-1, -1, -1):
+
+ face_vert_loc_indicies,\
+ face_vert_tex_indicies,\
+ context_material,\
+ context_smooth_group,\
+ context_object= faces[f_idx]
+
+ len_face_vert_loc_indicies = len(face_vert_loc_indicies)
+
+ if len_face_vert_loc_indicies==1:
+ faces.pop(f_idx)# cant add single vert faces
+
+ elif not face_vert_tex_indicies or len_face_vert_loc_indicies == 2: # faces that have no texture coords are lines
+ if CREATE_EDGES:
+ # generators are better in python 2.4+ but can't be used in 2.3
+ # edges.extend( (face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in xrange(len_face_vert_loc_indicies-1) )
+ edges.extend( [(face_vert_loc_indicies[i], face_vert_loc_indicies[i+1]) for i in range(len_face_vert_loc_indicies-1)] )
+
+ faces.pop(f_idx)
+ else:
+
+ # Smooth Group
+ if unique_smooth_groups and context_smooth_group:
+ # Is a part of of a smooth group and is a face
+ if context_smooth_group_old is not context_smooth_group:
+ edge_dict= smooth_group_users[context_smooth_group]
+ context_smooth_group_old= context_smooth_group
+
+ for i in range(len_face_vert_loc_indicies):
+ i1= face_vert_loc_indicies[i]
+ i2= face_vert_loc_indicies[i-1]
+ if i1>i2: i1,i2= i2,i1
+
+ try:
+ edge_dict[i1,i2]+= 1
+ except KeyError:
+ edge_dict[i1,i2]= 1
+
+ # FGons into triangles
+ if has_ngons and len_face_vert_loc_indicies > 4:
+
+ ngon_face_indices= BPyMesh_ngon(verts_loc, face_vert_loc_indicies)
+ faces.extend(
+ [(
+ [face_vert_loc_indicies[ngon[0]], face_vert_loc_indicies[ngon[1]], face_vert_loc_indicies[ngon[2]] ],
+ [face_vert_tex_indicies[ngon[0]], face_vert_tex_indicies[ngon[1]], face_vert_tex_indicies[ngon[2]] ],
+ context_material,
+ context_smooth_group,
+ context_object)
+ for ngon in ngon_face_indices]
+ )
+
+ # edges to make fgons
+ if CREATE_FGONS:
+ edge_users= {}
+ for ngon in ngon_face_indices:
+ for i in (0,1,2):
+ i1= face_vert_loc_indicies[ngon[i ]]
+ i2= face_vert_loc_indicies[ngon[i-1]]
+ if i1>i2: i1,i2= i2,i1
+
+ try:
+ edge_users[i1,i2]+=1
+ except KeyError:
+ edge_users[i1,i2]= 1
+
+ for key, users in edge_users.items():
+ if users>1:
+ fgon_edges[key]= None
+
+ # remove all after 3, means we dont have to pop this one.
+ faces.pop(f_idx)
+
+
+ # Build sharp edges
+ if unique_smooth_groups:
+ for edge_dict in list(smooth_group_users.values()):
+ for key, users in list(edge_dict.items()):
+ if users==1: # This edge is on the boundry of a group
+ sharp_edges[key]= None
+
+
+ # map the material names to an index
+ material_mapping = {name: i for i, name in enumerate(unique_materials)} # enumerate over unique_materials keys()
+
+ materials= [None] * len(unique_materials)
+
+ for name, index in list(material_mapping.items()):
+ materials[index]= unique_materials[name]
+
+ me= bpy.data.meshes.new(dataname)
+
+ # make sure the list isnt too big
+ for material in materials:
+ me.materials.append(material)
+
+ me.vertices.add(len(verts_loc))
+ me.faces.add(len(faces))
+
+ # verts_loc is a list of (x, y, z) tuples
+ me.vertices.foreach_set("co", unpack_list(verts_loc))
+
+ # faces is a list of (vert_indices, texco_indices, ...) tuples
+ # XXX faces should contain either 3 or 4 verts
+ # XXX no check for valid face indices
+ me.faces.foreach_set("vertices_raw", unpack_face_list([f[0] for f in faces]))
+
+ if verts_tex and me.faces:
+ me.uv_textures.new()
+
+ context_material_old= -1 # avoid a dict lookup
+ mat= 0 # rare case it may be un-initialized.
+ me_faces= me.faces
+
+ for i, face in enumerate(faces):
+ if len(face[0]) < 2:
+ pass #raise "bad face"
+ elif len(face[0])==2:
+ if CREATE_EDGES:
+ edges.append(face[0])
+ else:
+
+ blender_face = me.faces[i]
+
+ face_vert_loc_indicies,\
+ face_vert_tex_indicies,\
+ context_material,\
+ context_smooth_group,\
+ context_object= face
+
+
+
+ if context_smooth_group:
+ blender_face.use_smooth = True
+
+ if context_material:
+ if context_material_old is not context_material:
+ mat= material_mapping[context_material]
+ context_material_old= context_material
+
+ blender_face.material_index= mat
+# blender_face.mat= mat
+
+
+ if verts_tex:
+
+ blender_tface= me.uv_textures[0].data[i]
+
+ if context_material:
+ image, has_data = unique_material_images[context_material]
+ if image: # Can be none if the material dosnt have an image.
+ blender_tface.image = image
+ blender_tface.use_image = True
+ if has_data and image.depth == 32:
+ blender_tface.blend_type = 'ALPHA'
+
+ # BUG - Evil eekadoodle problem where faces that have vert index 0 location at 3 or 4 are shuffled.
+ if len(face_vert_loc_indicies)==4:
+ if face_vert_loc_indicies[2]==0 or face_vert_loc_indicies[3]==0:
+ face_vert_tex_indicies= face_vert_tex_indicies[2], face_vert_tex_indicies[3], face_vert_tex_indicies[0], face_vert_tex_indicies[1]
+ else: # length of 3
+ if face_vert_loc_indicies[2]==0:
+ face_vert_tex_indicies= face_vert_tex_indicies[1], face_vert_tex_indicies[2], face_vert_tex_indicies[0]
+ # END EEEKADOODLE FIX
+
+ # assign material, uv's and image
+ blender_tface.uv1= verts_tex[face_vert_tex_indicies[0]]
+ blender_tface.uv2= verts_tex[face_vert_tex_indicies[1]]
+ blender_tface.uv3= verts_tex[face_vert_tex_indicies[2]]
+
+ if len(face_vert_loc_indicies)==4:
+ blender_tface.uv4= verts_tex[face_vert_tex_indicies[3]]
+
+# for ii, uv in enumerate(blender_face.uv):
+# uv.x, uv.y= verts_tex[face_vert_tex_indicies[ii]]
+ del me_faces
+# del ALPHA
+
+ if CREATE_EDGES and not edges:
+ CREATE_EDGES = False
+
+ if CREATE_EDGES:
+ me.edges.add(len(edges))
+
+ # edges should be a list of (a, b) tuples
+ me.edges.foreach_set("vertices", unpack_list(edges))
+# me_edges.extend( edges )
+
+# del me_edges
+
+ # Add edge faces.
+# me_edges= me.edges
+
+ def edges_match(e1, e2):
+ return (e1[0] == e2[0] and e1[1] == e2[1]) or (e1[0] == e2[1] and e1[1] == e2[0])
+
+ # XXX slow
+# if CREATE_FGONS and fgon_edges:
+# for fgon_edge in fgon_edges.keys():
+# for ed in me.edges:
+# if edges_match(fgon_edge, ed.vertices):
+# ed.is_fgon = True
+
+# if CREATE_FGONS and fgon_edges:
+# FGON= Mesh.EdgeFlags.FGON
+# for ed in me.findEdges( fgon_edges.keys() ):
+# if ed is not None:
+# me_edges[ed].flag |= FGON
+# del FGON
+
+ # XXX slow
+# if unique_smooth_groups and sharp_edges:
+# for sharp_edge in sharp_edges.keys():
+# for ed in me.edges:
+# if edges_match(sharp_edge, ed.vertices):
+# ed.use_edge_sharp = True
+
+# if unique_smooth_groups and sharp_edges:
+# SHARP= Mesh.EdgeFlags.SHARP
+# for ed in me.findEdges( sharp_edges.keys() ):
+# if ed is not None:
+# me_edges[ed].flag |= SHARP
+# del SHARP
+
+ me.update(calc_edges=CREATE_EDGES)
+# me.calcNormals()
+
+ ob= bpy.data.objects.new("Mesh", me)
+ new_objects.append(ob)
+
+ # Create the vertex groups. No need to have the flag passed here since we test for the
+ # content of the vertex_groups. If the user selects to NOT have vertex groups saved then
+ # the following test will never run
+ for group_name, group_indicies in vertex_groups.items():
+ group= ob.vertex_groups.new(group_name)
+ ob.vertex_groups.assign(group_indicies, group, 1.0, 'REPLACE')
+
+
+def create_nurbs(context_nurbs, vert_loc, new_objects):
+ '''
+ Add nurbs object to blender, only support one type at the moment
+ '''
+ deg = context_nurbs.get('deg', (3,))
+ curv_range = context_nurbs.get('curv_range')
+ curv_idx = context_nurbs.get('curv_idx', [])
+ parm_u = context_nurbs.get('parm_u', [])
+ parm_v = context_nurbs.get('parm_v', [])
+ name = context_nurbs.get('name', 'ObjNurb')
+ cstype = context_nurbs.get('cstype')
+
+ if cstype is None:
+ print('\tWarning, cstype not found')
+ return
+ if cstype != 'bspline':
+ print('\tWarning, cstype is not supported (only bspline)')
+ return
+ if not curv_idx:
+ print('\tWarning, curv argument empty or not set')
+ return
+ if len(deg) > 1 or parm_v:
+ print('\tWarning, surfaces not supported')
+ return
+
+ cu = bpy.data.curves.new(name, 'CURVE')
+ cu.dimensions = '3D'
+
+ nu = cu.splines.new('NURBS')
+ nu.points.add(len(curv_idx) - 1) # a point is added to start with
+ nu.points.foreach_set("co", [co_axis for vt_idx in curv_idx for co_axis in (vert_loc[vt_idx] + (1.0,))])
+
+ nu.order_u = deg[0] + 1
+
+ # get for endpoint flag from the weighting
+ if curv_range and len(parm_u) > deg[0]+1:
+ do_endpoints = True
+ for i in range(deg[0]+1):
+
+ if abs(parm_u[i]-curv_range[0]) > 0.0001:
+ do_endpoints = False
+ break
+
+ if abs(parm_u[-(i+1)]-curv_range[1]) > 0.0001:
+ do_endpoints = False
+ break
+
+ else:
+ do_endpoints = False
+
+ if do_endpoints:
+ nu.use_endpoint_u = True
+
+
+ # close
+ '''
+ do_closed = False
+ if len(parm_u) > deg[0]+1:
+ for i in xrange(deg[0]+1):
+ #print curv_idx[i], curv_idx[-(i+1)]
+
+ if curv_idx[i]==curv_idx[-(i+1)]:
+ do_closed = True
+ break
+
+ if do_closed:
+ nu.use_cyclic_u = True
+ '''
+
+ ob= bpy.data.objects.new("Nurb", cu)
+
+ new_objects.append(ob)
+
+
+def strip_slash(line_split):
+ if line_split[-1][-1]== '\\':
+ if len(line_split[-1])==1:
+ line_split.pop() # remove the \ item
+ else:
+ line_split[-1]= line_split[-1][:-1] # remove the \ from the end last number
+ return True
+ return False
+
+
+
+def get_float_func(filepath):
+ '''
+ find the float function for this obj file
+ - whether to replace commas or not
+ '''
+ file= open(filepath, 'rU')
+ for line in file: #.xreadlines():
+ line = line.lstrip()
+ if line.startswith('v'): # vn vt v
+ if ',' in line:
+ return lambda f: float(f.replace(',', '.'))
+ elif '.' in line:
+ return float
+
+ # incase all vert values were ints
+ return float
+
+def load(operator, context, filepath,
+ CLAMP_SIZE= 0.0,
+ CREATE_FGONS= True,
+ CREATE_SMOOTH_GROUPS= True,
+ CREATE_EDGES= True,
+ SPLIT_OBJECTS= True,
+ SPLIT_GROUPS= True,
+ ROTATE_X90= True,
+ IMAGE_SEARCH=True,
+ POLYGROUPS=False):
+ '''
+ Called by the user interface or another script.
+ load_obj(path) - should give acceptable results.
+ This function passes the file and sends the data off
+ to be split into objects and then converted into mesh objects
+ '''
+ print('\nimporting obj %r' % filepath)
+
+ if SPLIT_OBJECTS or SPLIT_GROUPS:
+ POLYGROUPS = False
+
+ time_main= time.time()
+# time_main= sys.time()
+
+ verts_loc= []
+ verts_tex= []
+ faces= [] # tuples of the faces
+ material_libs= [] # filanems to material libs this uses
+ vertex_groups = {} # when POLYGROUPS is true
+
+ # Get the string to float conversion func for this file- is 'float' for almost all files.
+ float_func= get_float_func(filepath)
+
+ # Context variables
+ context_material= None
+ context_smooth_group= None
+ context_object= None
+ context_vgroup = None
+
+ # Nurbs
+ context_nurbs = {}
+ nurbs = []
+ context_parm = '' # used by nurbs too but could be used elsewhere
+
+ has_ngons= False
+ # has_smoothgroups= False - is explicit with len(unique_smooth_groups) being > 0
+
+ # Until we can use sets
+ unique_materials= {}
+ unique_material_images= {}
+ unique_smooth_groups= {}
+ # unique_obects= {} - no use for this variable since the objects are stored in the face.
+
+ # when there are faces that end with \
+ # it means they are multiline-
+ # since we use xreadline we cant skip to the next line
+ # so we need to know whether
+ context_multi_line= ''
+
+ print("\tparsing obj file...")
+ time_sub= time.time()
+# time_sub= sys.time()
+
+ file= open(filepath, 'rU')
+ for line in file: #.xreadlines():
+ line = line.lstrip() # rare cases there is white space at the start of the line
+
+ if line.startswith('v '):
+ line_split= line.split()
+ # rotate X90: (x,-z,y)
+ verts_loc.append( (float_func(line_split[1]), -float_func(line_split[3]), float_func(line_split[2])) )
+
+ elif line.startswith('vn '):
+ pass
+
+ elif line.startswith('vt '):
+ line_split= line.split()
+ verts_tex.append( (float_func(line_split[1]), float_func(line_split[2])) )
+
+ # Handel faces lines (as faces) and the second+ lines of fa multiline face here
+ # use 'f' not 'f ' because some objs (very rare have 'fo ' for faces)
+ elif line.startswith('f') or context_multi_line == 'f':
+
+ if context_multi_line:
+ # use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
+ line_split= line.split()
+
+ else:
+ line_split= line[2:].split()
+ face_vert_loc_indicies= []
+ face_vert_tex_indicies= []
+
+ # Instance a face
+ faces.append((\
+ face_vert_loc_indicies,\
+ face_vert_tex_indicies,\
+ context_material,\
+ context_smooth_group,\
+ context_object\
+ ))
+
+ if strip_slash(line_split):
+ context_multi_line = 'f'
+ else:
+ context_multi_line = ''
+
+ for v in line_split:
+ obj_vert= v.split('/')
+
+ vert_loc_index= int(obj_vert[0])-1
+ # Add the vertex to the current group
+ # *warning*, this wont work for files that have groups defined around verts
+ if POLYGROUPS and context_vgroup:
+ vertex_groups[context_vgroup].append(vert_loc_index)
+
+ # Make relative negative vert indicies absolute
+ if vert_loc_index < 0:
+ vert_loc_index= len(verts_loc) + vert_loc_index + 1
+
+ face_vert_loc_indicies.append(vert_loc_index)
+
+ if len(obj_vert)>1 and obj_vert[1]:
+ # formatting for faces with normals and textures us
+ # loc_index/tex_index/nor_index
+
+ vert_tex_index= int(obj_vert[1])-1
+ # Make relative negative vert indicies absolute
+ if vert_tex_index < 0:
+ vert_tex_index= len(verts_tex) + vert_tex_index + 1
+
+ face_vert_tex_indicies.append(vert_tex_index)
+ else:
+ # dummy
+ face_vert_tex_indicies.append(0)
+
+ if len(face_vert_loc_indicies) > 4:
+ has_ngons= True
+
+ elif CREATE_EDGES and (line.startswith('l ') or context_multi_line == 'l'):
+ # very similar to the face load function above with some parts removed
+
+ if context_multi_line:
+ # use face_vert_loc_indicies and face_vert_tex_indicies previously defined and used the obj_face
+ line_split= line.split()
+
+ else:
+ line_split= line[2:].split()
+ face_vert_loc_indicies= []
+ face_vert_tex_indicies= []
+
+ # Instance a face
+ faces.append((\
+ face_vert_loc_indicies,\
+ face_vert_tex_indicies,\
+ context_material,\
+ context_smooth_group,\
+ context_object\
+ ))
+
+ if strip_slash(line_split):
+ context_multi_line = 'l'
+ else:
+ context_multi_line = ''
+
+ isline= line.startswith('l')
+
+ for v in line_split:
+ vert_loc_index= int(v)-1
+
+ # Make relative negative vert indicies absolute
+ if vert_loc_index < 0:
+ vert_loc_index= len(verts_loc) + vert_loc_index + 1
+
+ face_vert_loc_indicies.append(vert_loc_index)
+
+ elif line.startswith('s'):
+ if CREATE_SMOOTH_GROUPS:
+ context_smooth_group= line_value(line.split())
+ if context_smooth_group=='off':
+ context_smooth_group= None
+ elif context_smooth_group: # is not None
+ unique_smooth_groups[context_smooth_group]= None
+
+ elif line.startswith('o'):
+ if SPLIT_OBJECTS:
+ context_object= line_value(line.split())
+ # unique_obects[context_object]= None
+
+ elif line.startswith('g'):
+ if SPLIT_GROUPS:
+ context_object= line_value(line.split())
+ # print 'context_object', context_object
+ # unique_obects[context_object]= None
+ elif POLYGROUPS:
+ context_vgroup = line_value(line.split())
+ if context_vgroup and context_vgroup != '(null)':
+ vertex_groups.setdefault(context_vgroup, [])
+ else:
+ context_vgroup = None # dont assign a vgroup
+
+ elif line.startswith('usemtl'):
+ context_material= line_value(line.split())
+ unique_materials[context_material]= None
+ elif line.startswith('mtllib'): # usemap or usemat
+ material_libs = list(set(material_libs) | set(line.split()[1:])) # can have multiple mtllib filenames per line, mtllib can appear more than once, so make sure only occurance of material exists
+
+ # Nurbs support
+ elif line.startswith('cstype '):
+ context_nurbs['cstype']= line_value(line.split()) # 'rat bspline' / 'bspline'
+ elif line.startswith('curv ') or context_multi_line == 'curv':
+ line_split= line.split()
+
+ curv_idx = context_nurbs['curv_idx'] = context_nurbs.get('curv_idx', []) # incase were multiline
+
+ if not context_multi_line:
+ context_nurbs['curv_range'] = float_func(line_split[1]), float_func(line_split[2])
+ line_split[0:3] = [] # remove first 3 items
+
+ if strip_slash(line_split):
+ context_multi_line = 'curv'
+ else:
+ context_multi_line = ''
+
+
+ for i in line_split:
+ vert_loc_index = int(i)-1
+
+ if vert_loc_index < 0:
+ vert_loc_index= len(verts_loc) + vert_loc_index + 1
+
+ curv_idx.append(vert_loc_index)
+
+ elif line.startswith('parm') or context_multi_line == 'parm':
+ line_split= line.split()
+
+ if context_multi_line:
+ context_multi_line = ''
+ else:
+ context_parm = line_split[1]
+ line_split[0:2] = [] # remove first 2
+
+ if strip_slash(line_split):
+ context_multi_line = 'parm'
+ else:
+ context_multi_line = ''
+
+ if context_parm.lower() == 'u':
+ context_nurbs.setdefault('parm_u', []).extend( [float_func(f) for f in line_split] )
+ elif context_parm.lower() == 'v': # surfaces not suported yet
+ context_nurbs.setdefault('parm_v', []).extend( [float_func(f) for f in line_split] )
+ # else: # may want to support other parm's ?
+
+ elif line.startswith('deg '):
+ context_nurbs['deg']= [int(i) for i in line.split()[1:]]
+ elif line.startswith('end'):
+ # Add the nurbs curve
+ if context_object:
+ context_nurbs['name'] = context_object
+ nurbs.append(context_nurbs)
+ context_nurbs = {}
+ context_parm = ''
+
+ ''' # How to use usemap? depricated?
+ elif line.startswith('usema'): # usemap or usemat
+ context_image= line_value(line.split())
+ '''
+
+ file.close()
+ time_new= time.time()
+# time_new= sys.time()
+ print('%.4f sec' % (time_new-time_sub))
+ time_sub= time_new
+
+
+ print('\tloading materials and images...')
+ create_materials(filepath, material_libs, unique_materials, unique_material_images, IMAGE_SEARCH)
+
+ time_new= time.time()
+# time_new= sys.time()
+ print('%.4f sec' % (time_new-time_sub))
+ time_sub= time_new
+
+ if not ROTATE_X90:
+ verts_loc[:] = [(v[0], v[2], -v[1]) for v in verts_loc]
+
+ # deselect all
+ bpy.ops.object.select_all(action='DESELECT')
+
+ scene = context.scene
+# scn.objects.selected = []
+ new_objects= [] # put new objects here
+
+ print('\tbuilding geometry...\n\tverts:%i faces:%i materials: %i smoothgroups:%i ...' % ( len(verts_loc), len(faces), len(unique_materials), len(unique_smooth_groups) ))
+ # Split the mesh by objects/materials, may
+ if SPLIT_OBJECTS or SPLIT_GROUPS: SPLIT_OB_OR_GROUP = True
+ else: SPLIT_OB_OR_GROUP = False
+
+ for verts_loc_split, faces_split, unique_materials_split, dataname in split_mesh(verts_loc, faces, unique_materials, filepath, SPLIT_OB_OR_GROUP):
+ # Create meshes from the data, warning 'vertex_groups' wont support splitting
+ create_mesh(new_objects, has_ngons, CREATE_FGONS, CREATE_EDGES, verts_loc_split, verts_tex, faces_split, unique_materials_split, unique_material_images, unique_smooth_groups, vertex_groups, dataname)
+
+ # nurbs support
+ for context_nurbs in nurbs:
+ create_nurbs(context_nurbs, verts_loc, new_objects)
+
+ # Create new obj
+ for obj in new_objects:
+ base = scene.objects.link(obj)
+ base.select = True
+
+ scene.update()
+
+
+ axis_min= [ 1000000000]*3
+ axis_max= [-1000000000]*3
+
+# if CLAMP_SIZE:
+# # Get all object bounds
+# for ob in new_objects:
+# for v in ob.getBoundBox():
+# for axis, value in enumerate(v):
+# if axis_min[axis] > value: axis_min[axis]= value
+# if axis_max[axis] < value: axis_max[axis]= value
+
+# # Scale objects
+# max_axis= max(axis_max[0]-axis_min[0], axis_max[1]-axis_min[1], axis_max[2]-axis_min[2])
+# scale= 1.0
+
+# while CLAMP_SIZE < max_axis * scale:
+# scale= scale/10.0
+
+# for ob in new_objects:
+# ob.setSize(scale, scale, scale)
+
+ # Better rotate the vert locations
+ #if not ROTATE_X90:
+ # for ob in new_objects:
+ # ob.RotX = -1.570796326794896558
+
+ time_new= time.time()
+# time_new= sys.time()
+
+ print('finished importing: %r in %.4f sec.' % (filepath, (time_new-time_main)))
+ return {'FINISHED'}
+
+
+# NOTES (all line numbers refer to 2.4x import_obj.py, not this file)
+# check later: line 489
+# can convert now: edge flags, edges: lines 508-528
+# ngon (uses python module BPyMesh): 384-414
+# NEXT clamp size: get bound box with RNA
+# get back to l 140 (here)
+# search image in bpy.config.textureDir - load_image
+# replaced BPyImage.comprehensiveImageLoad with a simplified version that only checks additional directory specified, but doesn't search dirs recursively (obj_image_load)
+# bitmask won't work? - 132
+# uses bpy.sys.time()
+
+if __name__ == "__main__":
+ register()
diff --git a/io_scene_x3d/__init__.py b/io_scene_x3d/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..67d35ce9c0db7dc0cf1b644b78f0b1e306cfadc9
--- /dev/null
+++ b/io_scene_x3d/__init__.py
@@ -0,0 +1,96 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+bl_info = {
+ "name": "Web3D X3D/VRML format",
+ "author": "Campbell Barton, Bart",
+ "location": "File > Import-Export",
+ "description": "Import-Export X3D, Import VRML",
+ "warning": "",
+ "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.5/Py/"\
+ "Scripts/Import-Export/Web3D",
+ "tracker_url": "",
+ "support": 'OFFICIAL',
+ "category": "Import-Export"}
+
+# To support reload properly, try to access a package var, if it's there, reload everything
+if "bpy" in locals():
+ import imp
+ if "export_x3d" in locals():
+ imp.reload(export_x3d)
+
+
+import bpy
+from bpy.props import *
+from io_utils import ImportHelper, ExportHelper
+
+
+class ImportX3D(bpy.types.Operator, ImportHelper):
+ '''Load a BVH motion capture file'''
+ bl_idname = "import_scene.x3d"
+ bl_label = "Import X3D/VRML"
+
+ filename_ext = ".x3d"
+ filter_glob = StringProperty(default="*.x3d;*.wrl", options={'HIDDEN'})
+
+ def execute(self, context):
+ from . import import_x3d
+ return import_x3d.load(self, context, **self.as_keywords(ignore=("filter_glob",)))
+
+
+class ExportX3D(bpy.types.Operator, ExportHelper):
+ '''Export selection to Extensible 3D file (.x3d)'''
+ bl_idname = "export_scene.x3d"
+ bl_label = 'Export X3D'
+
+ filename_ext = ".x3d"
+ filter_glob = StringProperty(default="*.x3d", options={'HIDDEN'})
+
+ use_apply_modifiers = BoolProperty(name="Apply Modifiers", description="Use transformed mesh data from each object", default=True)
+ use_triangulate = BoolProperty(name="Triangulate", description="Triangulate quads.", default=False)
+ use_compress = BoolProperty(name="Compress", description="GZip the resulting file, requires a full python install", default=False)
+
+ def execute(self, context):
+ from . import export_x3d
+ return export_x3d.save(self, context, **self.as_keywords(ignore=("check_existing", "filter_glob")))
+
+
+def menu_func_import(self, context):
+ self.layout.operator(ImportX3D.bl_idname, text="X3D Extensible 3D (.x3d/.wrl)")
+
+
+def menu_func_export(self, context):
+ self.layout.operator(ExportX3D.bl_idname, text="X3D Extensible 3D (.x3d)")
+
+
+def register():
+ bpy.types.INFO_MT_file_import.append(menu_func_import)
+ bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+ bpy.types.INFO_MT_file_import.remove(menu_func_import)
+ bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+# NOTES
+# - blender version is hardcoded
+
+if __name__ == "__main__":
+ register()
diff --git a/io_scene_x3d/export_x3d.py b/io_scene_x3d/export_x3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..c420b0cddd8acf26bd25d06d96336a821ef8d653
--- /dev/null
+++ b/io_scene_x3d/export_x3d.py
@@ -0,0 +1,847 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+# Contributors: bart:neeneenee*de, http://www.neeneenee.de/vrml, Campbell Barton
+
+"""
+This script exports to X3D format.
+
+Usage:
+Run this script from "File->Export" menu. A pop-up will ask whether you
+want to export only selected or all relevant objects.
+
+Known issues:
+ Doesn't handle multiple materials (don't use material indices);<br>
+ Doesn't handle multiple UV textures on a single mesh (create a mesh for each texture);<br>
+ Can't get the texture array associated with material * not the UV ones;
+"""
+
+import math
+import os
+
+import bpy
+import mathutils
+
+from io_utils import create_derived_objects, free_derived_objects
+
+
+def round_color(col, cp):
+ return tuple([round(max(min(c, 1.0), 0.0), cp) for c in col])
+
+
+def matrix_direction(mtx):
+ return (mathutils.Vector((0.0, 0.0, -1.0)) * mtx.rotation_part()).normalize()[:]
+
+
+##########################################################
+# Functions for writing output file
+##########################################################
+
+
+class x3d_class:
+
+ def __init__(self, filepath):
+ #--- public you can change these ---
+ self.proto = 1
+ self.billnode = 0
+ self.halonode = 0
+ self.collnode = 0
+ self.verbose = 2 # level of verbosity in console 0-none, 1-some, 2-most
+ self.cp = 3 # decimals for material color values 0.000 - 1.000
+ self.vp = 3 # decimals for vertex coordinate values 0.000 - n.000
+ self.tp = 3 # decimals for texture coordinate values 0.000 - 1.000
+ self.it = 3
+
+ self.global_matrix = mathutils.Matrix.Rotation(-(math.pi / 2.0), 4, 'X')
+
+ #--- class private don't touch ---
+ self.indentLevel = 0 # keeps track of current indenting
+ self.filepath = filepath
+ self.file = None
+ if filepath.lower().endswith('.x3dz'):
+ try:
+ import gzip
+ self.file = gzip.open(filepath, "w")
+ except:
+ print("failed to import compression modules, exporting uncompressed")
+ self.filepath = filepath[:-1] # remove trailing z
+
+ if self.file is None:
+ self.file = open(self.filepath, "w", encoding='utf8')
+
+ self.bNav = 0
+ self.nodeID = 0
+ self.namesReserved = ("Anchor", "Appearance", "Arc2D", "ArcClose2D", "AudioClip", "Background", "Billboard",
+ "BooleanFilter", "BooleanSequencer", "BooleanToggle", "BooleanTrigger", "Box", "Circle2D",
+ "Collision", "Color", "ColorInterpolator", "ColorRGBA", "component", "Cone", "connect",
+ "Contour2D", "ContourPolyline2D", "Coordinate", "CoordinateDouble", "CoordinateInterpolator",
+ "CoordinateInterpolator2D", "Cylinder", "CylinderSensor", "DirectionalLight", "Disk2D",
+ "ElevationGrid", "EspduTransform", "EXPORT", "ExternProtoDeclare", "Extrusion", "field",
+ "fieldValue", "FillProperties", "Fog", "FontStyle", "GeoCoordinate", "GeoElevationGrid",
+ "GeoLocationLocation", "GeoLOD", "GeoMetadata", "GeoOrigin", "GeoPositionInterpolator",
+ "GeoTouchSensor", "GeoViewpoint", "Group", "HAnimDisplacer", "HAnimHumanoid", "HAnimJoint",
+ "HAnimSegment", "HAnimSite", "head", "ImageTexture", "IMPORT", "IndexedFaceSet",
+ "IndexedLineSet", "IndexedTriangleFanSet", "IndexedTriangleSet", "IndexedTriangleStripSet",
+ "Inline", "IntegerSequencer", "IntegerTrigger", "IS", "KeySensor", "LineProperties", "LineSet",
+ "LoadSensor", "LOD", "Material", "meta", "MetadataDouble", "MetadataFloat", "MetadataInteger",
+ "MetadataSet", "MetadataString", "MovieTexture", "MultiTexture", "MultiTextureCoordinate",
+ "MultiTextureTransform", "NavigationInfo", "Normal", "NormalInterpolator", "NurbsCurve",
+ "NurbsCurve2D", "NurbsOrientationInterpolator", "NurbsPatchSurface",
+ "NurbsPositionInterpolator", "NurbsSet", "NurbsSurfaceInterpolator", "NurbsSweptSurface",
+ "NurbsSwungSurface", "NurbsTextureCoordinate", "NurbsTrimmedSurface", "OrientationInterpolator",
+ "PixelTexture", "PlaneSensor", "PointLight", "PointSet", "Polyline2D", "Polypoint2D",
+ "PositionInterpolator", "PositionInterpolator2D", "ProtoBody", "ProtoDeclare", "ProtoInstance",
+ "ProtoInterface", "ProximitySensor", "ReceiverPdu", "Rectangle2D", "ROUTE", "ScalarInterpolator",
+ "Scene", "Script", "Shape", "SignalPdu", "Sound", "Sphere", "SphereSensor", "SpotLight", "StaticGroup",
+ "StringSensor", "Switch", "Text", "TextureBackground", "TextureCoordinate", "TextureCoordinateGenerator",
+ "TextureTransform", "TimeSensor", "TimeTrigger", "TouchSensor", "Transform", "TransmitterPdu",
+ "TriangleFanSet", "TriangleSet", "TriangleSet2D", "TriangleStripSet", "Viewpoint", "VisibilitySensor",
+ "WorldInfo", "X3D", "XvlShell", "VertexShader", "FragmentShader", "MultiShaderAppearance", "ShaderAppearance")
+
+ self.namesFog = ("", "LINEAR", "EXPONENTIAL", "")
+
+##########################################################
+# Writing nodes routines
+##########################################################
+
+ def writeHeader(self):
+ #bfile = sys.expandpath( Blender.Get('filepath') ).replace('<', '<').replace('>', '>')
+ bfile = repr(os.path.basename(self.filepath).replace('<', '<').replace('>', '>'))[1:-1] # use outfile name
+ self.file.write("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n")
+ self.file.write("<!DOCTYPE X3D PUBLIC \"ISO//Web3D//DTD X3D 3.0//EN\" \"http://www.web3d.org/specifications/x3d-3.0.dtd\">\n")
+ self.file.write("<X3D version=\"3.0\" profile=\"Immersive\" xmlns:xsd=\"http://www.w3.org/2001/XMLSchema-instance\" xsd:noNamespaceSchemaLocation=\"http://www.web3d.org/specifications/x3d-3.0.xsd\">\n")
+ self.file.write("<head>\n")
+ self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % bfile)
+ # self.file.write("\t<meta name=\"filename\" content=\"%s\" />\n" % sys.basename(bfile))
+ self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % bpy.app.version_string)
+ # self.file.write("\t<meta name=\"generator\" content=\"Blender %s\" />\n" % Blender.Get('version'))
+ self.file.write("\t<meta name=\"translator\" content=\"X3D exporter v1.55 (2006/01/17)\" />\n")
+ self.file.write("</head>\n")
+ self.file.write("<Scene>\n")
+
+ # This functionality is poorly defined, disabling for now - campbell
+ '''
+ def writeScript(self):
+ textEditor = Blender.Text.Get()
+ alltext = len(textEditor)
+ for i in xrange(alltext):
+ nametext = textEditor[i].name
+ nlines = textEditor[i].getNLines()
+ if (self.proto == 1):
+ if (nametext == "proto" or nametext == "proto.js" or nametext == "proto.txt") and (nlines != None):
+ nalllines = len(textEditor[i].asLines())
+ alllines = textEditor[i].asLines()
+ for j in xrange(nalllines):
+ self.write_indented(alllines[j] + "\n")
+ elif (self.proto == 0):
+ if (nametext == "route" or nametext == "route.js" or nametext == "route.txt") and (nlines != None):
+ nalllines = len(textEditor[i].asLines())
+ alllines = textEditor[i].asLines()
+ for j in xrange(nalllines):
+ self.write_indented(alllines[j] + "\n")
+ self.write_indented("\n")
+ '''
+
+ def writeViewpoint(self, ob, mat, scene):
+ loc, quat, scale = mat.decompose()
+ self.file.write("<Viewpoint DEF=\"%s\" " % (self.cleanStr(ob.name)))
+ self.file.write("description=\"%s\" " % (ob.name))
+ self.file.write("centerOfRotation=\"0 0 0\" ")
+ self.file.write("position=\"%3.2f %3.2f %3.2f\" " % loc[:])
+ self.file.write("orientation=\"%3.2f %3.2f %3.2f %3.2f\" " % (quat.axis[:] + (quat.angle, )))
+ self.file.write("fieldOfView=\"%.3f\" " % ob.data.angle)
+ self.file.write(" />\n\n")
+
+ def writeFog(self, world):
+ if world:
+ mtype = world.mist_settings.falloff
+ mparam = world.mist_settings
+ else:
+ return
+ if (mtype == 'LINEAR' or mtype == 'INVERSE_QUADRATIC'):
+ mtype = 1 if mtype == 'LINEAR' else 2
+ # if (mtype == 1 or mtype == 2):
+ self.file.write("<Fog fogType=\"%s\" " % self.namesFog[mtype])
+ self.file.write("color=\"%s %s %s\" " % round_color(world.horizon_color, self.cp))
+ self.file.write("visibilityRange=\"%s\" />\n\n" % round(mparam[2], self.cp))
+ else:
+ return
+
+ def writeNavigationInfo(self, scene):
+ self.file.write('<NavigationInfo headlight="false" visibilityLimit="0.0" type=\'"EXAMINE","ANY"\' avatarSize="0.25, 1.75, 0.75" />\n')
+
+ def writeSpotLight(self, ob, mtx, lamp, world):
+ safeName = self.cleanStr(ob.name)
+ if world:
+ ambi = world.ambient_color
+ ambientIntensity = ((ambi[0] + ambi[1] + ambi[2]) / 3.0) / 2.5
+ del ambi
+ else:
+ ambientIntensity = 0.0
+
+ # compute cutoff and beamwidth
+ intensity = min(lamp.energy / 1.75, 1.0)
+ beamWidth = lamp.spot_size * 0.37
+ # beamWidth=((lamp.spotSize*math.pi)/180.0)*.37
+ cutOffAngle = beamWidth * 1.3
+
+ dx, dy, dz = matrix_direction(mtx)
+
+ location = mtx.translation_part()
+
+ radius = lamp.distance * math.cos(beamWidth)
+ # radius = lamp.dist*math.cos(beamWidth)
+ self.file.write("<SpotLight DEF=\"%s\" " % safeName)
+ self.file.write("radius=\"%s\" " % (round(radius, self.cp)))
+ self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity, self.cp)))
+ self.file.write("intensity=\"%s\" " % (round(intensity, self.cp)))
+ self.file.write("color=\"%s %s %s\" " % round_color(lamp.color, self.cp))
+ self.file.write("beamWidth=\"%s\" " % (round(beamWidth, self.cp)))
+ self.file.write("cutOffAngle=\"%s\" " % (round(cutOffAngle, self.cp)))
+ self.file.write("direction=\"%s %s %s\" " % (round(dx, 3), round(dy, 3), round(dz, 3)))
+ self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0], 3), round(location[1], 3), round(location[2], 3)))
+
+ def writeDirectionalLight(self, ob, mtx, lamp, world):
+ safeName = self.cleanStr(ob.name)
+ if world:
+ ambi = world.ambient_color
+ # ambi = world.amb
+ ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2])) / 3.0) / 2.5
+ else:
+ ambi = 0
+ ambientIntensity = 0
+
+ intensity = min(lamp.energy / 1.75, 1.0)
+ dx, dy, dz = matrix_direction(mtx)
+ self.file.write("<DirectionalLight DEF=\"%s\" " % safeName)
+ self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity, self.cp)))
+ self.file.write("color=\"%s %s %s\" " % (round(lamp.color[0], self.cp), round(lamp.color[1], self.cp), round(lamp.color[2], self.cp)))
+ self.file.write("intensity=\"%s\" " % (round(intensity, self.cp)))
+ self.file.write("direction=\"%s %s %s\" />\n\n" % (round(dx, 4), round(dy, 4), round(dz, 4)))
+
+ def writePointLight(self, ob, mtx, lamp, world):
+ safeName = self.cleanStr(ob.name)
+ if world:
+ ambi = world.ambient_color
+ # ambi = world.amb
+ ambientIntensity = ((float(ambi[0] + ambi[1] + ambi[2])) / 3) / 2.5
+ else:
+ ambi = 0
+ ambientIntensity = 0
+
+ location = mtx.translation_part()
+
+ self.file.write("<PointLight DEF=\"%s\" " % safeName)
+ self.file.write("ambientIntensity=\"%s\" " % (round(ambientIntensity, self.cp)))
+ self.file.write("color=\"%s %s %s\" " % (round(lamp.color[0], self.cp), round(lamp.color[1], self.cp), round(lamp.color[2], self.cp)))
+
+ self.file.write("intensity=\"%s\" " % (round(min(lamp.energy / 1.75, 1.0), self.cp)))
+ self.file.write("radius=\"%s\" " % lamp.distance)
+ self.file.write("location=\"%s %s %s\" />\n\n" % (round(location[0], 3), round(location[1], 3), round(location[2], 3)))
+
+ def secureName(self, name):
+ name = name + str(self.nodeID)
+ self.nodeID = self.nodeID + 1
+ if len(name) <= 3:
+ newname = "_" + str(self.nodeID)
+ return "%s" % (newname)
+ else:
+ for bad in ('"', '#', "'", ', ', '.', '[', '\\', ']', '{', '}'):
+ name = name.replace(bad, "_")
+ if name in self.namesReserved:
+ newname = name[0:3] + "_" + str(self.nodeID)
+ return "%s" % (newname)
+ elif name[0].isdigit():
+ newname = "_" + name + str(self.nodeID)
+ return "%s" % (newname)
+ else:
+ newname = name
+ return "%s" % (newname)
+
+ def writeIndexedFaceSet(self, ob, mesh, mtx, world, EXPORT_TRI=False):
+ fw = self.file.write
+ mesh_name_x3d = self.cleanStr(ob.name)
+
+ if not mesh.faces:
+ return
+
+ mode = []
+ # mode = 0
+ if mesh.uv_textures.active:
+ # if mesh.faceUV:
+ for face in mesh.uv_textures.active.data:
+ # for face in mesh.faces:
+ if face.use_halo and 'HALO' not in mode:
+ mode += ['HALO']
+ if face.use_billboard and 'BILLBOARD' not in mode:
+ mode += ['BILLBOARD']
+ if face.use_object_color and 'OBJECT_COLOR' not in mode:
+ mode += ['OBJECT_COLOR']
+ if face.use_collision and 'COLLISION' not in mode:
+ mode += ['COLLISION']
+ # mode |= face.mode
+
+ if 'HALO' in mode and self.halonode == 0:
+ # if mode & Mesh.FaceModes.HALO and self.halonode == 0:
+ self.write_indented("<Billboard axisOfRotation=\"0 0 0\">\n", 1)
+ self.halonode = 1
+ elif 'BILLBOARD' in mode and self.billnode == 0:
+ # elif mode & Mesh.FaceModes.BILLBOARD and self.billnode == 0:
+ self.write_indented("<Billboard axisOfRotation=\"0 1 0\">\n", 1)
+ self.billnode = 1
+ elif 'COLLISION' not in mode and self.collnode == 0:
+ # elif not mode & Mesh.FaceModes.DYNAMIC and self.collnode == 0:
+ self.write_indented("<Collision enabled=\"false\">\n", 1)
+ self.collnode = 1
+
+ loc, quat, sca = mtx.decompose()
+
+ self.write_indented("<Transform DEF=\"%s\" " % mesh_name_x3d, 1)
+ fw("translation=\"%.6f %.6f %.6f\" " % loc[:])
+ fw("scale=\"%.6f %.6f %.6f\" " % sca[:])
+ fw("rotation=\"%.6f %.6f %.6f %.6f\" " % (quat.axis[:] + (quat.angle, )))
+ fw(">\n")
+
+ if mesh.tag:
+ self.write_indented("<Group USE=\"G_%s\" />\n" % mesh_name_x3d, 1)
+ else:
+ mesh.tag = True
+
+ self.write_indented("<Group DEF=\"G_%s\">\n" % mesh_name_x3d, 1)
+
+ is_uv = bool(mesh.uv_textures.active)
+ # is_col, defined for each material
+
+ is_coords_written = False
+
+ mesh_materials = mesh.materials[:]
+ if not mesh_materials:
+ mesh_materials = [None]
+
+ mesh_material_tex = [None] * len(mesh_materials)
+ mesh_material_mtex = [None] * len(mesh_materials)
+ mesh_material_images = [None] * len(mesh_materials)
+
+ for i, material in enumerate(mesh_materials):
+ if material:
+ for mtex in material.texture_slots:
+ if mtex:
+ tex = mtex.texture
+ if tex and tex.type == 'IMAGE':
+ image = tex.image
+ if image:
+ mesh_material_tex[i] = tex
+ mesh_material_mtex[i] = mtex
+ mesh_material_images[i] = image
+ break
+
+ mesh_materials_use_face_texture = [getattr(material, "use_face_texture", True) for material in mesh_materials]
+
+ mesh_faces = mesh.faces[:]
+ mesh_faces_materials = [f.material_index for f in mesh_faces]
+
+ if is_uv and True in mesh_materials_use_face_texture:
+ mesh_faces_image = [(fuv.image if (mesh_materials_use_face_texture[mesh_faces_materials[i]] and fuv.use_image) else mesh_material_images[mesh_faces_materials[i]]) for i, fuv in enumerate(mesh.uv_textures.active.data)]
+ mesh_faces_image_unique = set(mesh_faces_image)
+ elif len(set(mesh_material_images) | {None}) > 1: # make sure there is at least one image
+ mesh_faces_image = [mesh_material_images[material_index] for material_index in mesh_faces_materials]
+ mesh_faces_image_unique = set(mesh_faces_image)
+ else:
+ mesh_faces_image = [None] * len(mesh_faces)
+ mesh_faces_image_unique = {None}
+
+ # group faces
+ face_groups = {}
+ for material_index in range(len(mesh_materials)):
+ for image in mesh_faces_image_unique:
+ face_groups[material_index, image] = []
+ del mesh_faces_image_unique
+
+ for i, (material_index, image) in enumerate(zip(mesh_faces_materials, mesh_faces_image)):
+ face_groups[material_index, image].append(i)
+
+ for (material_index, image), face_group in face_groups.items():
+ if face_group:
+ material = mesh_materials[material_index]
+
+ self.write_indented("<Shape>\n", 1)
+ is_smooth = False
+ is_col = (mesh.vertex_colors.active and (material is None or material.use_vertex_color_paint))
+
+ # kludge but as good as it gets!
+ for i in face_group:
+ if mesh_faces[i].use_smooth:
+ is_smooth = True
+ break
+
+ if image:
+ self.write_indented("<Appearance>\n", 1)
+ self.writeImageTexture(image)
+
+ if mesh_materials_use_face_texture[material_index]:
+ if image.use_tiles:
+ self.write_indented("<TextureTransform scale=\"%s %s\" />\n" % (image.tiles_x, image.tiles_y))
+ else:
+ # transform by mtex
+ loc = mesh_material_mtex[material_index].offset[:2]
+
+ # mtex_scale * tex_repeat
+ sca_x, sca_y = mesh_material_mtex[material_index].scale[:2]
+
+ sca_x *= mesh_material_tex[material_index].repeat_x
+ sca_y *= mesh_material_tex[material_index].repeat_y
+
+ # flip x/y is a sampling feature, convert to transform
+ if mesh_material_tex[material_index].use_flip_axis:
+ rot = math.pi / -2.0
+ sca_x, sca_y = sca_y, -sca_x
+ else:
+ rot = 0.0
+
+ self.write_indented("<TextureTransform ", 1)
+ # fw("center=\"%.6f %.6f\" " % (0.0, 0.0))
+ fw("translation=\"%.6f %.6f\" " % loc)
+ fw("scale=\"%.6f %.6f\" " % (sca_x, sca_y))
+ fw("rotation=\"%.6f\" " % rot)
+ fw("/>\n")
+
+ self.write_indented("</Appearance>\n", -1)
+
+ elif material:
+ self.write_indented("<Appearance>\n", 1)
+ self.writeMaterial(material, self.cleanStr(material.name, ""), world)
+ self.write_indented("</Appearance>\n", -1)
+
+ #-- IndexedFaceSet or IndexedLineSet
+
+ self.write_indented("<IndexedFaceSet ", 1)
+
+ # --- Write IndexedFaceSet Attributes
+ if mesh.show_double_sided:
+ fw("solid=\"true\" ")
+ else:
+ fw("solid=\"false\" ")
+
+ if is_smooth:
+ fw("creaseAngle=\"%.4f\" " % mesh.auto_smooth_angle)
+
+ if is_uv:
+ # "texCoordIndex"
+ fw("\n\t\t\ttexCoordIndex=\"")
+ j = 0
+ for i in face_group:
+ if len(mesh_faces[i].vertices) == 4:
+ fw("%d %d %d %d -1, " % (j, j + 1, j + 2, j + 3))
+ j += 4
+ else:
+ fw("%d %d %d -1, " % (j, j + 1, j + 2))
+ j += 3
+ fw("\" ")
+ # --- end texCoordIndex
+
+ if is_col:
+ fw("colorPerVertex=\"false\" ")
+
+ if True:
+ # "coordIndex"
+ fw('coordIndex="')
+ if EXPORT_TRI:
+ for i in face_group:
+ fv = mesh_faces[i].vertices[:]
+ if len(fv) == 3:
+ fw("%i %i %i -1, " % fv)
+ else:
+ fw("%i %i %i -1, " % (fv[0], fv[1], fv[2]))
+ fw("%i %i %i -1, " % (fv[0], fv[2], fv[3]))
+ else:
+ for i in face_group:
+ fv = mesh_faces[i].vertices[:]
+ if len(fv) == 3:
+ fw("%i %i %i -1, " % fv)
+ else:
+ fw("%i %i %i %i -1, " % fv)
+
+ fw("\" ")
+ # --- end coordIndex
+
+ # close IndexedFaceSet
+ fw(">\n")
+
+ # --- Write IndexedFaceSet Elements
+ if True:
+ if is_coords_written:
+ self.write_indented("<Coordinate USE=\"%s%s\" />\n" % ("coord_", mesh_name_x3d))
+ else:
+ self.write_indented("<Coordinate DEF=\"%s%s\" \n" % ("coord_", mesh_name_x3d), 1)
+ fw("\t\t\t\tpoint=\"")
+ for v in mesh.vertices:
+ fw("%.6f %.6f %.6f, " % v.co[:])
+ fw("\" />")
+ self.write_indented("\n", -1)
+ is_coords_written = True
+
+ if is_uv:
+ self.write_indented("<TextureCoordinate point=\"", 1)
+ fw = fw
+ mesh_faces_uv = mesh.uv_textures.active.data
+ for i in face_group:
+ for uv in mesh_faces_uv[i].uv:
+ fw("%.4f %.4f, " % uv[:])
+ del mesh_faces_uv
+ fw("\" />")
+ self.write_indented("\n", -1)
+
+ if is_col:
+ self.write_indented("<Color color=\"", 1)
+ # XXX, 1 color per face, only
+ mesh_faces_col = mesh.vertex_colors.active.data
+ for i in face_group:
+ fw("%.3f %.3f %.3f, " % mesh_faces_col[i].color1[:])
+ del mesh_faces_col
+ fw("\" />")
+ self.write_indented("\n", -1)
+
+ #--- output vertexColors
+
+ #--- output closing braces
+ self.write_indented("</IndexedFaceSet>\n", -1)
+ self.write_indented("</Shape>\n", -1)
+
+ self.write_indented("</Group>\n", -1)
+
+ self.write_indented("</Transform>\n", -1)
+
+ if self.halonode == 1:
+ self.write_indented("</Billboard>\n", -1)
+ self.halonode = 0
+
+ if self.billnode == 1:
+ self.write_indented("</Billboard>\n", -1)
+ self.billnode = 0
+
+ if self.collnode == 1:
+ self.write_indented("</Collision>\n", -1)
+ self.collnode = 0
+
+ fw("\n")
+
+ def writeMaterial(self, mat, matName, world):
+ # look up material name, use it if available
+ if mat.tag:
+ self.write_indented("<Material USE=\"MA_%s\" />\n" % matName)
+ else:
+ mat.tag = True
+
+ emit = mat.emit
+ ambient = mat.ambient / 3.0
+ diffuseColor = tuple(mat.diffuse_color)
+ if world:
+ ambiColor = tuple(((c * mat.ambient) * 2.0) for c in world.ambient_color)
+ else:
+ ambiColor = 0.0, 0.0, 0.0
+
+ emitColor = tuple(((c * emit) + ambiColor[i]) / 2.0 for i, c in enumerate(diffuseColor))
+ shininess = mat.specular_hardness / 512.0
+ specColor = tuple((c + 0.001) / (1.25 / (mat.specular_intensity + 0.001)) for c in mat.specular_color)
+ transp = 1.0 - mat.alpha
+
+ if mat.use_shadeless:
+ ambient = 1.0
+ shininess = 0.0
+ specColor = emitColor = diffuseColor
+
+ self.write_indented("<Material DEF=\"MA_%s\" " % matName, 1)
+ self.file.write("diffuseColor=\"%s %s %s\" " % round_color(diffuseColor, self.cp))
+ self.file.write("specularColor=\"%s %s %s\" " % round_color(specColor, self.cp))
+ self.file.write("emissiveColor=\"%s %s %s\" \n" % round_color(emitColor, self.cp))
+ self.write_indented("ambientIntensity=\"%s\" " % (round(ambient, self.cp)))
+ self.file.write("shininess=\"%s\" " % (round(shininess, self.cp)))
+ self.file.write("transparency=\"%s\" />" % (round(transp, self.cp)))
+ self.write_indented("\n", -1)
+
+ def writeImageTexture(self, image):
+ name = image.name
+ filepath = os.path.basename(image.filepath)
+ if image.tag:
+ self.write_indented("<ImageTexture USE=\"%s\" />\n" % self.cleanStr(name))
+ else:
+ image.tag = True
+
+ self.write_indented("<ImageTexture DEF=\"%s\" " % self.cleanStr(name), 1)
+ self.file.write("url=\"%s\" />" % filepath)
+ self.write_indented("\n", -1)
+
+ def writeBackground(self, world, alltextures):
+ if world:
+ worldname = world.name
+ else:
+ return
+
+ blending = world.use_sky_blend, world.use_sky_paper, world.use_sky_real
+
+ grd_triple = round_color(world.horizon_color, self.cp)
+ sky_triple = round_color(world.zenith_color, self.cp)
+ mix_triple = round_color(((grd_triple[i] + sky_triple[i]) / 2.0 for i in range(3)), self.cp)
+
+ self.file.write("<Background DEF=\"%s\" " % self.secureName(worldname))
+ # No Skytype - just Hor color
+ if blending == (False, False, False):
+ self.file.write("groundColor=\"%s %s %s\" " % grd_triple)
+ self.file.write("skyColor=\"%s %s %s\" " % grd_triple)
+ # Blend Gradient
+ elif blending == (True, False, False):
+ self.file.write("groundColor=\"%s %s %s, " % grd_triple)
+ self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " % mix_triple)
+ self.file.write("skyColor=\"%s %s %s, " % sky_triple)
+ self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " % mix_triple)
+ # Blend+Real Gradient Inverse
+ elif blending == (True, False, True):
+ self.file.write("groundColor=\"%s %s %s, " % sky_triple)
+ self.file.write("%s %s %s\" groundAngle=\"1.57, 1.57\" " % mix_triple)
+ self.file.write("skyColor=\"%s %s %s, " % grd_triple)
+ self.file.write("%s %s %s\" skyAngle=\"1.57, 1.57\" " % mix_triple)
+ # Paper - just Zen Color
+ elif blending == (False, False, True):
+ self.file.write("groundColor=\"%s %s %s\" " % sky_triple)
+ self.file.write("skyColor=\"%s %s %s\" " % sky_triple)
+ # Blend+Real+Paper - komplex gradient
+ elif blending == (True, True, True):
+ self.write_indented("groundColor=\"%s %s %s, " % sky_triple)
+ self.write_indented("%s %s %s\" groundAngle=\"1.57, 1.57\" " % grd_triple)
+ self.write_indented("skyColor=\"%s %s %s, " % sky_triple)
+ self.write_indented("%s %s %s\" skyAngle=\"1.57, 1.57\" " % grd_triple)
+ # Any Other two colors
+ else:
+ self.file.write("groundColor=\"%s %s %s\" " % grd_triple)
+ self.file.write("skyColor=\"%s %s %s\" " % sky_triple)
+
+ alltexture = len(alltextures)
+
+ for i in range(alltexture):
+ tex = alltextures[i]
+
+ if tex.type != 'IMAGE' or tex.image is None:
+ continue
+
+ namemat = tex.name
+ # namemat = alltextures[i].name
+
+ pic = tex.image
+
+ # using .expandpath just in case, os.path may not expect //
+ basename = os.path.basename(bpy.path.abspath(pic.filepath))
+
+ pic = alltextures[i].image
+ if (namemat == "back") and (pic != None):
+ self.file.write("\n\tbackUrl=\"%s\" " % basename)
+ elif (namemat == "bottom") and (pic != None):
+ self.write_indented("bottomUrl=\"%s\" " % basename)
+ elif (namemat == "front") and (pic != None):
+ self.write_indented("frontUrl=\"%s\" " % basename)
+ elif (namemat == "left") and (pic != None):
+ self.write_indented("leftUrl=\"%s\" " % basename)
+ elif (namemat == "right") and (pic != None):
+ self.write_indented("rightUrl=\"%s\" " % basename)
+ elif (namemat == "top") and (pic != None):
+ self.write_indented("topUrl=\"%s\" " % basename)
+ self.write_indented("/>\n\n")
+
+##########################################################
+# export routine
+##########################################################
+
+ def export(self, scene, world, alltextures,
+ EXPORT_APPLY_MODIFIERS=False,
+ EXPORT_TRI=False,
+ ):
+
+ # tag un-exported IDs
+ bpy.data.meshes.tag(False)
+ bpy.data.materials.tag(False)
+ bpy.data.images.tag(False)
+
+ print("Info: starting X3D export to %r..." % self.filepath)
+ self.writeHeader()
+ # self.writeScript()
+ self.writeNavigationInfo(scene)
+ self.writeBackground(world, alltextures)
+ self.writeFog(world)
+ self.proto = 0
+
+ for ob_main in [o for o in scene.objects if o.is_visible(scene)]:
+
+ free, derived = create_derived_objects(scene, ob_main)
+
+ if derived is None:
+ continue
+
+ for ob, ob_mat in derived:
+ objType = ob.type
+ objName = ob.name
+ ob_mat = self.global_matrix * ob_mat
+
+ if objType == 'CAMERA':
+ self.writeViewpoint(ob, ob_mat, scene)
+ elif objType in ('MESH', 'CURVE', 'SURF', 'FONT'):
+ if EXPORT_APPLY_MODIFIERS or objType != 'MESH':
+ me = ob.create_mesh(scene, EXPORT_APPLY_MODIFIERS, 'PREVIEW')
+ else:
+ me = ob.data
+
+ self.writeIndexedFaceSet(ob, me, ob_mat, world, EXPORT_TRI=EXPORT_TRI)
+
+ # free mesh created with create_mesh()
+ if me != ob.data:
+ bpy.data.meshes.remove(me)
+
+ elif objType == 'LAMP':
+ data = ob.data
+ datatype = data.type
+ if datatype == 'POINT':
+ self.writePointLight(ob, ob_mat, data, world)
+ elif datatype == 'SPOT':
+ self.writeSpotLight(ob, ob_mat, data, world)
+ elif datatype == 'SUN':
+ self.writeDirectionalLight(ob, ob_mat, data, world)
+ else:
+ self.writeDirectionalLight(ob, ob_mat, data, world)
+ else:
+ #print "Info: Ignoring [%s], object type [%s] not handle yet" % (object.name,object.getType)
+ pass
+
+ if free:
+ free_derived_objects(ob_main)
+
+ self.file.write("\n</Scene>\n</X3D>")
+
+ # if EXPORT_APPLY_MODIFIERS:
+ # if containerMesh:
+ # containerMesh.vertices = None
+
+ self.cleanup()
+
+##########################################################
+# Utility methods
+##########################################################
+
+ def cleanup(self):
+ self.file.close()
+ self.indentLevel = 0
+ print("Info: finished X3D export to %r" % self.filepath)
+
+ def cleanStr(self, name, prefix='rsvd_'):
+ """cleanStr(name,prefix) - try to create a valid VRML DEF name from object name"""
+
+ newName = name
+ if len(newName) == 0:
+ self.nNodeID += 1
+ return "%s%d" % (prefix, self.nNodeID)
+
+ if newName in self.namesReserved:
+ newName = '%s%s' % (prefix, newName)
+
+ if newName[0].isdigit():
+ newName = "%s%s" % ('_', newName)
+
+ for bad in [' ', '"', '#', "'", ', ', '.', '[', '\\', ']', '{', '}']:
+ newName = newName.replace(bad, '_')
+ return newName
+
+ def faceToString(self, face):
+
+ print("Debug: face.flag=0x%x (bitflags)" % face.flag)
+ if face.sel:
+ print("Debug: face.sel=true")
+
+ print("Debug: face.mode=0x%x (bitflags)" % face.mode)
+ if face.mode & Mesh.FaceModes.TWOSIDE:
+ print("Debug: face.mode twosided")
+
+ print("Debug: face.transp=0x%x (enum)" % face.blend_type)
+ if face.blend_type == Mesh.FaceTranspModes.SOLID:
+ print("Debug: face.transp.SOLID")
+
+ if face.image:
+ print("Debug: face.image=%s" % face.image.name)
+ print("Debug: face.materialIndex=%d" % face.materialIndex)
+
+ def meshToString(self, mesh):
+ # print("Debug: mesh.hasVertexUV=%d" % mesh.vertexColors)
+ print("Debug: mesh.faceUV=%d" % (len(mesh.uv_textures) > 0))
+ # print("Debug: mesh.faceUV=%d" % mesh.faceUV)
+ print("Debug: mesh.hasVertexColours=%d" % (len(mesh.vertex_colors) > 0))
+ # print("Debug: mesh.hasVertexColours=%d" % mesh.hasVertexColours())
+ print("Debug: mesh.vertices=%d" % len(mesh.vertices))
+ print("Debug: mesh.faces=%d" % len(mesh.faces))
+ print("Debug: mesh.materials=%d" % len(mesh.materials))
+
+ # s="%s %s %s" % (
+ # round(c.r/255.0,self.cp),
+ # round(c.g/255.0,self.cp),
+ # round(c.b/255.0,self.cp))
+ return s
+
+ # For writing well formed VRML code
+ #------------------------------------------------------------------------
+ def write_indented(self, s, inc=0):
+ if inc < 1:
+ self.indentLevel = self.indentLevel + inc
+
+ self.file.write((self.indentLevel * "\t") + s)
+
+ if inc > 0:
+ self.indentLevel = self.indentLevel + inc
+
+##########################################################
+# Callbacks, needed before Main
+##########################################################
+
+
+def save(operator, context, filepath="",
+ use_apply_modifiers=False,
+ use_triangulate=False,
+ use_compress=False):
+
+ if use_compress:
+ if not filepath.lower().endswith('.x3dz'):
+ filepath = '.'.join(filepath.split('.')[:-1]) + '.x3dz'
+ else:
+ if not filepath.lower().endswith('.x3d'):
+ filepath = '.'.join(filepath.split('.')[:-1]) + '.x3d'
+
+ scene = context.scene
+ world = scene.world
+
+ if bpy.ops.object.mode_set.poll():
+ bpy.ops.object.mode_set(mode='OBJECT')
+
+ # XXX these are global textures while .Get() returned only scene's?
+ alltextures = bpy.data.textures
+ # alltextures = Blender.Texture.Get()
+
+ wrlexport = x3d_class(filepath)
+ wrlexport.export(scene,
+ world,
+ alltextures,
+ EXPORT_APPLY_MODIFIERS=use_apply_modifiers,
+ EXPORT_TRI=use_triangulate,
+ )
+
+ return {'FINISHED'}
diff --git a/io_scene_x3d/import_x3d.py b/io_scene_x3d/import_x3d.py
new file mode 100644
index 0000000000000000000000000000000000000000..f28859438661164dcbaf5fefa20cb09c6ad6ce2a
--- /dev/null
+++ b/io_scene_x3d/import_x3d.py
@@ -0,0 +1,2658 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software Foundation,
+# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+
+DEBUG = False
+
+# This should work without a blender at all
+from os.path import exists
+
+
+def baseName(path):
+ return path.split('/')[-1].split('\\')[-1]
+
+
+def dirName(path):
+ return path[:-len(baseName(path))]
+
+
+def imageConvertCompat(path):
+
+ try:
+ import os
+ except:
+ return path
+ if os.sep == '\\':
+ return path # assime win32 has quicktime, dont convert
+
+ if path.lower().endswith('.gif'):
+ path_to = path[:-3] + 'png'
+
+ '''
+ if exists(path_to):
+ return path_to
+ '''
+ # print('\n'+path+'\n'+path_to+'\n')
+ os.system('convert "%s" "%s"' % (path, path_to)) # for now just hope we have image magick
+
+ if exists(path_to):
+ return path_to
+
+ return path
+
+# notes
+# transform are relative
+# order dosnt matter for loc/size/rot
+# right handed rotation
+# angles are in radians
+# rotation first defines axis then ammount in radians
+
+
+# =============================== VRML Spesific
+
+def vrmlFormat(data):
+ '''
+ Keep this as a valid vrml file, but format in a way we can predict.
+ '''
+ # Strip all commends - # not in strings - warning multiline strings are ignored.
+ def strip_comment(l):
+ #l = ' '.join(l.split())
+ l = l.strip()
+
+ if l.startswith('#'):
+ return ''
+
+ i = l.find('#')
+
+ if i == -1:
+ return l
+
+ # Most cases accounted for! if we have a comment at the end of the line do this...
+ #j = l.find('url "')
+ j = l.find('"')
+
+ if j == -1: # simple no strings
+ return l[:i].strip()
+
+ q = False
+ for i, c in enumerate(l):
+ if c == '"':
+ q = not q # invert
+
+ elif c == '#':
+ if q == False:
+ return l[:i - 1]
+
+ return l
+
+ data = '\n'.join([strip_comment(l) for l in data.split('\n')]) # remove all whitespace
+
+ EXTRACT_STRINGS = True # only needed when strings or filesnames containe ,[]{} chars :/
+
+ if EXTRACT_STRINGS:
+
+ # We need this so we can detect URL's
+ data = '\n'.join([' '.join(l.split()) for l in data.split('\n')]) # remove all whitespace
+
+ string_ls = []
+
+ #search = 'url "'
+ search = '"'
+
+ ok = True
+ last_i = 0
+ while ok:
+ ok = False
+ i = data.find(search, last_i)
+ if i != -1:
+
+ start = i + len(search) # first char after end of search
+ end = data.find('"', start)
+ if end != -1:
+ item = data[start:end]
+ string_ls.append(item)
+ data = data[:start] + data[end:]
+ ok = True # keep looking
+
+ last_i = (end - len(item)) + 1
+ # print(last_i, item, '|' + data[last_i] + '|')
+
+ # done with messy extracting strings part
+
+ # Bad, dont take strings into account
+ '''
+ data = data.replace('#', '\n#')
+ data = '\n'.join([ll for l in data.split('\n') for ll in (l.strip(),) if not ll.startswith('#')]) # remove all whitespace
+ '''
+ data = data.replace('{', '\n{\n')
+ data = data.replace('}', '\n}\n')
+ data = data.replace('[', '\n[\n')
+ data = data.replace(']', '\n]\n')
+ data = data.replace(',', ' , ') # make sure comma's seperate
+
+ if EXTRACT_STRINGS:
+ # add strings back in
+
+ search = '"' # fill in these empty strings
+
+ ok = True
+ last_i = 0
+ while ok:
+ ok = False
+ i = data.find(search + '"', last_i)
+ # print(i)
+ if i != -1:
+ start = i + len(search) # first char after end of search
+ item = string_ls.pop(0)
+ # print(item)
+ data = data[:start] + item + data[start:]
+
+ last_i = start + len(item) + 1
+
+ ok = True
+
+ # More annoying obscure cases where USE or DEF are placed on a newline
+ # data = data.replace('\nDEF ', ' DEF ')
+ # data = data.replace('\nUSE ', ' USE ')
+
+ data = '\n'.join([' '.join(l.split()) for l in data.split('\n')]) # remove all whitespace
+
+ # Better to parse the file accounting for multiline arrays
+ '''
+ data = data.replace(',\n', ' , ') # remove line endings with commas
+ data = data.replace(']', '\n]\n') # very very annoying - but some comma's are at the end of the list, must run this again.
+ '''
+
+ return [l for l in data.split('\n') if l]
+
+NODE_NORMAL = 1 # {}
+NODE_ARRAY = 2 # []
+NODE_REFERENCE = 3 # USE foobar
+# NODE_PROTO = 4 #
+
+lines = []
+
+
+def getNodePreText(i, words):
+ # print(lines[i])
+ use_node = False
+ while len(words) < 5:
+
+ if i >= len(lines):
+ break
+ '''
+ elif lines[i].startswith('PROTO'):
+ return NODE_PROTO, i+1
+ '''
+ elif lines[i] == '{':
+ # words.append(lines[i]) # no need
+ # print("OK")
+ return NODE_NORMAL, i + 1
+ elif lines[i].count('"') % 2 != 0: # odd number of quotes? - part of a string.
+ # print('ISSTRING')
+ break
+ else:
+ new_words = lines[i].split()
+ if 'USE' in new_words:
+ use_node = True
+
+ words.extend(new_words)
+ i += 1
+
+ # Check for USE node - no {
+ # USE #id - should always be on the same line.
+ if use_node:
+ # print('LINE', i, words[:words.index('USE')+2])
+ words[:] = words[:words.index('USE') + 2]
+ if lines[i] == '{' and lines[i + 1] == '}':
+ # USE sometimes has {} after it anyway
+ i += 2
+ return NODE_REFERENCE, i
+
+ # print("error value!!!", words)
+ return 0, -1
+
+
+def is_nodeline(i, words):
+
+ if not lines[i][0].isalpha():
+ return 0, 0
+
+ #if lines[i].startswith('field'):
+ # return 0, 0
+
+ # Is this a prototype??
+ if lines[i].startswith('PROTO'):
+ words[:] = lines[i].split()
+ return NODE_NORMAL, i + 1 # TODO - assumes the next line is a '[\n', skip that
+ if lines[i].startswith('EXTERNPROTO'):
+ words[:] = lines[i].split()
+ return NODE_ARRAY, i + 1 # TODO - assumes the next line is a '[\n', skip that
+
+ '''
+ proto_type, new_i = is_protoline(i, words, proto_field_defs)
+ if new_i != -1:
+ return proto_type, new_i
+ '''
+
+ # Simple "var [" type
+ if lines[i + 1] == '[':
+ if lines[i].count('"') % 2 == 0:
+ words[:] = lines[i].split()
+ return NODE_ARRAY, i + 2
+
+ node_type, new_i = getNodePreText(i, words)
+
+ if not node_type:
+ if DEBUG:
+ print("not node_type", lines[i])
+ return 0, 0
+
+ # Ok, we have a { after some values
+ # Check the values are not fields
+ for i, val in enumerate(words):
+ if i != 0 and words[i - 1] in ('DEF', 'USE'):
+ # ignore anything after DEF, it is a ID and can contain any chars.
+ pass
+ elif val[0].isalpha() and val not in ('TRUE', 'FALSE'):
+ pass
+ else:
+ # There is a number in one of the values, therefor we are not a node.
+ return 0, 0
+
+ #if node_type==NODE_REFERENCE:
+ # print(words, "REF_!!!!!!!")
+ return node_type, new_i
+
+
+def is_numline(i):
+ '''
+ Does this line start with a number?
+ '''
+
+ # Works but too slow.
+ '''
+ l = lines[i]
+ for w in l.split():
+ if w==',':
+ pass
+ else:
+ try:
+ float(w)
+ return True
+
+ except:
+ return False
+
+ return False
+ '''
+
+ l = lines[i]
+
+ line_start = 0
+
+ if l.startswith(', '):
+ line_start += 2
+
+ line_end = len(l) - 1
+ line_end_new = l.find(' ', line_start) # comma's always have a space before them
+
+ if line_end_new != -1:
+ line_end = line_end_new
+
+ try:
+ float(l[line_start:line_end]) # works for a float or int
+ return True
+ except:
+ return False
+
+
+class vrmlNode(object):
+ __slots__ = ('id',
+ 'fields',
+ 'proto_node',
+ 'proto_field_defs',
+ 'proto_fields',
+ 'node_type',
+ 'parent',
+ 'children',
+ 'parent',
+ 'array_data',
+ 'reference',
+ 'lineno',
+ 'filename',
+ 'blendObject',
+ 'DEF_NAMESPACE',
+ 'ROUTE_IPO_NAMESPACE',
+ 'PROTO_NAMESPACE',
+ 'x3dNode')
+
+ def __init__(self, parent, node_type, lineno):
+ self.id = None
+ self.node_type = node_type
+ self.parent = parent
+ self.blendObject = None
+ self.x3dNode = None # for x3d import only
+ if parent:
+ parent.children.append(self)
+
+ self.lineno = lineno
+
+ # This is only set from the root nodes.
+ # Having a filename also denotes a root node
+ self.filename = None
+ self.proto_node = None # proto field definition eg: "field SFColor seatColor .6 .6 .1"
+
+ # Store in the root node because each inline file needs its own root node and its own namespace
+ self.DEF_NAMESPACE = None
+ self.ROUTE_IPO_NAMESPACE = None
+ '''
+ self.FIELD_NAMESPACE = None
+ '''
+
+ self.PROTO_NAMESPACE = None
+
+ self.reference = None
+
+ if node_type == NODE_REFERENCE:
+ # For references, only the parent and ID are needed
+ # the reference its self is assigned on parsing
+ return
+
+ self.fields = [] # fields have no order, in some cases rool level values are not unique so dont use a dict
+
+ self.proto_field_defs = [] # proto field definition eg: "field SFColor seatColor .6 .6 .1"
+ self.proto_fields = [] # proto field usage "diffuseColor IS seatColor"
+ self.children = []
+ self.array_data = [] # use for arrays of data - should only be for NODE_ARRAY types
+
+ # Only available from the root node
+ '''
+ def getFieldDict(self):
+ if self.FIELD_NAMESPACE != None:
+ return self.FIELD_NAMESPACE
+ else:
+ return self.parent.getFieldDict()
+ '''
+ def getProtoDict(self):
+ if self.PROTO_NAMESPACE != None:
+ return self.PROTO_NAMESPACE
+ else:
+ return self.parent.getProtoDict()
+
+ def getDefDict(self):
+ if self.DEF_NAMESPACE != None:
+ return self.DEF_NAMESPACE
+ else:
+ return self.parent.getDefDict()
+
+ def getRouteIpoDict(self):
+ if self.ROUTE_IPO_NAMESPACE != None:
+ return self.ROUTE_IPO_NAMESPACE
+ else:
+ return self.parent.getRouteIpoDict()
+
+ def setRoot(self, filename):
+ self.filename = filename
+ # self.FIELD_NAMESPACE = {}
+ self.DEF_NAMESPACE = {}
+ self.ROUTE_IPO_NAMESPACE = {}
+ self.PROTO_NAMESPACE = {}
+
+ def isRoot(self):
+ if self.filename == None:
+ return False
+ else:
+ return True
+
+ def getFilename(self):
+ if self.filename:
+ return self.filename
+ elif self.parent:
+ return self.parent.getFilename()
+ else:
+ return None
+
+ def getRealNode(self):
+ if self.reference:
+ return self.reference
+ else:
+ return self
+
+ def getSpec(self):
+ self_real = self.getRealNode()
+ try:
+ return self_real.id[-1] # its possible this node has no spec
+ except:
+ return None
+
+ def findSpecRecursive(self, spec):
+ self_real = self.getRealNode()
+ if spec == self_real.getSpec():
+ return self
+
+ for child in self_real.children:
+ if child.findSpecRecursive(spec):
+ return child
+
+ return None
+
+ def getPrefix(self):
+ if self.id:
+ return self.id[0]
+ return None
+
+ def getSpecialTypeName(self, typename):
+ self_real = self.getRealNode()
+ try:
+ return self_real.id[list(self_real.id).index(typename) + 1]
+ except:
+ return None
+
+ def getDefName(self):
+ return self.getSpecialTypeName('DEF')
+
+ def getProtoName(self):
+ return self.getSpecialTypeName('PROTO')
+
+ def getExternprotoName(self):
+ return self.getSpecialTypeName('EXTERNPROTO')
+
+ def getChildrenBySpec(self, node_spec): # spec could be Transform, Shape, Appearance
+ self_real = self.getRealNode()
+ # using getSpec functions allows us to use the spec of USE children that dont have their spec in their ID
+ if type(node_spec) == str:
+ return [child for child in self_real.children if child.getSpec() == node_spec]
+ else:
+ # Check inside a list of optional types
+ return [child for child in self_real.children if child.getSpec() in node_spec]
+
+ def getChildBySpec(self, node_spec): # spec could be Transform, Shape, Appearance
+ # Use in cases where there is only ever 1 child of this type
+ ls = self.getChildrenBySpec(node_spec)
+ if ls:
+ return ls[0]
+ else:
+ return None
+
+ def getChildrenByName(self, node_name): # type could be geometry, children, appearance
+ self_real = self.getRealNode()
+ return [child for child in self_real.children if child.id if child.id[0] == node_name]
+
+ def getChildByName(self, node_name):
+ self_real = self.getRealNode()
+ for child in self_real.children:
+ if child.id and child.id[0] == node_name: # and child.id[-1]==node_spec:
+ return child
+
+ def getSerialized(self, results, ancestry):
+ ''' Return this node and all its children in a flat list '''
+ ancestry = ancestry[:] # always use a copy
+
+ # self_real = self.getRealNode()
+
+ results.append((self, tuple(ancestry)))
+ ancestry.append(self)
+ for child in self.getRealNode().children:
+ if child not in ancestry:
+ # We dont want to load proto's, they are only references
+ # We could enforce this elsewhere
+
+ # Only add this in a very special case
+ # where the parent of this object is not the real parent
+ # - In this case we have added the proto as a child to a node instancing it.
+ # This is a bit arbitary, but its how Proto's are done with this importer.
+ if child.getProtoName() == None and child.getExternprotoName() == None:
+ child.getSerialized(results, ancestry)
+ else:
+
+ if DEBUG:
+ print('getSerialized() is proto:', child.getProtoName(), child.getExternprotoName(), self.getSpec())
+
+ self_spec = self.getSpec()
+
+ if child.getProtoName() == self_spec or child.getExternprotoName() == self_spec:
+ #if DEBUG:
+ # "FoundProto!"
+ child.getSerialized(results, ancestry)
+
+ return results
+
+ def searchNodeTypeID(self, node_spec, results):
+ self_real = self.getRealNode()
+ # print(self.lineno, self.id)
+ if self_real.id and self_real.id[-1] == node_spec: # use last element, could also be only element
+ results.append(self_real)
+ for child in self_real.children:
+ child.searchNodeTypeID(node_spec, results)
+ return results
+
+ def getFieldName(self, field, ancestry, AS_CHILD=False):
+ self_real = self.getRealNode() # incase we're an instance
+
+ for f in self_real.fields:
+ # print(f)
+ if f and f[0] == field:
+ # print('\tfound field', f)
+
+ if len(f) >= 3 and f[1] == 'IS': # eg: 'diffuseColor IS legColor'
+ field_id = f[2]
+
+ # print("\n\n\n\n\n\nFOND IS!!!")
+ f_proto_lookup = None
+ f_proto_child_lookup = None
+ i = len(ancestry)
+ while i:
+ i -= 1
+ node = ancestry[i]
+ node = node.getRealNode()
+
+ # proto settings are stored in "self.proto_node"
+ if node.proto_node:
+ # Get the default value from the proto, this can be overwridden by the proto instace
+ # 'field SFColor legColor .8 .4 .7'
+ if AS_CHILD:
+ for child in node.proto_node.children:
+ #if child.id and len(child.id) >= 3 and child.id[2]==field_id:
+ if child.id and ('point' in child.id or 'points' in child.id):
+ f_proto_child_lookup = child
+
+ else:
+ for f_def in node.proto_node.proto_field_defs:
+ if len(f_def) >= 4:
+ if f_def[0] == 'field' and f_def[2] == field_id:
+ f_proto_lookup = f_def[3:]
+
+ # Node instance, Will be 1 up from the proto-node in the ancestry list. but NOT its parent.
+ # This is the setting as defined by the instance, including this setting is optional,
+ # and will override the default PROTO value
+ # eg: 'legColor 1 0 0'
+ if AS_CHILD:
+ for child in node.children:
+ if child.id and child.id[0] == field_id:
+ f_proto_child_lookup = child
+ else:
+ for f_def in node.fields:
+ if len(f_def) >= 2:
+ if f_def[0] == field_id:
+ if DEBUG:
+ print("getFieldName(), found proto", f_def)
+ f_proto_lookup = f_def[1:]
+
+ if AS_CHILD:
+ if f_proto_child_lookup:
+ if DEBUG:
+ print("getFieldName() - AS_CHILD=True, child found")
+ print(f_proto_child_lookup)
+ return f_proto_child_lookup
+ else:
+ return f_proto_lookup
+ else:
+ if AS_CHILD:
+ return None
+ else:
+ # Not using a proto
+ return f[1:]
+ # print('\tfield not found', field)
+
+ # See if this is a proto name
+ if AS_CHILD:
+ child_array = None
+ for child in self_real.children:
+ if child.id and len(child.id) == 1 and child.id[0] == field:
+ return child
+
+ return None
+
+ def getFieldAsInt(self, field, default, ancestry):
+ self_real = self.getRealNode() # incase we're an instance
+
+ f = self_real.getFieldName(field, ancestry)
+ if f == None:
+ return default
+ if ',' in f:
+ f = f[:f.index(',')] # strip after the comma
+
+ if len(f) != 1:
+ print('\t"%s" wrong length for int conversion for field "%s"' % (f, field))
+ return default
+
+ try:
+ return int(f[0])
+ except:
+ print('\tvalue "%s" could not be used as an int for field "%s"' % (f[0], field))
+ return default
+
+ def getFieldAsFloat(self, field, default, ancestry):
+ self_real = self.getRealNode() # incase we're an instance
+
+ f = self_real.getFieldName(field, ancestry)
+ if f == None:
+ return default
+ if ',' in f:
+ f = f[:f.index(',')] # strip after the comma
+
+ if len(f) != 1:
+ print('\t"%s" wrong length for float conversion for field "%s"' % (f, field))
+ return default
+
+ try:
+ return float(f[0])
+ except:
+ print('\tvalue "%s" could not be used as a float for field "%s"' % (f[0], field))
+ return default
+
+ def getFieldAsFloatTuple(self, field, default, ancestry):
+ self_real = self.getRealNode() # incase we're an instance
+
+ f = self_real.getFieldName(field, ancestry)
+ if f == None:
+ return default
+ # if ',' in f: f = f[:f.index(',')] # strip after the comma
+
+ if len(f) < 1:
+ print('"%s" wrong length for float tuple conversion for field "%s"' % (f, field))
+ return default
+
+ ret = []
+ for v in f:
+ if v != ',':
+ try:
+ ret.append(float(v))
+ except:
+ break # quit of first non float, perhaps its a new field name on the same line? - if so we are going to ignore it :/ TODO
+ # print(ret)
+
+ if ret:
+ return ret
+ if not ret:
+ print('\tvalue "%s" could not be used as a float tuple for field "%s"' % (f, field))
+ return default
+
+ def getFieldAsBool(self, field, default, ancestry):
+ self_real = self.getRealNode() # incase we're an instance
+
+ f = self_real.getFieldName(field, ancestry)
+ if f == None:
+ return default
+ if ',' in f:
+ f = f[:f.index(',')] # strip after the comma
+
+ if len(f) != 1:
+ print('\t"%s" wrong length for bool conversion for field "%s"' % (f, field))
+ return default
+
+ if f[0].upper() == '"TRUE"' or f[0].upper() == 'TRUE':
+ return True
+ elif f[0].upper() == '"FALSE"' or f[0].upper() == 'FALSE':
+ return False
+ else:
+ print('\t"%s" could not be used as a bool for field "%s"' % (f[1], field))
+ return default
+
+ def getFieldAsString(self, field, default, ancestry):
+ self_real = self.getRealNode() # incase we're an instance
+
+ f = self_real.getFieldName(field, ancestry)
+ if f == None:
+ return default
+ if len(f) < 1:
+ print('\t"%s" wrong length for string conversion for field "%s"' % (f, field))
+ return default
+
+ if len(f) > 1:
+ # String may contain spaces
+ st = ' '.join(f)
+ else:
+ st = f[0]
+
+ # X3D HACK
+ if self.x3dNode:
+ return st
+
+ if st[0] == '"' and st[-1] == '"':
+ return st[1:-1]
+ else:
+ print('\tvalue "%s" could not be used as a string for field "%s"' % (f[0], field))
+ return default
+
+ def getFieldAsArray(self, field, group, ancestry):
+ '''
+ For this parser arrays are children
+ '''
+
+ def array_as_number(array_string):
+ array_data = []
+ try:
+ array_data = [int(val) for val in array_string]
+ except:
+ try:
+ array_data = [float(val) for val in array_string]
+ except:
+ print('\tWarning, could not parse array data from field')
+
+ return array_data
+
+ self_real = self.getRealNode() # incase we're an instance
+
+ child_array = self_real.getFieldName(field, ancestry, True)
+
+ #if type(child_array)==list: # happens occasionaly
+ # array_data = child_array
+
+ if child_array is None:
+ # For x3d, should work ok with vrml too
+ # for x3d arrays are fields, vrml they are nodes, annoying but not tooo bad.
+ data_split = self.getFieldName(field, ancestry)
+ if not data_split:
+ return []
+ array_data = ' '.join(data_split)
+ if array_data == None:
+ return []
+
+ array_data = array_data.replace(',', ' ')
+ data_split = array_data.split()
+
+ array_data = array_as_number(data_split)
+
+ elif type(child_array) == list:
+ # x3d creates these
+ data_split = [w.strip(",") for w in child_array]
+
+ array_data = array_as_number(data_split)
+ else:
+ # print(child_array)
+ # Normal vrml
+ array_data = child_array.array_data
+
+ # print('array_data', array_data)
+ if group == -1 or len(array_data) == 0:
+ return array_data
+
+ # We want a flat list
+ flat = True
+ for item in array_data:
+ if type(item) == list:
+ flat = False
+ break
+
+ # make a flat array
+ if flat:
+ flat_array = array_data # we are alredy flat.
+ else:
+ flat_array = []
+
+ def extend_flat(ls):
+ for item in ls:
+ if type(item) == list:
+ extend_flat(item)
+ else:
+ flat_array.append(item)
+
+ extend_flat(array_data)
+
+ # We requested a flat array
+ if group == 0:
+ return flat_array
+
+ new_array = []
+ sub_array = []
+
+ for item in flat_array:
+ sub_array.append(item)
+ if len(sub_array) == group:
+ new_array.append(sub_array)
+ sub_array = []
+
+ if sub_array:
+ print('\twarning, array was not aligned to requested grouping', group, 'remaining value', sub_array)
+
+ return new_array
+
+ def getFieldAsStringArray(self, field, ancestry):
+ '''
+ Get a list of strings
+ '''
+ self_real = self.getRealNode() # incase we're an instance
+
+ child_array = None
+ for child in self_real.children:
+ if child.id and len(child.id) == 1 and child.id[0] == field:
+ child_array = child
+ break
+ if not child_array:
+ return []
+
+ # each string gets its own list, remove ""'s
+ try:
+ new_array = [f[0][1:-1] for f in child_array.fields]
+ except:
+ print('\twarning, string array could not be made')
+ new_array = []
+
+ return new_array
+
+ def getLevel(self):
+ # Ignore self_real
+ level = 0
+ p = self.parent
+ while p:
+ level += 1
+ p = p.parent
+ if not p:
+ break
+
+ return level
+
+ def __repr__(self):
+ level = self.getLevel()
+ ind = ' ' * level
+ if self.node_type == NODE_REFERENCE:
+ brackets = ''
+ elif self.node_type == NODE_NORMAL:
+ brackets = '{}'
+ else:
+ brackets = '[]'
+
+ if brackets:
+ text = ind + brackets[0] + '\n'
+ else:
+ text = ''
+
+ text += ind + 'ID: ' + str(self.id) + ' ' + str(level) + (' lineno %d\n' % self.lineno)
+
+ if self.node_type == NODE_REFERENCE:
+ text += ind + "(reference node)\n"
+ return text
+
+ if self.proto_node:
+ text += ind + 'PROTO NODE...\n'
+ text += str(self.proto_node)
+ text += ind + 'PROTO NODE_DONE\n'
+
+ text += ind + 'FIELDS:' + str(len(self.fields)) + '\n'
+
+ for i, item in enumerate(self.fields):
+ text += ind + 'FIELD:\n'
+ text += ind + str(item) + '\n'
+
+ text += ind + 'PROTO_FIELD_DEFS:' + str(len(self.proto_field_defs)) + '\n'
+
+ for i, item in enumerate(self.proto_field_defs):
+ text += ind + 'PROTO_FIELD:\n'
+ text += ind + str(item) + '\n'
+
+ text += ind + 'ARRAY: ' + str(len(self.array_data)) + ' ' + str(self.array_data) + '\n'
+ #text += ind + 'ARRAY: ' + str(len(self.array_data)) + '[...] \n'
+
+ text += ind + 'CHILDREN: ' + str(len(self.children)) + '\n'
+ for i, child in enumerate(self.children):
+ text += ind + ('CHILD%d:\n' % i)
+ text += str(child)
+
+ text += '\n' + ind + brackets[1]
+
+ return text
+
+ def parse(self, i, IS_PROTO_DATA=False):
+ new_i = self.__parse(i, IS_PROTO_DATA)
+
+ # print(self.id, self.getFilename())
+
+ # Check if this node was an inline or externproto
+
+ url_ls = []
+
+ if self.node_type == NODE_NORMAL and self.getSpec() == 'Inline':
+ ancestry = [] # Warning! - PROTO's using this wont work at all.
+ url = self.getFieldAsString('url', None, ancestry)
+ if url:
+ url_ls = [(url, None)]
+ del ancestry
+
+ elif self.getExternprotoName():
+ # externproto
+ url_ls = []
+ for f in self.fields:
+
+ if type(f) == str:
+ f = [f]
+
+ for ff in f:
+ for f_split in ff.split('"'):
+ # print(f_split)
+ # "someextern.vrml#SomeID"
+ if '#' in f_split:
+
+ f_split, f_split_id = f_split.split('#') # there should only be 1 # anyway
+
+ url_ls.append((f_split, f_split_id))
+ else:
+ url_ls.append((f_split, None))
+
+ # Was either an Inline or an EXTERNPROTO
+ if url_ls:
+
+ # print(url_ls)
+
+ for url, extern_key in url_ls:
+ print(url)
+ urls = []
+ urls.append(url)
+ urls.append(bpy.path.resolve_ncase(urls[-1]))
+
+ urls.append(dirName(self.getFilename()) + url)
+ urls.append(bpy.path.resolve_ncase(urls[-1]))
+
+ urls.append(dirName(self.getFilename()) + baseName(url))
+ urls.append(bpy.path.resolve_ncase(urls[-1]))
+
+ try:
+ url = [url for url in urls if exists(url)][0]
+ url_found = True
+ except:
+ url_found = False
+
+ if not url_found:
+ print('\tWarning: Inline URL could not be found:', url)
+ else:
+ if url == self.getFilename():
+ print('\tWarning: cant Inline yourself recursively:', url)
+ else:
+
+ try:
+ data = gzipOpen(url)
+ except:
+ print('\tWarning: cant open the file:', url)
+ data = None
+
+ if data:
+ # Tricky - inline another VRML
+ print('\tLoading Inline:"%s"...' % url)
+
+ # Watch it! - backup lines
+ lines_old = lines[:]
+
+ lines[:] = vrmlFormat(data)
+
+ lines.insert(0, '{')
+ lines.insert(0, 'root_node____')
+ lines.append('}')
+ '''
+ ff = open('/tmp/test.txt', 'w')
+ ff.writelines([l+'\n' for l in lines])
+ '''
+
+ child = vrmlNode(self, NODE_NORMAL, -1)
+ child.setRoot(url) # initialized dicts
+ child.parse(0)
+
+ # if self.getExternprotoName():
+ if self.getExternprotoName():
+ if not extern_key: # if none is spesified - use the name
+ extern_key = self.getSpec()
+
+ if extern_key:
+
+ self.children.remove(child)
+ child.parent = None
+
+ extern_child = child.findSpecRecursive(extern_key)
+
+ if extern_child:
+ self.children.append(extern_child)
+ extern_child.parent = self
+
+ if DEBUG:
+ print("\tEXTERNPROTO ID found!:", extern_key)
+ else:
+ print("\tEXTERNPROTO ID not found!:", extern_key)
+
+ # Watch it! - restore lines
+ lines[:] = lines_old
+
+ return new_i
+
+ def __parse(self, i, IS_PROTO_DATA=False):
+ '''
+ print('parsing at', i, end="")
+ print(i, self.id, self.lineno)
+ '''
+ l = lines[i]
+
+ if l == '[':
+ # An anonymous list
+ self.id = None
+ i += 1
+ else:
+ words = []
+
+ node_type, new_i = is_nodeline(i, words)
+ if not node_type: # fail for parsing new node.
+ print("Failed to parse new node")
+ raise ValueError
+
+ if self.node_type == NODE_REFERENCE:
+ # Only assign the reference and quit
+ key = words[words.index('USE') + 1]
+ self.id = (words[0],)
+
+ self.reference = self.getDefDict()[key]
+ return new_i
+
+ self.id = tuple(words)
+
+ # fill in DEF/USE
+ key = self.getDefName()
+ if key != None:
+ self.getDefDict()[key] = self
+
+ key = self.getProtoName()
+ if not key:
+ key = self.getExternprotoName()
+
+ proto_dict = self.getProtoDict()
+ if key != None:
+ proto_dict[key] = self
+
+ # Parse the proto nodes fields
+ self.proto_node = vrmlNode(self, NODE_ARRAY, new_i)
+ new_i = self.proto_node.parse(new_i)
+
+ self.children.remove(self.proto_node)
+
+ # print(self.proto_node)
+
+ new_i += 1 # skip past the {
+
+ else: # If we're a proto instance, add the proto node as our child.
+ spec = self.getSpec()
+ try:
+ self.children.append(proto_dict[spec])
+ #pass
+ except:
+ pass
+
+ del spec
+
+ del proto_dict, key
+
+ i = new_i
+
+ # print(self.id)
+ ok = True
+ while ok:
+ if i >= len(lines):
+ return len(lines) - 1
+
+ l = lines[i]
+ # print('\tDEBUG:', i, self.node_type, l)
+ if l == '':
+ i += 1
+ continue
+
+ if l == '}':
+ if self.node_type != NODE_NORMAL: # also ends proto nodes, we may want a type for these too.
+ print('wrong node ending, expected an } ' + str(i) + ' ' + str(self.node_type))
+ if DEBUG:
+ raise ValueError
+ ### print("returning", i)
+ return i + 1
+ if l == ']':
+ if self.node_type != NODE_ARRAY:
+ print('wrong node ending, expected a ] ' + str(i) + ' ' + str(self.node_type))
+ if DEBUG:
+ raise ValueError
+ ### print("returning", i)
+ return i + 1
+
+ node_type, new_i = is_nodeline(i, [])
+ if node_type: # check text\n{
+ child = vrmlNode(self, node_type, i)
+ i = child.parse(i)
+
+ elif l == '[': # some files have these anonymous lists
+ child = vrmlNode(self, NODE_ARRAY, i)
+ i = child.parse(i)
+
+ elif is_numline(i):
+ l_split = l.split(',')
+
+ values = None
+ # See if each item is a float?
+
+ for num_type in (int, float):
+ try:
+ values = [num_type(v) for v in l_split]
+ break
+ except:
+ pass
+
+ try:
+ values = [[num_type(v) for v in segment.split()] for segment in l_split]
+ break
+ except:
+ pass
+
+ if values == None: # dont parse
+ values = l_split
+
+ # This should not extend over multiple lines however it is possible
+ # print(self.array_data)
+ if values:
+ self.array_data.extend(values)
+ i += 1
+ else:
+ words = l.split()
+ if len(words) > 2 and words[1] == 'USE':
+ vrmlNode(self, NODE_REFERENCE, i)
+ else:
+
+ # print("FIELD", i, l)
+ #
+ #words = l.split()
+ ### print('\t\ttag', i)
+ # this is a tag/
+ # print(words, i, l)
+ value = l
+ # print(i)
+ # javastrips can exist as values.
+ quote_count = l.count('"')
+ if quote_count % 2: # odd number?
+ # print('MULTILINE')
+ while 1:
+ i += 1
+ l = lines[i]
+ quote_count = l.count('"')
+ if quote_count % 2: # odd number?
+ value += '\n' + l[:l.rfind('"')]
+ break # assume
+ else:
+ value += '\n' + l
+
+ value_all = value.split()
+
+ def iskey(k):
+ if k[0] != '"' and k[0].isalpha() and k.upper() not in ('TRUE', 'FALSE'):
+ return True
+ return False
+
+ def split_fields(value):
+ '''
+ key 0.0 otherkey 1,2,3 opt1 opt1 0.0
+ -> [key 0.0], [otherkey 1,2,3], [opt1 opt1 0.0]
+ '''
+ field_list = []
+ field_context = []
+
+ for j in range(len(value)):
+ if iskey(value[j]):
+ if field_context:
+ # this IS a key but the previous value was not a key, ot it was a defined field.
+ if (not iskey(field_context[-1])) or ((len(field_context) == 3 and field_context[1] == 'IS')):
+ field_list.append(field_context)
+
+ field_context = [value[j]]
+ else:
+ # The last item was not a value, multiple keys are needed in some cases.
+ field_context.append(value[j])
+ else:
+ # Is empty, just add this on
+ field_context.append(value[j])
+ else:
+ # Add a value to the list
+ field_context.append(value[j])
+
+ if field_context:
+ field_list.append(field_context)
+
+ return field_list
+
+ for value in split_fields(value_all):
+ # Split
+
+ if value[0] == 'field':
+ # field SFFloat creaseAngle 4
+ self.proto_field_defs.append(value)
+ else:
+ self.fields.append(value)
+ i += 1
+
+
+def gzipOpen(path):
+ try:
+ import gzip
+ except:
+ gzip = None
+
+ data = None
+ if gzip:
+ try:
+ data = gzip.open(path, 'r').read()
+ except:
+ pass
+ else:
+ print('\tNote, gzip module could not be imported, compressed files will fail to load')
+
+ if data == None:
+ try:
+ data = open(path, 'rU').read()
+ except:
+ pass
+
+ return data
+
+
+def vrml_parse(path):
+ '''
+ Sets up the root node and returns it so load_web3d() can deal with the blender side of things.
+ Return root (vrmlNode, '') or (None, 'Error String')
+ '''
+ data = gzipOpen(path)
+
+ if data == None:
+ return None, 'Failed to open file: ' + path
+
+ # Stripped above
+ lines[:] = vrmlFormat(data)
+
+ lines.insert(0, '{')
+ lines.insert(0, 'dymmy_node')
+ lines.append('}')
+ # Use for testing our parsed output, so we can check on line numbers.
+
+ '''
+ ff = open('/tmp/test.txt', 'w')
+ ff.writelines([l+'\n' for l in lines])
+ ff.close()
+ '''
+
+ # Now evaluate it
+ node_type, new_i = is_nodeline(0, [])
+ if not node_type:
+ return None, 'Error: VRML file has no starting Node'
+
+ # Trick to make sure we get all root nodes.
+ lines.insert(0, '{')
+ lines.insert(0, 'root_node____') # important the name starts with an ascii char
+ lines.append('}')
+
+ root = vrmlNode(None, NODE_NORMAL, -1)
+ root.setRoot(path) # we need to set the root so we have a namespace and know the path incase of inlineing
+
+ # Parse recursively
+ root.parse(0)
+
+ # This prints a load of text
+ if DEBUG:
+ print(root)
+
+ return root, ''
+
+
+# ====================== END VRML
+
+# ====================== X3d Support
+
+# Sane as vrml but replace the parser
+class x3dNode(vrmlNode):
+ def __init__(self, parent, node_type, x3dNode):
+ vrmlNode.__init__(self, parent, node_type, -1)
+ self.x3dNode = x3dNode
+
+ def parse(self, IS_PROTO_DATA=False):
+ # print(self.x3dNode.tagName)
+
+ define = self.x3dNode.getAttributeNode('DEF')
+ if define:
+ self.getDefDict()[define.value] = self
+ else:
+ use = self.x3dNode.getAttributeNode('USE')
+ if use:
+ try:
+ self.reference = self.getDefDict()[use.value]
+ self.node_type = NODE_REFERENCE
+ except:
+ print('\tWarning: reference', use.value, 'not found')
+ self.parent.children.remove(self)
+
+ return
+
+ for x3dChildNode in self.x3dNode.childNodes:
+ if x3dChildNode.nodeType in (x3dChildNode.TEXT_NODE, x3dChildNode.COMMENT_NODE, x3dChildNode.CDATA_SECTION_NODE):
+ continue
+
+ node_type = NODE_NORMAL
+ # print(x3dChildNode, dir(x3dChildNode))
+ if x3dChildNode.getAttributeNode('USE'):
+ node_type = NODE_REFERENCE
+
+ child = x3dNode(self, node_type, x3dChildNode)
+ child.parse()
+
+ # TODO - x3d Inline
+
+ def getSpec(self):
+ return self.x3dNode.tagName # should match vrml spec
+
+ def getDefName(self):
+ data = self.x3dNode.getAttributeNode('DEF')
+ if data:
+ data.value # XXX, return??
+ return None
+
+ # Other funcs operate from vrml, but this means we can wrap XML fields, still use nice utility funcs
+ # getFieldAsArray getFieldAsBool etc
+ def getFieldName(self, field, ancestry, AS_CHILD=False):
+ # ancestry and AS_CHILD are ignored, only used for VRML now
+
+ self_real = self.getRealNode() # incase we're an instance
+ field_xml = self.x3dNode.getAttributeNode(field)
+ if field_xml:
+ value = field_xml.value
+
+ # We may want to edit. for x3d spesific stuff
+ # Sucks a bit to return the field name in the list but vrml excepts this :/
+ return value.split()
+ else:
+ return None
+
+
+def x3d_parse(path):
+ '''
+ Sets up the root node and returns it so load_web3d() can deal with the blender side of things.
+ Return root (x3dNode, '') or (None, 'Error String')
+ '''
+
+ try:
+ import xml.dom.minidom
+ except:
+ return None, 'Error, import XML parsing module (xml.dom.minidom) failed, install python'
+
+ '''
+ try: doc = xml.dom.minidom.parse(path)
+ except: return None, 'Could not parse this X3D file, XML error'
+ '''
+
+ # Could add a try/except here, but a console error is more useful.
+ data = gzipOpen(path)
+
+ if data == None:
+ return None, 'Failed to open file: ' + path
+
+ doc = xml.dom.minidom.parseString(data)
+
+ try:
+ x3dnode = doc.getElementsByTagName('X3D')[0]
+ except:
+ return None, 'Not a valid x3d document, cannot import'
+
+ root = x3dNode(None, NODE_NORMAL, x3dnode)
+ root.setRoot(path) # so images and Inline's we load have a relative path
+ root.parse()
+
+ return root, ''
+
+## f = open('/_Cylinder.wrl', 'r')
+# f = open('/fe/wrl/Vrml/EGS/TOUCHSN.WRL', 'r')
+# vrml_parse('/fe/wrl/Vrml/EGS/TOUCHSN.WRL')
+#vrml_parse('/fe/wrl/Vrml/EGS/SCRIPT.WRL')
+'''
+import os
+files = os.popen('find /fe/wrl -iname "*.wrl"').readlines()
+files.sort()
+tot = len(files)
+for i, f in enumerate(files):
+ #if i < 801:
+ # continue
+
+ f = f.strip()
+ print(f, i, tot)
+ vrml_parse(f)
+'''
+
+# NO BLENDER CODE ABOVE THIS LINE.
+# -----------------------------------------------------------------------------------
+import bpy
+import image_utils
+# import BPyImage
+# import BPySys
+# reload(BPySys)
+# reload(BPyImage)
+# import Blender
+# from Blender import Texture, Material, Mathutils, Mesh, Types, Window
+from mathutils import Vector, Matrix
+
+RAD_TO_DEG = 57.29578
+
+GLOBALS = {'CIRCLE_DETAIL': 16}
+
+
+def translateRotation(rot):
+ ''' axis, angle '''
+ return Matrix.Rotation(rot[3], 4, Vector(rot[:3]))
+
+
+def translateScale(sca):
+ mat = Matrix() # 4x4 default
+ mat[0][0] = sca[0]
+ mat[1][1] = sca[1]
+ mat[2][2] = sca[2]
+ return mat
+
+
+def translateTransform(node, ancestry):
+ cent = node.getFieldAsFloatTuple('center', None, ancestry) # (0.0, 0.0, 0.0)
+ rot = node.getFieldAsFloatTuple('rotation', None, ancestry) # (0.0, 0.0, 1.0, 0.0)
+ sca = node.getFieldAsFloatTuple('scale', None, ancestry) # (1.0, 1.0, 1.0)
+ scaori = node.getFieldAsFloatTuple('scaleOrientation', None, ancestry) # (0.0, 0.0, 1.0, 0.0)
+ tx = node.getFieldAsFloatTuple('translation', None, ancestry) # (0.0, 0.0, 0.0)
+
+ if cent:
+ cent_mat = Matrix.Translation(Vector(cent)).resize4x4()
+ cent_imat = cent_mat.copy().invert()
+ else:
+ cent_mat = cent_imat = None
+
+ if rot:
+ rot_mat = translateRotation(rot)
+ else:
+ rot_mat = None
+
+ if sca:
+ sca_mat = translateScale(sca)
+ else:
+ sca_mat = None
+
+ if scaori:
+ scaori_mat = translateRotation(scaori)
+ scaori_imat = scaori_mat.copy().invert()
+ else:
+ scaori_mat = scaori_imat = None
+
+ if tx:
+ tx_mat = Matrix.Translation(Vector(tx)).resize4x4()
+ else:
+ tx_mat = None
+
+ new_mat = Matrix()
+
+ mats = [tx_mat, cent_mat, rot_mat, scaori_mat, sca_mat, scaori_imat, cent_imat]
+ for mtx in mats:
+ if mtx:
+ new_mat = new_mat * mtx
+
+ return new_mat
+
+
+def translateTexTransform(node, ancestry):
+ cent = node.getFieldAsFloatTuple('center', None, ancestry) # (0.0, 0.0)
+ rot = node.getFieldAsFloat('rotation', None, ancestry) # 0.0
+ sca = node.getFieldAsFloatTuple('scale', None, ancestry) # (1.0, 1.0)
+ tx = node.getFieldAsFloatTuple('translation', None, ancestry) # (0.0, 0.0)
+
+ if cent:
+ # cent is at a corner by default
+ cent_mat = Matrix.Translation(Vector(cent).resize3D()).resize4x4()
+ cent_imat = cent_mat.copy().invert()
+ else:
+ cent_mat = cent_imat = None
+
+ if rot:
+ rot_mat = Matrix.Rotation(rot, 4, 'Z') # translateRotation(rot)
+ else:
+ rot_mat = None
+
+ if sca:
+ sca_mat = translateScale((sca[0], sca[1], 0.0))
+ else:
+ sca_mat = None
+
+ if tx:
+ tx_mat = Matrix.Translation(Vector(tx).resize3D()).resize4x4()
+ else:
+ tx_mat = None
+
+ new_mat = Matrix()
+
+ # as specified in VRML97 docs
+ mats = [cent_imat, sca_mat, rot_mat, cent_mat, tx_mat]
+
+ for mtx in mats:
+ if mtx:
+ new_mat = new_mat * mtx
+
+ return new_mat
+
+
+# 90d X rotation
+import math
+MATRIX_Z_TO_Y = Matrix.Rotation(math.pi / 2.0, 4, 'X')
+
+
+def getFinalMatrix(node, mtx, ancestry):
+
+ transform_nodes = [node_tx for node_tx in ancestry if node_tx.getSpec() == 'Transform']
+ if node.getSpec() == 'Transform':
+ transform_nodes.append(node)
+ transform_nodes.reverse()
+
+ if mtx is None:
+ mtx = Matrix()
+
+ for node_tx in transform_nodes:
+ mat = translateTransform(node_tx, ancestry)
+ mtx = mat * mtx
+
+ # worldspace matrix
+ mtx = MATRIX_Z_TO_Y * mtx
+
+ return mtx
+
+
+def importMesh_IndexedFaceSet(geom, bpyima, ancestry):
+ # print(geom.lineno, geom.id, vrmlNode.DEF_NAMESPACE.keys())
+
+ ccw = geom.getFieldAsBool('ccw', True, ancestry)
+ ifs_colorPerVertex = geom.getFieldAsBool('colorPerVertex', True, ancestry) # per vertex or per face
+ ifs_normalPerVertex = geom.getFieldAsBool('normalPerVertex', True, ancestry)
+
+ # This is odd how point is inside Coordinate
+
+ # VRML not x3d
+ #coord = geom.getChildByName('coord') # 'Coordinate'
+
+ coord = geom.getChildBySpec('Coordinate') # works for x3d and vrml
+
+ if coord:
+ ifs_points = coord.getFieldAsArray('point', 3, ancestry)
+ else:
+ coord = []
+
+ if not coord:
+ print('\tWarnint: IndexedFaceSet has no points')
+ return None, ccw
+
+ ifs_faces = geom.getFieldAsArray('coordIndex', 0, ancestry)
+
+ coords_tex = None
+ if ifs_faces: # In rare cases this causes problems - no faces but UVs???
+
+ # WORKS - VRML ONLY
+ # coords_tex = geom.getChildByName('texCoord')
+ coords_tex = geom.getChildBySpec('TextureCoordinate')
+
+ if coords_tex:
+ ifs_texpoints = coords_tex.getFieldAsArray('point', 2, ancestry)
+ ifs_texfaces = geom.getFieldAsArray('texCoordIndex', 0, ancestry)
+
+ if not ifs_texpoints:
+ # IF we have no coords, then dont bother
+ coords_tex = None
+
+ # WORKS - VRML ONLY
+ # vcolor = geom.getChildByName('color')
+ vcolor = geom.getChildBySpec('Color')
+ vcolor_spot = None # spot color when we dont have an array of colors
+ if vcolor:
+ # float to char
+ ifs_vcol = [(0, 0, 0)] # EEKADOODLE - vertex start at 1
+ ifs_vcol.extend([col for col in vcolor.getFieldAsArray('color', 3, ancestry)])
+ ifs_color_index = geom.getFieldAsArray('colorIndex', 0, ancestry)
+
+ if not ifs_vcol:
+ vcolor_spot = vcolor.getFieldAsFloatTuple('color', [], ancestry)
+
+ # Convert faces into somthing blender can use
+ edges = []
+
+ # All lists are aligned!
+ faces = []
+ faces_uv = [] # if ifs_texfaces is empty then the faces_uv will match faces exactly.
+ faces_orig_index = [] # for ngons, we need to know our original index
+
+ if coords_tex and ifs_texfaces:
+ do_uvmap = True
+ else:
+ do_uvmap = False
+
+ # current_face = [0] # pointer anyone
+
+ def add_face(face, fuvs, orig_index):
+ l = len(face)
+ if l == 3 or l == 4:
+ faces.append(face)
+ # faces_orig_index.append(current_face[0])
+ if do_uvmap:
+ faces_uv.append(fuvs)
+
+ faces_orig_index.append(orig_index)
+ elif l == 2:
+ edges.append(face)
+ elif l > 4:
+ for i in range(2, len(face)):
+ faces.append([face[0], face[i - 1], face[i]])
+ if do_uvmap:
+ faces_uv.append([fuvs[0], fuvs[i - 1], fuvs[i]])
+ faces_orig_index.append(orig_index)
+ else:
+ # faces with 1 verts? pfft!
+ # still will affect index ordering
+ pass
+
+ face = []
+ fuvs = []
+ orig_index = 0
+ for i, fi in enumerate(ifs_faces):
+ # ifs_texfaces and ifs_faces should be aligned
+ if fi != -1:
+ # face.append(int(fi)) # in rare cases this is a float
+ # EEKADOODLE!!!
+ # Annoyance where faces that have a zero index vert get rotated. This will then mess up UVs and VColors
+ face.append(int(fi) + 1) # in rare cases this is a float, +1 because of stupid EEKADOODLE :/
+
+ if do_uvmap:
+ if i >= len(ifs_texfaces):
+ print('\tWarning: UV Texface index out of range')
+ fuvs.append(ifs_texfaces[0])
+ else:
+ fuvs.append(ifs_texfaces[i])
+ else:
+ add_face(face, fuvs, orig_index)
+ face = []
+ if do_uvmap:
+ fuvs = []
+ orig_index += 1
+
+ add_face(face, fuvs, orig_index)
+ del add_face # dont need this func anymore
+
+ bpymesh = bpy.data.meshes.new(name="XXX")
+
+ # EEKADOODLE
+ bpymesh.vertices.add(1 + (len(ifs_points)))
+ bpymesh.vertices.foreach_set("co", [0, 0, 0] + [a for v in ifs_points for a in v]) # XXX25 speed
+
+ # print(len(ifs_points), faces, edges, ngons)
+
+ try:
+ bpymesh.faces.add(len(faces))
+ bpymesh.faces.foreach_set("vertices_raw", [a for f in faces for a in (f + [0] if len(f) == 3 else f)]) # XXX25 speed
+ except KeyError:
+ print("one or more vert indicies out of range. corrupt file?")
+ #for f in faces:
+ # bpymesh.faces.extend(faces, smooth=True)
+
+ # bpymesh.calcNormals()
+ bpymesh.update()
+
+ if len(bpymesh.faces) != len(faces):
+ print('\tWarning: adding faces did not work! file is invalid, not adding UVs or vcolors')
+ return bpymesh, ccw
+
+ # Apply UVs if we have them
+ if not do_uvmap:
+ faces_uv = faces # fallback, we didnt need a uvmap in the first place, fallback to the face/vert mapping.
+ if coords_tex:
+ #print(ifs_texpoints)
+ # print(geom)
+ uvlay = bpymesh.uv_textures.new()
+
+ for i, f in enumerate(uvlay.data):
+ f.image = bpyima
+ fuv = faces_uv[i] # uv indicies
+ for j, uv in enumerate(f.uv):
+ # print(fuv, j, len(ifs_texpoints))
+ try:
+ f.uv[j] = ifs_texpoints[fuv[j]] # XXX25, speedup
+ except:
+ print('\tWarning: UV Index out of range')
+ f.uv[j] = ifs_texpoints[0] # XXX25, speedup
+
+ elif bpyima and len(bpymesh.faces):
+ # Oh Bugger! - we cant really use blenders ORCO for for texture space since texspace dosnt rotate.
+ # we have to create VRML's coords as UVs instead.
+
+ # VRML docs
+ '''
+ If the texCoord field is NULL, a default texture coordinate mapping is calculated using the local
+ coordinate system bounding box of the shape. The longest dimension of the bounding box defines the S coordinates,
+ and the next longest defines the T coordinates. If two or all three dimensions of the bounding box are equal,
+ ties shall be broken by choosing the X, Y, or Z dimension in that order of preference.
+ The value of the S coordinate ranges from 0 to 1, from one end of the bounding box to the other.
+ The T coordinate ranges between 0 and the ratio of the second greatest dimension of the bounding box to the greatest dimension.
+ '''
+
+ # Note, S,T == U,V
+ # U gets longest, V gets second longest
+ xmin, ymin, zmin = ifs_points[0]
+ xmax, ymax, zmax = ifs_points[0]
+ for co in ifs_points:
+ x, y, z = co
+ if x < xmin:
+ xmin = x
+ if y < ymin:
+ ymin = y
+ if z < zmin:
+ zmin = z
+
+ if x > xmax:
+ xmax = x
+ if y > ymax:
+ ymax = y
+ if z > zmax:
+ zmax = z
+
+ xlen = xmax - xmin
+ ylen = ymax - ymin
+ zlen = zmax - zmin
+
+ depth_min = xmin, ymin, zmin
+ depth_list = [xlen, ylen, zlen]
+ depth_sort = depth_list[:]
+ depth_sort.sort()
+
+ depth_idx = [depth_list.index(val) for val in depth_sort]
+
+ axis_u = depth_idx[-1]
+ axis_v = depth_idx[-2] # second longest
+
+ # Hack, swap these !!! TODO - Why swap??? - it seems to work correctly but should not.
+ # axis_u,axis_v = axis_v,axis_u
+
+ min_u = depth_min[axis_u]
+ min_v = depth_min[axis_v]
+ depth_u = depth_list[axis_u]
+ depth_v = depth_list[axis_v]
+
+ depth_list[axis_u]
+
+ if axis_u == axis_v:
+ # This should be safe because when 2 axies have the same length, the lower index will be used.
+ axis_v += 1
+
+ uvlay = bpymesh.uv_textures.new()
+
+ # HACK !!! - seems to be compatible with Cosmo though.
+ depth_v = depth_u = max(depth_v, depth_u)
+
+ bpymesh_vertices = bpymesh.vertices[:]
+ bpymesh_faces = bpymesh.faces[:]
+
+ for j, f in enumerate(uvlay.data):
+ f.image = bpyima
+ fuv = f.uv
+ f_v = bpymesh_faces[j].vertices[:] # XXX25 speed
+
+ for i, v in enumerate(f_v):
+ co = bpymesh_vertices[v].co
+ fuv[i] = (co[axis_u] - min_u) / depth_u, (co[axis_v] - min_v) / depth_v
+
+ # Add vcote
+ if vcolor:
+ # print(ifs_vcol)
+ collay = bpymesh.vertex_colors.new()
+
+ for f_idx, f in enumerate(collay.data):
+ fv = bpymesh.faces[f_idx].vertices[:]
+ if len(fv) == 3: # XXX speed
+ fcol = f.color1, f.color2, f.color3
+ else:
+ fcol = f.color1, f.color2, f.color3, f.color4
+ if ifs_colorPerVertex:
+ for i, c in enumerate(fcol):
+ color_index = fv[i] # color index is vert index
+ if ifs_color_index:
+ try:
+ color_index = ifs_color_index[color_index]
+ except:
+ print('\tWarning: per vertex color index out of range')
+ continue
+
+ if color_index < len(ifs_vcol):
+ c.r, c.g, c.b = ifs_vcol[color_index]
+ else:
+ #print('\tWarning: per face color index out of range')
+ pass
+ else:
+ if vcolor_spot: # use 1 color, when ifs_vcol is []
+ for c in fcol:
+ c.r, c.g, c.b = vcolor_spot
+ else:
+ color_index = faces_orig_index[f_idx] # color index is face index
+ #print(color_index, ifs_color_index)
+ if ifs_color_index:
+ if color_index >= len(ifs_color_index):
+ print('\tWarning: per face color index out of range')
+ color_index = 0
+ else:
+ color_index = ifs_color_index[color_index]
+ try:
+ col = ifs_vcol[color_index]
+ except IndexError:
+ # TODO, look
+ col = (1.0, 1.0, 1.0)
+ for i, c in enumerate(fcol):
+ c.r, c.g, c.b = col
+
+ # XXX25
+ # bpymesh.vertices.delete([0, ]) # EEKADOODLE
+
+ return bpymesh, ccw
+
+
+def importMesh_IndexedLineSet(geom, ancestry):
+ # VRML not x3d
+ #coord = geom.getChildByName('coord') # 'Coordinate'
+ coord = geom.getChildBySpec('Coordinate') # works for x3d and vrml
+ if coord:
+ points = coord.getFieldAsArray('point', 3, ancestry)
+ else:
+ points = []
+
+ if not points:
+ print('\tWarning: IndexedLineSet had no points')
+ return None
+
+ ils_lines = geom.getFieldAsArray('coordIndex', 0, ancestry)
+
+ lines = []
+ line = []
+
+ for il in ils_lines:
+ if il == -1:
+ lines.append(line)
+ line = []
+ else:
+ line.append(int(il))
+ lines.append(line)
+
+ # vcolor = geom.getChildByName('color') # blender dosnt have per vertex color
+
+ bpycurve = bpy.data.curves.new('IndexedCurve', 'CURVE')
+ bpycurve.dimensions = '3D'
+
+ for line in lines:
+ if not line:
+ continue
+ co = points[line[0]]
+ nu = bpycurve.splines.new('POLY')
+ nu.points.add(len(line))
+
+ for il, pt in zip(line, nu.points):
+ pt.co[0:3] = points[il]
+
+ return bpycurve
+
+
+def importMesh_PointSet(geom, ancestry):
+ # VRML not x3d
+ #coord = geom.getChildByName('coord') # 'Coordinate'
+ coord = geom.getChildBySpec('Coordinate') # works for x3d and vrml
+ if coord:
+ points = coord.getFieldAsArray('point', 3, ancestry)
+ else:
+ points = []
+
+ # vcolor = geom.getChildByName('color') # blender dosnt have per vertex color
+
+ bpymesh = bpy.data.meshes.new("XXX")
+ bpymesh.vertices.add(len(points))
+ bpymesh.vertices.foreach_set("co", [a for v in points for a in v])
+
+ # bpymesh.calcNormals() # will just be dummy normals
+ bpymesh.update()
+ return bpymesh
+
+GLOBALS['CIRCLE_DETAIL'] = 12
+
+
+def bpy_ops_add_object_hack(): # XXX25, evil
+ scene = bpy.context.scene
+ obj = scene.objects[0]
+ scene.objects.unlink(obj)
+ bpymesh = obj.data
+ bpy.data.objects.remove(obj)
+ return bpymesh
+
+
+def importMesh_Sphere(geom, ancestry):
+ diameter = geom.getFieldAsFloat('radius', 0.5, ancestry)
+ # bpymesh = Mesh.Primitives.UVsphere(GLOBALS['CIRCLE_DETAIL'], GLOBALS['CIRCLE_DETAIL'], diameter)
+
+ bpy.ops.mesh.primitive_uv_sphere_add(segments=GLOBALS['CIRCLE_DETAIL'],
+ ring_count=GLOBALS['CIRCLE_DETAIL'],
+ size=diameter,
+ view_align=False,
+ enter_editmode=False,
+ )
+
+ bpymesh = bpy_ops_add_object_hack()
+
+ bpymesh.transform(MATRIX_Z_TO_Y)
+ return bpymesh
+
+
+def importMesh_Cylinder(geom, ancestry):
+ # bpymesh = bpy.data.meshes.new()
+ diameter = geom.getFieldAsFloat('radius', 1.0, ancestry)
+ height = geom.getFieldAsFloat('height', 2, ancestry)
+
+ # bpymesh = Mesh.Primitives.Cylinder(GLOBALS['CIRCLE_DETAIL'], diameter, height)
+
+ bpy.ops.mesh.primitive_cylinder_add(vertices=GLOBALS['CIRCLE_DETAIL'],
+ radius=diameter,
+ depth=height,
+ cap_ends=True,
+ view_align=False,
+ enter_editmode=False,
+ )
+
+ bpymesh = bpy_ops_add_object_hack()
+
+ bpymesh.transform(MATRIX_Z_TO_Y)
+
+ # Warning - Rely in the order Blender adds verts
+ # not nice design but wont change soon.
+
+ bottom = geom.getFieldAsBool('bottom', True, ancestry)
+ side = geom.getFieldAsBool('side', True, ancestry)
+ top = geom.getFieldAsBool('top', True, ancestry)
+
+ if not top: # last vert is top center of tri fan.
+ # bpymesh.vertices.delete([(GLOBALS['CIRCLE_DETAIL'] + GLOBALS['CIRCLE_DETAIL']) + 1]) # XXX25
+ pass
+
+ if not bottom: # second last vert is bottom of triangle fan
+ # XXX25
+ # bpymesh.vertices.delete([GLOBALS['CIRCLE_DETAIL'] + GLOBALS['CIRCLE_DETAIL']])
+ pass
+
+ if not side:
+ # remove all quads
+ # XXX25
+ # bpymesh.faces.delete(1, [f for f in bpymesh.faces if len(f) == 4])
+ pass
+
+ return bpymesh
+
+
+def importMesh_Cone(geom, ancestry):
+ # bpymesh = bpy.data.meshes.new()
+ diameter = geom.getFieldAsFloat('bottomRadius', 1.0, ancestry)
+ height = geom.getFieldAsFloat('height', 2, ancestry)
+
+ # bpymesh = Mesh.Primitives.Cone(GLOBALS['CIRCLE_DETAIL'], diameter, height)
+
+ bpy.ops.mesh.primitive_cone_add(vertices=GLOBALS['CIRCLE_DETAIL'],
+ radius=diameter,
+ depth=height,
+ cap_end=True,
+ view_align=False,
+ enter_editmode=False,
+ )
+
+ bpymesh = bpy_ops_add_object_hack()
+
+ bpymesh.transform(MATRIX_Z_TO_Y)
+
+ # Warning - Rely in the order Blender adds verts
+ # not nice design but wont change soon.
+
+ bottom = geom.getFieldAsBool('bottom', True, ancestry)
+ side = geom.getFieldAsBool('side', True, ancestry)
+
+ if not bottom: # last vert is on the bottom
+ # bpymesh.vertices.delete([GLOBALS['CIRCLE_DETAIL'] + 1]) # XXX25
+ pass
+ if not side: # second last vert is on the pointy bit of the cone
+ # bpymesh.vertices.delete([GLOBALS['CIRCLE_DETAIL']]) # XXX25
+ pass
+
+ return bpymesh
+
+
+def importMesh_Box(geom, ancestry):
+ # bpymesh = bpy.data.meshes.new()
+
+ size = geom.getFieldAsFloatTuple('size', (2.0, 2.0, 2.0), ancestry)
+
+ # bpymesh = Mesh.Primitives.Cube(1.0)
+ bpy.ops.mesh.primitive_cube_add(view_align=False,
+ enter_editmode=False,
+ )
+
+ bpymesh = bpy_ops_add_object_hack()
+
+ # Scale the box to the size set
+ scale_mat = Matrix(((size[0], 0, 0), (0, size[1], 0), (0, 0, size[2]))) * 0.5
+ bpymesh.transform(scale_mat.resize4x4())
+
+ return bpymesh
+
+
+def importShape(node, ancestry):
+ vrmlname = node.getDefName()
+ if not vrmlname:
+ vrmlname = 'Shape'
+
+ # works 100% in vrml, but not x3d
+ #appr = node.getChildByName('appearance') # , 'Appearance'
+ #geom = node.getChildByName('geometry') # , 'IndexedFaceSet'
+
+ # Works in vrml and x3d
+ appr = node.getChildBySpec('Appearance')
+ geom = node.getChildBySpec(['IndexedFaceSet', 'IndexedLineSet', 'PointSet', 'Sphere', 'Box', 'Cylinder', 'Cone'])
+
+ # For now only import IndexedFaceSet's
+ if geom:
+ bpymat = None
+ bpyima = None
+ texmtx = None
+
+ depth = 0 # so we can set alpha face flag later
+
+ if appr:
+
+ #mat = appr.getChildByName('material') # 'Material'
+ #ima = appr.getChildByName('texture') # , 'ImageTexture'
+ #if ima and ima.getSpec() != 'ImageTexture':
+ # print('\tWarning: texture type "%s" is not supported' % ima.getSpec())
+ # ima = None
+ # textx = appr.getChildByName('textureTransform')
+
+ mat = appr.getChildBySpec('Material')
+ ima = appr.getChildBySpec('ImageTexture')
+
+ textx = appr.getChildBySpec('TextureTransform')
+
+ if textx:
+ texmtx = translateTexTransform(textx, ancestry)
+
+ # print(mat, ima)
+ if mat or ima:
+
+ if not mat:
+ mat = ima # This is a bit dumb, but just means we use default values for all
+
+ # all values between 0.0 and 1.0, defaults from VRML docs
+ bpymat = bpy.data.materials.new("XXX")
+ bpymat.ambient = mat.getFieldAsFloat('ambientIntensity', 0.2, ancestry)
+ bpymat.diffuse_color = mat.getFieldAsFloatTuple('diffuseColor', [0.8, 0.8, 0.8], ancestry)
+
+ # NOTE - blender dosnt support emmisive color
+ # Store in mirror color and approximate with emit.
+ emit = mat.getFieldAsFloatTuple('emissiveColor', [0.0, 0.0, 0.0], ancestry)
+ bpymat.mirror_color = emit
+ bpymat.emit = (emit[0] + emit[1] + emit[2]) / 3.0
+
+ bpymat.specular_hardness = int(1 + (510 * mat.getFieldAsFloat('shininess', 0.2, ancestry))) # 0-1 -> 1-511
+ bpymat.specular_color = mat.getFieldAsFloatTuple('specularColor', [0.0, 0.0, 0.0], ancestry)
+ bpymat.alpha = 1.0 - mat.getFieldAsFloat('transparency', 0.0, ancestry)
+ if bpymat.alpha < 0.999:
+ bpymat.use_transparency = True
+
+ if ima:
+ ima_url = ima.getFieldAsString('url', None, ancestry)
+
+ if ima_url == None:
+ try:
+ ima_url = ima.getFieldAsStringArray('url', ancestry)[0] # in some cases we get a list of images.
+ except:
+ ima_url = None
+
+ if ima_url == None:
+ print("\twarning, image with no URL, this is odd")
+ else:
+ bpyima = image_utils.image_load(ima_url, dirName(node.getFilename()), place_holder=False, recursive=False, convert_callback=imageConvertCompat)
+ if bpyima:
+ texture = bpy.data.textures.new("XXX", 'IMAGE')
+ texture.image = bpyima
+
+ # Adds textures for materials (rendering)
+ try:
+ depth = bpyima.depth
+ except:
+ depth = -1
+
+ if depth == 32:
+ # Image has alpha
+ bpymat.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL | Texture.MapTo.ALPHA)
+ texture.setImageFlags('MipMap', 'InterPol', 'UseAlpha')
+ bpymat.mode |= Material.Modes.ZTRANSP
+ bpymat.alpha = 0.0
+ else:
+ mtex = bpymat.texture_slots.add()
+ mtex.texture = texture
+ mtex.texture_coords = 'UV'
+ mtex.use_map_diffuse = True
+
+ ima_repS = ima.getFieldAsBool('repeatS', True, ancestry)
+ ima_repT = ima.getFieldAsBool('repeatT', True, ancestry)
+
+ # To make this work properly we'd need to scale the UV's too, better to ignore th
+ # texture.repeat = max(1, ima_repS * 512), max(1, ima_repT * 512)
+
+ if not ima_repS:
+ bpyima.use_clamp_x = True
+ if not ima_repT:
+ bpyima.use_clamp_y = True
+
+ bpydata = None
+ geom_spec = geom.getSpec()
+ ccw = True
+ if geom_spec == 'IndexedFaceSet':
+ bpydata, ccw = importMesh_IndexedFaceSet(geom, bpyima, ancestry)
+ elif geom_spec == 'IndexedLineSet':
+ bpydata = importMesh_IndexedLineSet(geom, ancestry)
+ elif geom_spec == 'PointSet':
+ bpydata = importMesh_PointSet(geom, ancestry)
+ elif geom_spec == 'Sphere':
+ bpydata = importMesh_Sphere(geom, ancestry)
+ elif geom_spec == 'Box':
+ bpydata = importMesh_Box(geom, ancestry)
+ elif geom_spec == 'Cylinder':
+ bpydata = importMesh_Cylinder(geom, ancestry)
+ elif geom_spec == 'Cone':
+ bpydata = importMesh_Cone(geom, ancestry)
+ else:
+ print('\tWarning: unsupported type "%s"' % geom_spec)
+ return
+
+ if bpydata:
+ vrmlname = vrmlname + geom_spec
+
+ bpydata.name = vrmlname
+
+ bpyob = node.blendObject = bpy.data.objects.new(vrmlname, bpydata)
+ bpy.context.scene.objects.link(bpyob)
+
+ if type(bpydata) == bpy.types.Mesh:
+ is_solid = geom.getFieldAsBool('solid', True, ancestry)
+ creaseAngle = geom.getFieldAsFloat('creaseAngle', None, ancestry)
+
+ if creaseAngle != None:
+ bpydata.auto_smooth_angle = 1 + int(min(79, creaseAngle * RAD_TO_DEG))
+ bpydata.use_auto_smooth = True
+
+ # Only ever 1 material per shape
+ if bpymat:
+ bpydata.materials.append(bpymat)
+
+ if bpydata.uv_textures:
+
+ if depth == 32: # set the faces alpha flag?
+ transp = Mesh.FaceTranspModes.ALPHA
+ for f in bpydata.uv_textures.active.data:
+ f.blend_type = 'ALPHA'
+
+ if texmtx:
+ # Apply texture transform?
+ uv_copy = Vector()
+ for f in bpydata.uv_textures.active.data:
+ fuv = f.uv
+ for i, uv in enumerate(fuv):
+ uv_copy.x = uv[0]
+ uv_copy.y = uv[1]
+
+ fuv[i] = (uv_copy * texmtx)[0:2]
+ # Done transforming the texture
+
+ # Must be here and not in IndexedFaceSet because it needs an object for the flip func. Messy :/
+ if not ccw:
+ # bpydata.flipNormals()
+ # XXX25
+ pass
+
+ # else could be a curve for example
+
+ # Can transform data or object, better the object so we can instance the data
+ #bpymesh.transform(getFinalMatrix(node))
+ bpyob.matrix_world = getFinalMatrix(node, None, ancestry)
+
+
+def importLamp_PointLight(node, ancestry):
+ vrmlname = node.getDefName()
+ if not vrmlname:
+ vrmlname = 'PointLight'
+
+ # ambientIntensity = node.getFieldAsFloat('ambientIntensity', 0.0, ancestry) # TODO
+ # attenuation = node.getFieldAsFloatTuple('attenuation', (1.0, 0.0, 0.0), ancestry) # TODO
+ color = node.getFieldAsFloatTuple('color', (1.0, 1.0, 1.0), ancestry)
+ intensity = node.getFieldAsFloat('intensity', 1.0, ancestry) # max is documented to be 1.0 but some files have higher.
+ location = node.getFieldAsFloatTuple('location', (0.0, 0.0, 0.0), ancestry)
+ # is_on = node.getFieldAsBool('on', True, ancestry) # TODO
+ radius = node.getFieldAsFloat('radius', 100.0, ancestry)
+
+ bpylamp = bpy.data.lamps.new("ToDo", 'POINT')
+ bpylamp.energy = intensity
+ bpylamp.distance = radius
+ bpylamp.color = color
+
+ mtx = Matrix.Translation(Vector(location))
+
+ return bpylamp, mtx
+
+
+def importLamp_DirectionalLight(node, ancestry):
+ vrmlname = node.getDefName()
+ if not vrmlname:
+ vrmlname = 'DirectLight'
+
+ # ambientIntensity = node.getFieldAsFloat('ambientIntensity', 0.0) # TODO
+ color = node.getFieldAsFloatTuple('color', (1.0, 1.0, 1.0), ancestry)
+ direction = node.getFieldAsFloatTuple('direction', (0.0, 0.0, -1.0), ancestry)
+ intensity = node.getFieldAsFloat('intensity', 1.0, ancestry) # max is documented to be 1.0 but some files have higher.
+ # is_on = node.getFieldAsBool('on', True, ancestry) # TODO
+
+ bpylamp = bpy.data.lamps.new(vrmlname, 'SUN')
+ bpylamp.energy = intensity
+ bpylamp.color = color
+
+ # lamps have their direction as -z, yup
+ mtx = Vector(direction).to_track_quat('-Z', 'Y').to_matrix().resize4x4()
+
+ return bpylamp, mtx
+
+# looks like default values for beamWidth and cutOffAngle were swapped in VRML docs.
+
+
+def importLamp_SpotLight(node, ancestry):
+ vrmlname = node.getDefName()
+ if not vrmlname:
+ vrmlname = 'SpotLight'
+
+ # ambientIntensity = geom.getFieldAsFloat('ambientIntensity', 0.0, ancestry) # TODO
+ # attenuation = geom.getFieldAsFloatTuple('attenuation', (1.0, 0.0, 0.0), ancestry) # TODO
+ beamWidth = node.getFieldAsFloat('beamWidth', 1.570796, ancestry) # max is documented to be 1.0 but some files have higher.
+ color = node.getFieldAsFloatTuple('color', (1.0, 1.0, 1.0), ancestry)
+ cutOffAngle = node.getFieldAsFloat('cutOffAngle', 0.785398, ancestry) * 2.0 # max is documented to be 1.0 but some files have higher.
+ direction = node.getFieldAsFloatTuple('direction', (0.0, 0.0, -1.0), ancestry)
+ intensity = node.getFieldAsFloat('intensity', 1.0, ancestry) # max is documented to be 1.0 but some files have higher.
+ location = node.getFieldAsFloatTuple('location', (0.0, 0.0, 0.0), ancestry)
+ # is_on = node.getFieldAsBool('on', True, ancestry) # TODO
+ radius = node.getFieldAsFloat('radius', 100.0, ancestry)
+
+ bpylamp = bpy.data.lamps.new(vrmlname, 'SPOT')
+ bpylamp.energy = intensity
+ bpylamp.distance = radius
+ bpylamp.color = color
+ bpylamp.spot_size = cutOffAngle
+ if beamWidth > cutOffAngle:
+ bpylamp.spot_blend = 0.0
+ else:
+ if cutOffAngle == 0.0: # this should never happen!
+ bpylamp.spot_blend = 0.5
+ else:
+ bpylamp.spot_blend = beamWidth / cutOffAngle
+
+ # Convert
+
+ # lamps have their direction as -z, y==up
+ mtx = Matrix.Translation(Vector(location)) * Vector(direction).to_track_quat('-Z', 'Y').to_matrix().resize4x4()
+
+ return bpylamp, mtx
+
+
+def importLamp(node, spec, ancestry):
+ if spec == 'PointLight':
+ bpylamp, mtx = importLamp_PointLight(node, ancestry)
+ elif spec == 'DirectionalLight':
+ bpylamp, mtx = importLamp_DirectionalLight(node, ancestry)
+ elif spec == 'SpotLight':
+ bpylamp, mtx = importLamp_SpotLight(node, ancestry)
+ else:
+ print("Error, not a lamp")
+ raise ValueError
+
+ bpyob = node.blendObject = bpy.data.objects.new("TODO", bpylamp)
+ bpy.context.scene.objects.link(bpyob)
+
+ bpyob.matrix_world = getFinalMatrix(node, mtx, ancestry)
+
+
+def importViewpoint(node, ancestry):
+ name = node.getDefName()
+ if not name:
+ name = 'Viewpoint'
+
+ fieldOfView = node.getFieldAsFloat('fieldOfView', 0.785398, ancestry) # max is documented to be 1.0 but some files have higher.
+ # jump = node.getFieldAsBool('jump', True, ancestry)
+ orientation = node.getFieldAsFloatTuple('orientation', (0.0, 0.0, 1.0, 0.0), ancestry)
+ position = node.getFieldAsFloatTuple('position', (0.0, 0.0, 0.0), ancestry)
+ description = node.getFieldAsString('description', '', ancestry)
+
+ bpycam = bpy.data.cameras.new(name)
+
+ bpycam.angle = fieldOfView
+
+ mtx = Matrix.Translation(Vector(position)) * translateRotation(orientation)
+
+ bpyob = node.blendObject = bpy.data.objects.new("TODO", bpycam)
+ bpy.context.scene.objects.link(bpyob)
+ bpyob.matrix_world = getFinalMatrix(node, mtx, ancestry)
+
+
+def importTransform(node, ancestry):
+ name = node.getDefName()
+ if not name:
+ name = 'Transform'
+
+ bpyob = node.blendObject = bpy.data.objects.new(name, None)
+ bpy.context.scene.objects.link(bpyob)
+
+ bpyob.matrix_world = getFinalMatrix(node, None, ancestry)
+
+ # so they are not too annoying
+ bpyob.empty_draw_type = 'PLAIN_AXES'
+ bpyob.empty_draw_size = 0.2
+
+
+#def importTimeSensor(node):
+def action_fcurve_ensure(action, data_path, array_index):
+ for fcu in action.fcurves:
+ if fcu.data_path == data_path and fcu.array_index == array_index:
+ return fcu
+
+ return action.fcurves.new(data_path=data_path, array_index=array_index)
+
+
+def translatePositionInterpolator(node, action, ancestry):
+ key = node.getFieldAsArray('key', 0, ancestry)
+ keyValue = node.getFieldAsArray('keyValue', 3, ancestry)
+
+ loc_x = action_fcurve_ensure(action, "location", 0)
+ loc_y = action_fcurve_ensure(action, "location", 1)
+ loc_z = action_fcurve_ensure(action, "location", 2)
+
+ for i, time in enumerate(key):
+ try:
+ x, y, z = keyValue[i]
+ except:
+ continue
+
+ loc_x.keyframe_points.add(time, x)
+ loc_y.keyframe_points.add(time, y)
+ loc_z.keyframe_points.add(time, z)
+
+ for fcu in (loc_x, loc_y, loc_z):
+ for kf in fcu.keyframe_points:
+ kf.interpolation = 'LINEAR'
+
+
+def translateOrientationInterpolator(node, action, ancestry):
+ key = node.getFieldAsArray('key', 0, ancestry)
+ keyValue = node.getFieldAsArray('keyValue', 4, ancestry)
+
+ rot_x = action_fcurve_ensure(action, "rotation_euler", 0)
+ rot_y = action_fcurve_ensure(action, "rotation_euler", 1)
+ rot_z = action_fcurve_ensure(action, "rotation_euler", 2)
+
+ for i, time in enumerate(key):
+ try:
+ x, y, z, w = keyValue[i]
+ except:
+ continue
+
+ mtx = translateRotation((x, y, z, w))
+ eul = mtx.to_euler()
+ rot_x.keyframe_points.add(time, eul.x)
+ rot_y.keyframe_points.add(time, eul.y)
+ rot_z.keyframe_points.add(time, eul.z)
+
+ for fcu in (rot_x, rot_y, rot_z):
+ for kf in fcu.keyframe_points:
+ kf.interpolation = 'LINEAR'
+
+
+# Untested!
+def translateScalarInterpolator(node, action, ancestry):
+ key = node.getFieldAsArray('key', 0, ancestry)
+ keyValue = node.getFieldAsArray('keyValue', 4, ancestry)
+
+ sca_x = action_fcurve_ensure(action, "scale", 0)
+ sca_y = action_fcurve_ensure(action, "scale", 1)
+ sca_z = action_fcurve_ensure(action, "scale", 2)
+
+ for i, time in enumerate(key):
+ try:
+ x, y, z = keyValue[i]
+ except:
+ continue
+
+ sca_x.keyframe_points.new(time, x)
+ sca_y.keyframe_points.new(time, y)
+ sca_z.keyframe_points.new(time, z)
+
+
+def translateTimeSensor(node, action, ancestry):
+ '''
+ Apply a time sensor to an action, VRML has many combinations of loop/start/stop/cycle times
+ to give different results, for now just do the basics
+ '''
+
+ # XXX25 TODO
+ if 1:
+ return
+
+ time_cu = action.addCurve('Time')
+ time_cu.interpolation = Blender.IpoCurve.InterpTypes.LINEAR
+
+ cycleInterval = node.getFieldAsFloat('cycleInterval', None, ancestry)
+
+ startTime = node.getFieldAsFloat('startTime', 0.0, ancestry)
+ stopTime = node.getFieldAsFloat('stopTime', 250.0, ancestry)
+
+ if cycleInterval != None:
+ stopTime = startTime + cycleInterval
+
+ loop = node.getFieldAsBool('loop', False, ancestry)
+
+ time_cu.append((1 + startTime, 0.0))
+ time_cu.append((1 + stopTime, 1.0 / 10.0)) # anoying, the UI uses /10
+
+ if loop:
+ time_cu.extend = Blender.IpoCurve.ExtendTypes.CYCLIC # or - EXTRAP, CYCLIC_EXTRAP, CONST,
+
+
+def importRoute(node, ancestry):
+ '''
+ Animation route only at the moment
+ '''
+
+ if not hasattr(node, 'fields'):
+ return
+
+ routeIpoDict = node.getRouteIpoDict()
+
+ def getIpo(id):
+ try:
+ action = routeIpoDict[id]
+ except:
+ action = routeIpoDict[id] = bpy.data.actions.new('web3d_ipo')
+ return action
+
+ # for getting definitions
+ defDict = node.getDefDict()
+ '''
+ Handles routing nodes to eachother
+
+ROUTE vpPI.value_changed TO champFly001.set_position
+ROUTE vpOI.value_changed TO champFly001.set_orientation
+ROUTE vpTs.fraction_changed TO vpPI.set_fraction
+ROUTE vpTs.fraction_changed TO vpOI.set_fraction
+ROUTE champFly001.bindTime TO vpTs.set_startTime
+ '''
+
+ #from_id, from_type = node.id[1].split('.')
+ #to_id, to_type = node.id[3].split('.')
+
+ #value_changed
+ set_position_node = None
+ set_orientation_node = None
+ time_node = None
+
+ for field in node.fields:
+ if field and field[0] == 'ROUTE':
+ try:
+ from_id, from_type = field[1].split('.')
+ to_id, to_type = field[3].split('.')
+ except:
+ print("Warning, invalid ROUTE", field)
+ continue
+
+ if from_type == 'value_changed':
+ if to_type == 'set_position':
+ action = getIpo(to_id)
+ set_data_from_node = defDict[from_id]
+ translatePositionInterpolator(set_data_from_node, action, ancestry)
+
+ if to_type in ('set_orientation', 'rotation'):
+ action = getIpo(to_id)
+ set_data_from_node = defDict[from_id]
+ translateOrientationInterpolator(set_data_from_node, action, ancestry)
+
+ if to_type == 'set_scale':
+ action = getIpo(to_id)
+ set_data_from_node = defDict[from_id]
+ translateScalarInterpolator(set_data_from_node, action, ancestry)
+
+ elif from_type == 'bindTime':
+ action = getIpo(from_id)
+ time_node = defDict[to_id]
+ translateTimeSensor(time_node, action, ancestry)
+
+
+def load_web3d(path, PREF_FLAT=False, PREF_CIRCLE_DIV=16, HELPER_FUNC=None):
+
+ # Used when adding blender primitives
+ GLOBALS['CIRCLE_DETAIL'] = PREF_CIRCLE_DIV
+
+ #root_node = vrml_parse('/_Cylinder.wrl')
+ if path.lower().endswith('.x3d'):
+ root_node, msg = x3d_parse(path)
+ else:
+ root_node, msg = vrml_parse(path)
+
+ if not root_node:
+ print(msg)
+ return
+
+ # fill with tuples - (node, [parents-parent, parent])
+ all_nodes = root_node.getSerialized([], [])
+
+ for node, ancestry in all_nodes:
+ #if 'castle.wrl' not in node.getFilename():
+ # continue
+
+ spec = node.getSpec()
+ '''
+ prefix = node.getPrefix()
+ if prefix=='PROTO':
+ pass
+ else
+ '''
+ if HELPER_FUNC and HELPER_FUNC(node, ancestry):
+ # Note, include this function so the VRML/X3D importer can be extended
+ # by an external script. - gets first pick
+ pass
+ if spec == 'Shape':
+ importShape(node, ancestry)
+ elif spec in ('PointLight', 'DirectionalLight', 'SpotLight'):
+ importLamp(node, spec, ancestry)
+ elif spec == 'Viewpoint':
+ importViewpoint(node, ancestry)
+ elif spec == 'Transform':
+ # Only use transform nodes when we are not importing a flat object hierarchy
+ if PREF_FLAT == False:
+ importTransform(node, ancestry)
+ '''
+ # These are delt with later within importRoute
+ elif spec=='PositionInterpolator':
+ action = bpy.data.ipos.new('web3d_ipo', 'Object')
+ translatePositionInterpolator(node, action)
+ '''
+
+ # After we import all nodes, route events - anim paths
+ for node, ancestry in all_nodes:
+ importRoute(node, ancestry)
+
+ for node, ancestry in all_nodes:
+ if node.isRoot():
+ # we know that all nodes referenced from will be in
+ # routeIpoDict so no need to run node.getDefDict() for every node.
+ routeIpoDict = node.getRouteIpoDict()
+ defDict = node.getDefDict()
+
+ for key, action in routeIpoDict.items():
+
+ # Assign anim curves
+ node = defDict[key]
+ if node.blendObject == None: # Add an object if we need one for animation
+ node.blendObject = bpy.data.objects.new('AnimOb', None) # , name)
+ bpy.context.scene.objects.link(node.blendObject)
+
+ if node.blendObject.animation_data is None:
+ node.blendObject.animation_data_create()
+
+ node.blendObject.animation_data.action = action
+
+ # Add in hierarchy
+ if PREF_FLAT == False:
+ child_dict = {}
+ for node, ancestry in all_nodes:
+ if node.blendObject:
+ blendObject = None
+
+ # Get the last parent
+ i = len(ancestry)
+ while i:
+ i -= 1
+ blendObject = ancestry[i].blendObject
+ if blendObject:
+ break
+
+ if blendObject:
+ # Parent Slow, - 1 liner but works
+ # blendObject.makeParent([node.blendObject], 0, 1)
+
+ # Parent FAST
+ try:
+ child_dict[blendObject].append(node.blendObject)
+ except:
+ child_dict[blendObject] = [node.blendObject]
+
+ # Parent
+ for parent, children in child_dict.items():
+ for c in children:
+ c.parent = parent
+
+ # update deps
+ bpy.context.scene.update()
+ del child_dict
+
+
+def load(operator, context, filepath=""):
+
+ load_web3d(filepath,
+ PREF_FLAT=True,
+ PREF_CIRCLE_DIV=16,
+ )
+
+ return {'FINISHED'}