From 818afda046e6cbc6db7a0e77bba8e9cceb33d99f Mon Sep 17 00:00:00 2001
From: Nathan Letwory <nathan@letworyinteractive.com>
Date: Thu, 21 Apr 2011 14:04:05 +0000
Subject: Tag addons for Blender 2.57a release

---
 io_scene_3ds/__init__.py   |  108 +++++
 io_scene_3ds/export_3ds.py | 1072 ++++++++++++++++++++++++++++++++++++++++++++
 io_scene_3ds/import_3ds.py |  908 +++++++++++++++++++++++++++++++++++++
 3 files changed, 2088 insertions(+)
 create mode 100644 io_scene_3ds/__init__.py
 create mode 100644 io_scene_3ds/export_3ds.py
 create mode 100644 io_scene_3ds/import_3ds.py

(limited to 'io_scene_3ds')

diff --git a/io_scene_3ds/__init__.py b/io_scene_3ds/__init__.py
new file mode 100644
index 00000000..21bed64a
--- /dev/null
+++ b/io_scene_3ds/__init__.py
@@ -0,0 +1,108 @@
+# ##### 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",
+    "blender": (2, 5, 7),
+    "api": 35622,
+    "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 StringProperty, FloatProperty, BoolProperty
+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'})
+
+    use_selection = BoolProperty(name="Selection Only", description="Export selected objects only", default=False)
+
+    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.utils.register_module(__name__)
+
+    bpy.types.INFO_MT_file_import.append(menu_func_import)
+    bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+    bpy.utils.unregister_module(__name__)
+
+    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 00000000..bf7bd990
--- /dev/null
+++ b/io_scene_3ds/export_3ds.py
@@ -0,0 +1,1072 @@
+# ##### 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 = []  # stores str, ascii only
+name_mapping = {}  # stores {orig: byte} mapping
+
+
+def sane_name(name):
+    name_fixed = name_mapping.get(name)
+    if name_fixed is not None:
+        return name_fixed
+
+    # strip non ascii chars
+    new_name_clean = new_name = name.encode("ASCII", "replace").decode("ASCII")[:12]
+    i = 0
+
+    while new_name in name_unique:
+        new_name = new_name_clean + ".%.3d" % i
+        i += 1
+
+    # note, appending the 'str' version.
+    name_unique.append(new_name)
+    name_mapping[name] = new_name = new_name.encode("ASCII", "replace")
+    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):
+        assert(type(val) == bytes)
+        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)
+
+    name_str = material.name if material else "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 indices
+
+
+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
+            if img is not None:
+                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 mesh.uv_textures:
+        # 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:
+                name_str = mat if mat else "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_quaternion()  # XXX, todo!
+            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="",
+          use_selection=True,
+          ):
+
+    import bpy
+    import time
+    import io_utils
+    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)
+
+    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()
+    '''
+
+    # 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
+
+    if use_selection:
+        objects = (ob for ob in scene.objects if ob.is_visible(scene) and ob.select)
+    else:
+        objects = (ob for ob in scene.objects if ob.is_visible(scene))
+
+    for ob in objects:
+        # 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
+
+            try:
+                data = ob_derived.to_mesh(scene, True, 'PREVIEW')
+            except:
+                data = None
+
+            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]
+                            mat_name = None if mat is None else mat.name
+                        # else there already set to none
+
+                        img = uf.image
+                        img_name = None if img is None else img.name
+
+                        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 00000000..1aea6384
--- /dev/null
+++ b/io_scene_3ds/import_3ds.py
@@ -0,0 +1,908 @@
+# ##### 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 = 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
+EDITKEYFRAME = 0xB000  # This is the header for all of the key frame info
+
+#------ sub defines of OBJECTINFO
+MATERIAL = 0xAFFF  # This stored the texture info
+OBJECT = 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
+
+object_dictionary = {}
+object_matrix = {}
+
+
+#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
+    pivot_list = []  # pivots with hierarchy handling
+
+    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):
+                if matName is None:
+                    bmat = None
+                else:
+                    bmat = MATDICT.get(matName)
+                    # in rare cases no materials defined.
+                    if bmat:
+                        img = TEXTURE_DICT.get(bmat.name)
+                    else:
+                        print("    warning: material %r not defined!" % matName)
+                        bmat = MATDICT[matName] = bpy.data.materials.new(matName)
+                        img = None
+
+                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
+
+        bmesh.validate()
+        bmesh.update()
+
+        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
+            object_matrix[ob] = contextMatrix_rot.copy()
+
+        importedObjects.append(ob)
+
+    #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
+
+        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
+
+            temp_data = struct.unpack("<%dH" % (num_faces_using_mat), temp_data)
+
+            contextMeshMaterials.append((material_name, 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
+
+        # including these here means their EK_OB_NODE_HEADER are scanned
+        elif new_chunk.ID in {ED_KEY_AMBIENT_NODE,
+                               ED_KEY_OBJECT_NODE,
+                               ED_KEY_CAMERA_NODE,
+                               ED_KEY_TARGET_NODE,
+                               ED_KEY_LIGHT_NODE,
+                               ED_KEY_L_TARGET_NODE,
+                               ED_KEY_SPOTLIGHT_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)
+            pivot_list.append(mathutils.Vector((0.0, 0.0, 0.0)))
+
+        elif new_chunk.ID == EK_OB_INSTANCE_NAME:
+            object_name, read_str_len = read_string(file)
+            # child.name = object_name
+            child.name += "." + object_name
+            object_dictionary[object_name] = child
+            new_chunk.bytes_read += read_str_len
+            # print("new instance object:", object_name)
+
+        elif new_chunk.ID == EK_OB_PIVOT:  # translation
+                temp_data = file.read(STRUCT_SIZE_3FLOAT)
+                pivot = struct.unpack('<3f', temp_data)
+                new_chunk.bytes_read += STRUCT_SIZE_3FLOAT
+                pivot_list[len(pivot_list) - 1] = mathutils.Vector(pivot)
+
+        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]
+            # pivot_list[ind] += pivot_list[parent]  # XXX, not sure this is correct, should parent space matrix be applied before combining?
+    # fix pivots
+    for ind, ob in enumerate(object_list):
+        if ob.type == 'MESH':
+            pivot = pivot_list[ind]
+            pivot_matrix = object_matrix.get(ob, mathutils.Matrix())  # unlikely to fail
+            pivot_matrix = mathutils.Matrix.Translation(-pivot * pivot_matrix.to_3x3())
+            ob.data.transform(pivot_matrix)
+
+
+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
+
+    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()
+    object_matrix.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()
+    object_matrix.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.inverted())
+
+    # 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.0
+
+            # 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'}
-- 
cgit v1.2.3