3ds importer distributed with Blender 2.41 is broken in 2 places so bugfixed and...
authorCampbell Barton <ideasman42@gmail.com>
Wed, 1 Feb 2006 10:52:54 +0000 (10:52 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 1 Feb 2006 10:52:54 +0000 (10:52 +0000)
Version 0.93
- Tested with 400 3ds files from turbosquid, model cd's and net samples.
- Tactfully ignore faces that used the same verts twice.
- Rollback to 0.83 sloppy un-reorganized code, new code broke UV coord loading.
- Converted from NMesh to Mesh. First importer to use Mesh.
- Faster and cleaner new names.
- Use external comprehensive image loader.
- Re intergrated 0.92 and 0.9 changes
- Fixes for 2.41 compat.
- Non textured faces do not use a texture flag.

release/scripts/3ds_import.py

index 017ec74123fbf78e8a04a3fa145c98350c08b9cc..b5c307f7a0605cf164f0e2166948f607b4d67f42 100644 (file)
@@ -1,15 +1,14 @@
 #!BPY
-
 """ 
 Name: '3D Studio (.3ds)...'
-Blender: 237
+Blender: 241
 Group: 'Import'
-Tooltip: 'Import from 3DS file format. (.3ds)'
+Tooltip: 'Import from 3DS file format (.3ds)'
 """
 
 __author__ = ["Bob Holcomb", "Richard Lärkäng", "Damien McGinnes", "Campbell Barton"]
 __url__ = ("blender", "elysiun", "http://www.gametutorials.com")
-__version__ = "0.92"
+__version__ = "0.93"
 __bpydoc__ = """\
 
 3ds Importer
@@ -18,7 +17,17 @@ This script imports a 3ds file and the materials into Blender for editing.
 
 Loader is based on 3ds loader from www.gametutorials.com (Thanks DigiBen).
 
-Changes:
+
+0.93 by Campbell Barton<br> 
+- Tested with 400 3ds files from turbosquid and samples.
+- Tactfully ignore faces that used the same verts twice.
+- Rollback to 0.83 sloppy un-reorganized code, this broke UV coord loading.
+- Converted from NMesh to Mesh.
+- Faster and cleaner new names.
+- Use external comprehensive image loader.
+- Re intergrated 0.92 and 0.9 changes
+- Fixes for 2.41 compat.
+- Non textured faces do not use a texture flag.
 
 0.92<br>
 - Added support for diffuse, alpha, spec, bump maps in a single material
@@ -28,91 +37,87 @@ Changes:
 - Use of Matrix() to copy matrix data<br>
 - added support for material transparency<br>
 
-0.81a (fork- not 0.9) Campbell Barton 2005-06-08<br>
-- Simplified import code<br>
-- Never overwrite data<br>
-- Faster list handling<br>
-- Leaves import selected<br>
+0.83 2005-08-07: Campell Barton
+-  Aggressive image finding and case insensitivy for posisx systems.
 
-0.81 Damien McGinnes 2005-01-09<br>
-- handle missing images better<br>
+0.82a 2005-07-22
+- image texture loading (both for face uv and renderer)
 
-0.8 Damien McGinnes 2005-01-08<br>
-- copies sticky UV coords to face ones<br>
-- handles images better<br>
-- Recommend that you run 'RemoveDoubles' on each imported mesh after using this script
+0.82 - image texture loading (for face uv)
 
-"""
+0.81a (fork- not 0.9) Campbell Barton 2005-06-08
+- Simplified import code
+- Never overwrite data
+- Faster list handling
+- Leaves import selected
 
-# $Id$
-#
-# ***** BEGIN GPL LICENSE BLOCK *****
-#
-# Script copyright (C) Bob Holcomb
-#
-# 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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
-#
-# ***** END GPL LICENCE BLOCK *****
-# --------------------------------------------------------------------------
+0.81 Damien McGinnes 2005-01-09
+- handle missing images better
+    
+0.8 Damien McGinnes 2005-01-08
+- copies sticky UV coords to face ones
+- handles images better
+- Recommend that you run 'RemoveDoubles' on each imported mesh after using this script
 
+"""
 
 # Importing modules
 
 import Blender
-from Blender import NMesh, Scene, Object, Material, Image, Texture
+from Blender import Mesh, Scene, Object, Material, Image, Texture, Lamp, Mathutils
+from Blender.Mathutils import Vector
+import BPyImage
+reload(BPyImage)
 
-import sys, struct, string
+import struct
 
 import os
 
+#this script imports uvcoords as sticky vertex coords
+#this parameter enables copying these to face uv coords
+#which shold be more useful.
+
+
+#===========================================================================#
+# Returns unique name of object/mesh (stops overwriting existing meshes)    #
+#===========================================================================#
+def getUniqueName(name):
+       count = 0
+       newname = name[:19]
+       while newname in getUniqueName.uniqueObNames:
+               newname = '%s.%.3i' % (name[:15], count)
+               count+=1
+       # Dont use again.
+       getUniqueName.uniqueObNames.append(newname)
+       return newname
+getUniqueName.uniqueObNames = Blender.NMesh.GetNames() + [ob.name for ob in Object.Get()]
+
+def createBlenderTexture(material, name, image):
+       texture = Texture.New(name)
+       texture.setType('Image')
+       texture.image = image
+       material.setTexture(0, texture, Texture.TexCo.UV, Texture.MapTo.COL)
+
+
+
 ######################################################
 # Data Structures
 ######################################################
-#----- Primary Chunk, 
-PRIMARY                        =       long("0x4D4D",16)       # should be aat the beginning of each file
-VERSION                        =       long("0x0002",16)       #This gives the version of the .3ds file
-EDITOR_BLOCK   =       long("0x3D3D",16)       #this is the Editor Data block, contains objects, materials
-KEYFRAME_BLOCK =       long("0xB000",16)       #This is the header for all of the key frame info
-
-#------ sub defines of EDITOR_BLOCK
-MATERIAL_BLOCK =       long("0xAFFF",16)       #This stores the Material info
-OBJECT_BLOCK   =       long("0x4000",16)       #This stores the Object,Camera,Light
-
-#------ sub defines of OBJECT_BLOCK
-OBJECT_MESH            =       long("0x4100",16)       # This lets us know that we are reading a new object
-OBJECT_LIGHT   =       long("0x4600",16)       # This lets un know we are reading a light object
-OBJECT_CAMERA  =       long("0x4700",16)       # This lets un know we are reading a camera object
-
-#------ sub defines of OBJECT_MESH
-MESH_VERTICES  =       long("0x4110",16)       # The objects vertices
-MESH_FACES             =       long("0x4120",16)       # The objects faces
-MESH_MATERIAL  =       long("0x4130",16)       # This is found if the object has a material, either texture map or color
-MESH_UV                        =       long("0x4140",16)       # The UV texture coordinates
-MESH_TRANS_MATRIX      =       long("0x4160",16)       # The Object Matrix
-MESH_COLOR             =       long("0x4165",16)       # The color of the object
-MESH_TEXTURE_INFO      =       long("0x470",16)        # Info about the Object Texture
-
-#------ sub defines of OBJECT_CAMERA
-CAMERA_CONE            =       long("0x4710",16)       # The camera see cone
-CAMERA_RANGES  =       long("0x4720",16)       # The camera range values
-
-#------ sub defines of OBJECT_LIGHT
-LIGHT_SPOTLIGHT        =       long("0x4610",16)       # A spotlight
-LIGHT_ATTENUATE        =       long("0x4625",16)       # Light attenuation values
 
+#Some of the chunks that we will see
+#----- Primary Chunk, at the beginning of each file
+PRIMARY= long("0x4D4D",16)
 
+#------ Main Chunks
+OBJECTINFO   =      long("0x3D3D",16);      #This gives the version of the mesh and is found right before the material and object information
+VERSION      =      long("0x0002",16);      #This gives the version of the .3ds file
+EDITKEYFRAME=      long("0xB000",16);      #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               =       long("0xA000",16)       # This holds the material name
 MAT_AMBIENT            =       long("0xA010",16)       # Ambient color of the object/material
@@ -128,24 +133,56 @@ MAT_SPECULAR_MAP= long("0xA204",16)       # This is a header for a new specular map
 MAT_OPACITY_MAP        =       long("0xA210",16)       # This is a header for a new opacity map
 MAT_REFLECTION_MAP=    long("0xA220",16)       # This is a header for a new reflection map
 MAT_BUMP_MAP   =       long("0xA230",16)       # This is a header for a new bump map
-MAT_MAP_FILENAME=      long("0xA300",16)       # This holds the file name of the texture
-#lots more to add here for maps
-
-######################################################
-# Globals
-######################################################
-TEXTURE_DICT={}
-MATERIAL_DICT={}
-
-
-######################################################
-# Chunk Class
-######################################################
+MAT_MAP_FILENAME =      long("0xA300",16);      # This holds the file name of the texture
+
+#>------ sub defines of OBJECT
+OBJECT_MESH  =      long("0x4100",16);      # This lets us know that we are reading a new object
+OBJECT_LAMP =      long("0x4600",16);      # This lets un know we are reading a light object
+OBJECT_LAMP_SPOT = long("0x4610",16);          # The light is a spotloght.
+OBJECT_LAMP_OFF = long("0x4620",16);           # The light off.
+OBJECT_LAMP_ATTENUATE = long("0x4625",16);     
+OBJECT_LAMP_RAYSHADE = long("0x4627",16);      
+OBJECT_LAMP_SHADOWED = long("0x4630",16);      
+OBJECT_LAMP_LOCAL_SHADOW = long("0x4640",16);  
+OBJECT_LAMP_LOCAL_SHADOW2 = long("0x4641",16); 
+OBJECT_LAMP_SEE_CONE = long("0x4650",16);      
+OBJECT_LAMP_SPOT_RECTANGULAR= long("0x4651",16);
+OBJECT_LAMP_SPOT_OVERSHOOT= long("0x4652",16);
+OBJECT_LAMP_SPOT_PROJECTOR= long("0x4653",16);
+OBJECT_LAMP_EXCLUDE= long("0x4654",16);
+OBJECT_LAMP_RANGE= long("0x4655",16);
+OBJECT_LAMP_ROLL= long("0x4656",16);
+OBJECT_LAMP_SPOT_ASPECT= long("0x4657",16);
+OBJECT_LAMP_RAY_BIAS= long("0x4658",16);
+OBJECT_LAMP_INNER_RANGE= long("0x4659",16);
+OBJECT_LAMP_OUTER_RANGE= long("0x465A",16);
+OBJECT_LAMP_MULTIPLIER = long("0x465B",16);
+OBJECT_LAMP_AMBIENT_LIGHT = long("0x4680",16);
+
+
+
+OBJECT_CAMERA=      long("0x4700",16);      # This lets un know we are reading a camera object
+
+#>------ sub defines of CAMERA
+OBJECT_CAM_RANGES=   long("0x4720",16);      # The camera range values
+
+#>------ sub defines of OBJECT_MESH
+OBJECT_VERTICES =   long("0x4110",16);      # The objects vertices
+OBJECT_FACES    =   long("0x4120",16);      # The objects faces
+OBJECT_MATERIAL =   long("0x4130",16);      # This is found if the object has a material, either texture map or color
+OBJECT_UV       =   long("0x4140",16);      # The UV texture coordinates
+OBJECT_TRANS_MATRIX  =   long("0x4160",16); # The Object Matrix
+
+global scn
+scn = None
+
+#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):
@@ -154,58 +191,60 @@ class chunk:
                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
                
 
-######################################################
-# Helper functions
-######################################################
 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]
-       chunk.bytes_read=6
+               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
 
-def skip_to_end(file, skip_chunk):
-       buffer_size=skip_chunk.length-skip_chunk.bytes_read
-       binary_format=str(buffer_size)+"c"
-       temp_data=file.read(struct.calcsize(binary_format))
-       skip_chunk.bytes_read+=buffer_size
+               #if debugging
+               #chunk.dump()
 
 def read_string(file):
        s=""
        index=0
-       #read the first character
+       #print "reading a string"
+       #read in the characters till we get a null character
        temp_data=file.read(1)
        data=struct.unpack("c", temp_data)
        s=s+(data[0])
-       #read in the characters till we get a null character
+       #print "string: ",s
        while(ord(s[index])!=0):
                index+=1
                temp_data=file.read(1)
                data=struct.unpack("c", temp_data)
                s=s+(data[0])
-       the_string=s[:-1]  #remove the null character from the string
-       return str(the_string)
+               #print "string: ",s
+       
+       #remove the null character from the string
+       the_string=s[:-1]
+       return the_string
+
+######################################################
+# 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=str(buffer_size)+"c"
+       temp_data=file.read(struct.calcsize(binary_format))
+       skip_chunk.bytes_read+=buffer_size
 
-def getUniqueName(name):
-       newName = name
-       uniqueInt = 0
-       while 1:
-               try:
-                       ob = Object.Get(newName)
-                       # Okay, this is working, so lets make a new name
-                       newName = '%s.%d' % (name, uniqueInt)
-                       uniqueInt +=1
-               except AttributeError:
-                       if newName not in NMesh.GetNames():
-                               return newName
-                       else:
-                               newName = '%s.%d' % (name, uniqueInt)
-                               uniqueInt +=1
 
 def add_texture_to_material(image, texture, material, mapto):
        if mapto=="DIFFUSE":
@@ -220,226 +259,155 @@ def add_texture_to_material(image, texture, material, mapto):
                print "/tError:  Cannot map to ", mapto
                return
        
+
        texture.setImage(image)
        texture_list=material.getTextures()
        index=0
        for tex in texture_list:
                if tex==None:
-                       material.setTexture(index,texture,Texture.TexCo.OBJECT,map)
+                       material.setTexture(index,texture,Texture.TexCo.UV,map)
                        return
                else:
                        index+=1
                if index>10:
                        print "/tError: Cannot add diffuse map.  Too many textures"
+
+def process_next_chunk(file, filename, previous_chunk):
+       scn = Scene.GetCurrent()
+       contextObName = None
+       contextLamp = [None, None] # object, Data
+       contextMaterial = None
+       contextMatrix = Blender.Mathutils.Matrix(); contextMatrix.identity()
+       contextMesh = None
+       
+       TEXTURE_DICT={}
+       MATDICT={}
+       TEXMODE = Mesh.FaceModes['TEX']
+       objectList = [] # Keep a list of imported objects.
        
-######################################################
-# Process an object (tri-mesh, Camera, or Light)
-######################################################
-def process_object_block(file, previous_chunk, object_list):
        # Localspace variable names, faster.
+       STRUCT_SIZE_1CHAR = struct.calcsize("c")
        STRUCT_SIZE_2FLOAT = struct.calcsize("2f")
        STRUCT_SIZE_3FLOAT = struct.calcsize("3f")
        STRUCT_SIZE_UNSIGNED_SHORT = struct.calcsize("H")
        STRUCT_SIZE_4UNSIGNED_SHORT = struct.calcsize("4H")
        STRUCT_SIZE_4x3MAT = struct.calcsize("ffffffffffff")
        
-       #spare chunks
-       new_chunk=chunk()
-       temp_chunk=chunk()
-       
-       global TEXURE_DICT
-       global MATERIAL_DICT
-       
-       #don't know which one we're making, so let's have a place for one of each
-       new_mesh=None
-       new_light=None
-       new_camera=None
        
-       #all objects have a name (first thing)
-       tempName = str(read_string(file))
-       obj_name = getUniqueName( tempName )
-       previous_chunk.bytes_read += (len(tempName)+1)
-       
-       while (previous_chunk.bytes_read<previous_chunk.length):
-               read_chunk(file, new_chunk)
+       def putContextMesh(myContextMesh):
+               INV_MAT = Blender.Mathutils.Matrix(contextMatrix)
                
-               if (new_chunk.ID==OBJECT_MESH):
-                       new_mesh=Blender.NMesh.New(obj_name)
-                       while (new_chunk.bytes_read<new_chunk.length):
-                               read_chunk(file, temp_chunk)
-                               
-                               if (temp_chunk.ID==MESH_VERTICES):
-                                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
-                                       data=struct.unpack("H", temp_data)
-                                       temp_chunk.bytes_read+=2
-                                       num_verts=data[0]
-                                       for counter in range (num_verts):
-                                               temp_data=file.read(STRUCT_SIZE_3FLOAT)
-                                               temp_chunk.bytes_read += STRUCT_SIZE_3FLOAT
-                                               data=struct.unpack("3f", temp_data)
-                                               v=NMesh.Vert(data[0],data[1],data[2])
-                                               new_mesh.verts.append(v)
-               
-                               elif (temp_chunk.ID==MESH_FACES):
-                                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
-                                       data=struct.unpack("H", temp_data)
-                                       temp_chunk.bytes_read+=2
-                                       num_faces=data[0]
-                                       for counter in range(num_faces):
-                                               temp_data=file.read(STRUCT_SIZE_4UNSIGNED_SHORT)
-                                               temp_chunk.bytes_read += STRUCT_SIZE_4UNSIGNED_SHORT #4 short ints x 2 bytes each
-                                               data=struct.unpack("4H", temp_data)
-                                               #insert the mesh info into the faces, don't worry about data[3] it is a 3D studio thing
-                                               f = NMesh.Face( [new_mesh.verts[data[i]] for i in xrange(3)] )
-                                               f.uv = [ tuple(new_mesh.verts[data[i]].uvco[:2]) for  i in xrange(3) ]
-                                               new_mesh.faces.append(f)
-               
-                               elif (temp_chunk.ID==MESH_MATERIAL):
-                                       material_name=""
-                                       material_name=str(read_string(file))
-                                       temp_chunk.bytes_read += len(material_name)+1 # remove 1 null character.
-                                       material_found=0
-                                       for mat in Material.Get():
-                                               if(mat.name==material_name):
-                                                       if len(new_mesh.materials) >= 15:
-                                                               print "\tCant assign more than 16 materials per mesh, keep going..."
-                                                               break
-                                                       else:
-                                                               meshHasMat = 0
-                                                               for myMat in new_mesh.materials:
-                                                                       if myMat.name == mat.name:
-                                                                               meshHasMat = 1
-                                                               if meshHasMat == 0:
-                                                                       new_mesh.addMaterial(mat)
-                                                                       material_found=1
-                                                                       #figure out what material index this is for the mesh
-                                                                       for mat_counter in range(len(new_mesh.materials)):
-                                                                               if new_mesh.materials[mat_counter].name == material_name:
-                                                                                       mat_index=mat_counter                                                   
-                                                               break # get out of this for loop so we don't accidentally set material_found back to 0
-                                               else:
-                                                       material_found=0
-                                                       
-                                       if material_found == 1:
-                                               #read the number of faces using this material
-                                               temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
-                                               data=struct.unpack("H", temp_data)
-                                               temp_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
-                                               num_faces_using_mat=data[0]
-                                               #list of faces using mat
-                                               for face_counter in range(num_faces_using_mat):
-                                                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
-                                                       temp_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
-                                                       data=struct.unpack("H", temp_data)
-                                                       new_mesh.faces[data[0]].materialIndex = mat_index       
-                                                       try:
-                                                               mname = MATERIAL_DICT[mat.name]
-                                                               new_mesh.faces[data[0]].image = TEXTURE_DICT[mname]
-                                                       except:
-                                                               continue
-                                       else:
-                                               #read past the information about the material you couldn't find
-                                               skip_to_end(file,temp_chunk)    
-               
-                               elif (new_chunk.ID == MESH_UV):
-                                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
-                                       data=struct.unpack("H", temp_data)
-                                       temp_chunk.bytes_read+=2
-                                       num_uv=data[0]
+               INV_MAT.invert()
+               contextMesh.transform(INV_MAT)
                
-                                       for counter in range(num_uv):
-                                               temp_data=file.read(STRUCT_SIZE_2FLOAT)
-                                               temp_chunk.bytes_read += STRUCT_SIZE_2FLOAT #2 float x 4 bytes each
-                                               data=struct.unpack("2f", temp_data)
-                                               #insert the insert the UV coords in the vertex data
-                                               new_mesh.verts[counter].uvco = data
+               # Faces without an image can have the image flag disabled.
+               if myContextMesh.faceUV:
+                       TEX_ON_FLAG = Mesh.FaceModes['TEX']
+                       for f in myContextMesh.faces:
+                               if not f.image:
+                                       f.mode &= ~TEX_ON_FLAG # disable tex flag.
+                               for c in f.col:
+                                       c.b=c.g=c.r=255
                                
-                               elif (new_chunk.ID == MESH_TRANS_MATRIX):
-                                       temp_data=file.read(STRUCT_SIZE_4x3MAT)
-                                       data = list( struct.unpack("ffffffffffff", temp_data) )
-                                       temp_chunk.bytes_read += STRUCT_SIZE_4x3MAT 
-                                       new_matrix = Blender.Mathutils.Matrix(\
-                                       data[:3] + [0],\
-                                       data[3:6] + [0],\
-                                       data[6:9] + [0],\
-                                       data[9:] + [1])
-                                       new_mesh.setMatrix(new_matrix)
-                               else:
-                                       skip_to_end(file, temp_chunk)
                                
-                               new_chunk.bytes_read+=temp_chunk.bytes_read
-               
-               elif (new_chunk.ID==OBJECT_LIGHT):
-                       skip_to_end(file,new_chunk)
-
-               elif (new_chunk.ID==OBJECT_CAMERA):
-                       skip_to_end(file,new_chunk)
-                       
-               else: #don't know what kind of object it is
-                       skip_to_end(file,new_chunk)
-               
-               if new_mesh!=None:
-                       object_list.append(NMesh.PutRaw(new_mesh))
-               if new_light!=None:
-                       object_list.append(new_light)
-               if new_camera!=None:
-                       object_list.append(new_camera)
+               newOb = Object.New('Mesh', contextMesh.name) # Meshes name is always a free object name too.
+               newOb.link(contextMesh)
+               scn.link(newOb)
+               newOb.Layers = scn.Layers
+               newOb.sel = 1
+               objectList.append(newOb) # last 2 recal normals
+               newOb.setMatrix(contextMatrix)
                
-               previous_chunk.bytes_read+=new_chunk.bytes_read
-
-######################################################
-# Process a Material
-######################################################
-def process_material_block(file, previous_chunk):
-       # Localspace variable names, faster.
-       STRUCT_SIZE_3BYTE = struct.calcsize("3B")
-       STRUCT_SIZE_UNSIGNED_SHORT = struct.calcsize("H")
+               Blender.Window.EditMode(1)
+               Blender.Window.EditMode(0)
+       
        
-       #spare chunks
+       #a spare chunk
        new_chunk=chunk()
        temp_chunk=chunk()
-       
-       global TEXURE_DICT
-       global MATERIAL_DICT
-       
-       new_material=Blender.Material.New()
-       
+
+       #loop through all the data for this chunk (previous chunk) and see what it is
        while (previous_chunk.bytes_read<previous_chunk.length):
                #read the next chunk
+               #print "reading a chunk"
                read_chunk(file, new_chunk)
+
+               #is it a Version chunk?
+               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"))
+                       data=struct.unpack("I", temp_data)
+                       version=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 "found an OBJECTINFO chunk"
+                       process_next_chunk(file, filename, new_chunk)
+                       
+                       #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):
+                       tempName = read_string(file)
+                       contextObName = getUniqueName( tempName )
+                       new_chunk.bytes_read += (len(tempName)+1)
+               
+               #is it a material chunk?
+               elif (new_chunk.ID==MATERIAL):
+                       # print "found a MATERIAL chunk"
+                       contextMaterial = Material.New()
                
-               if (new_chunk.ID==MAT_NAME):
+               elif (new_chunk.ID==MAT_NAME):
+                       # print "Found a MATNAME chunk"
                        material_name=""
-                       material_name=str(read_string(file))
-                       new_chunk.bytes_read+=(len(material_name)+1) #plus one for the null character that ended the string
-                       new_material.setName(material_name)
-                       MATERIAL_DICT[material_name] = new_material.name
+                       material_name=read_string(file)
+                       
+                       #plus one for the null character that ended the string
+                       new_chunk.bytes_read+=(len(material_name)+1)
+                       
+                       contextMaterial.setName(material_name)
+                       MATDICT[material_name] = contextMaterial.name
                
                elif (new_chunk.ID==MAT_AMBIENT):
+                       # print "Found a MATAMBIENT chunk"
+
                        read_chunk(file, temp_chunk)
-                       temp_data=file.read(STRUCT_SIZE_3BYTE)
+                       temp_data=file.read(struct.calcsize("3B"))
                        data=struct.unpack("3B", temp_data)
                        temp_chunk.bytes_read+=3
-                       new_material.mirCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
+                       contextMaterial.mirCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
                        new_chunk.bytes_read+=temp_chunk.bytes_read
 
                elif (new_chunk.ID==MAT_DIFFUSE):
+                       # print "Found a MATDIFFUSE chunk"
+
                        read_chunk(file, temp_chunk)
-                       temp_data=file.read(STRUCT_SIZE_3BYTE)
+                       temp_data=file.read(struct.calcsize("3B"))
                        data=struct.unpack("3B", temp_data)
                        temp_chunk.bytes_read+=3
-                       new_material.rgbCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
+                       contextMaterial.rgbCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
                        new_chunk.bytes_read+=temp_chunk.bytes_read
 
                elif (new_chunk.ID==MAT_SPECULAR):
+                       # print "Found a MATSPECULAR chunk"
+
                        read_chunk(file, temp_chunk)
-                       temp_data=file.read(STRUCT_SIZE_3BYTE)
+                       temp_data=file.read(struct.calcsize("3B"))
                        data=struct.unpack("3B", temp_data)
                        temp_chunk.bytes_read+=3
-                       new_material.specCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
+                       
+                       contextMaterial.specCol = [float(col)/255 for col in data] # data [0,1,2] == rgb
                        new_chunk.bytes_read+=temp_chunk.bytes_read
 
                elif (new_chunk.ID==MAT_TEXTURE_MAP):
+                       #print 'DIFFUSE MAP'
                        new_texture=Blender.Texture.New('Diffuse')
                        new_texture.setType('Image')
                        while (new_chunk.bytes_read<new_chunk.length):
@@ -448,18 +416,7 @@ def process_material_block(file, previous_chunk):
                                if (temp_chunk.ID==MAT_MAP_FILENAME):
                                        texture_name=""
                                        texture_name=str(read_string(file))
-                                       try:
-                                               img = Image.Load(texture_name)
-                                               TEXTURE_DICT[new_material.name]=img
-                                       except IOError:
-                                               fname = os.path.join( os.path.dirname(FILENAME), texture_name)
-                                               try:
-                                                       img = Image.Load(fname)
-                                                       TEXTURE_DICT[new_material.name]=img
-                                               except IOError:
-                                                       print "\tERROR: failed to load image ",texture_name
-                                                       TEXTURE_DICT[new_material.name] = None # Dummy
-                                                       img=Blender.Image.New(fname,1,1,24) #blank image
+                                       img = TEXTURE_DICT[contextMaterial.name] = BPyImage.comprehensiveImageLoad(texture_name, FILENAME)
                                        new_chunk.bytes_read += (len(texture_name)+1) #plus one for the null character that gets removed
                                        
                                else:
@@ -468,8 +425,8 @@ def process_material_block(file, previous_chunk):
                                new_chunk.bytes_read+=temp_chunk.bytes_read
                        
                        #add the map to the material in the right channel
-                       add_texture_to_material(img, new_texture, new_material, "DIFFUSE")
-                               
+                       add_texture_to_material(img, new_texture, contextMaterial, "DIFFUSE")
+                       
                elif (new_chunk.ID==MAT_SPECULAR_MAP):
                        new_texture=Blender.Texture.New('Specular')
                        new_texture.setType('Image')
@@ -479,18 +436,7 @@ def process_material_block(file, previous_chunk):
                                if (temp_chunk.ID==MAT_MAP_FILENAME):
                                        texture_name=""
                                        texture_name=str(read_string(file))
-                                       try:
-                                               img = Image.Load(texture_name)
-                                               TEXTURE_DICT[new_material.name]=img
-                                       except IOError:
-                                               fname = os.path.join( os.path.dirname(FILENAME), texture_name)
-                                               try:
-                                                       img = Image.Load(fname)
-                                                       TEXTURE_DICT[new_material.name]=img
-                                               except IOError:
-                                                       print "\tERROR: failed to load image ",texture_name
-                                                       TEXTURE_DICT[new_material.name] = None # Dummy
-                                                       img=Blender.Image.New(fname,1,1,24) #blank image
+                                       img = BPyImage.comprehensiveImageLoad(texture_name, FILENAME)
                                        new_chunk.bytes_read += (len(texture_name)+1) #plus one for the null character that gets removed
                                else:
                                        skip_to_end(file, temp_chunk)
@@ -498,7 +444,7 @@ def process_material_block(file, previous_chunk):
                                new_chunk.bytes_read+=temp_chunk.bytes_read
                                
                        #add the map to the material in the right channel
-                       add_texture_to_material(img, new_texture, new_material, "SPECULAR")
+                       add_texture_to_material(img, new_texture, contextMaterial, "SPECULAR")
        
                elif (new_chunk.ID==MAT_OPACITY_MAP):
                        new_texture=Blender.Texture.New('Opacity')
@@ -509,18 +455,7 @@ def process_material_block(file, previous_chunk):
                                if (temp_chunk.ID==MAT_MAP_FILENAME):
                                        texture_name=""
                                        texture_name=str(read_string(file))
-                                       try:
-                                               img = Image.Load(texture_name)
-                                               TEXTURE_DICT[new_material.name]=img
-                                       except IOError:
-                                               fname = os.path.join( os.path.dirname(FILENAME), texture_name)
-                                               try:
-                                                       img = Image.Load(fname)
-                                                       TEXTURE_DICT[new_material.name]=img
-                                               except IOError:
-                                                       print "\tERROR: failed to load image ",texture_name
-                                                       TEXTURE_DICT[new_material.name] = None # Dummy
-                                                       img=Blender.Image.New(fname,1,1,24) #blank image
+                                       img = BPyImage.comprehensiveImageLoad(texture_name, FILENAME)
                                        new_chunk.bytes_read += (len(texture_name)+1) #plus one for the null character that gets removed
                                else:
                                        skip_to_end(file, temp_chunk)
@@ -528,7 +463,7 @@ def process_material_block(file, previous_chunk):
                                new_chunk.bytes_read+=temp_chunk.bytes_read
 
                        #add the map to the material in the right channel
-                       add_texture_to_material(img, new_texture, new_material, "OPACITY")
+                       add_texture_to_material(img, new_texture, contextMaterial, "OPACITY")
 
                elif (new_chunk.ID==MAT_BUMP_MAP):
                        new_texture=Blender.Texture.New('Bump')
@@ -539,18 +474,7 @@ def process_material_block(file, previous_chunk):
                                if (temp_chunk.ID==MAT_MAP_FILENAME):
                                        texture_name=""
                                        texture_name=str(read_string(file))
-                                       try:
-                                               img = Image.Load(texture_name)
-                                               TEXTURE_DICT[new_material.name]=img
-                                       except IOError:
-                                               fname = os.path.join( os.path.dirname(FILENAME), texture_name)
-                                               try:
-                                                       img = Image.Load(fname)
-                                                       TEXTURE_DICT[new_material.name]=img
-                                               except IOError:
-                                                       print "\tERROR: failed to load image ",texture_name
-                                                       TEXTURE_DICT[new_material.name] = None # Dummy
-                                                       img=Blender.Image.New(fname,1,1,24) #blank image        
+                                       img = BPyImage.comprehensiveImageLoad(texture_name, FILENAME)
                                        new_chunk.bytes_read += (len(texture_name)+1) #plus one for the null character that gets removed
                                else:
                                        skip_to_end(file, temp_chunk)
@@ -558,105 +482,319 @@ def process_material_block(file, previous_chunk):
                                new_chunk.bytes_read+=temp_chunk.bytes_read
                                
                        #add the map to the material in the right channel
-                       add_texture_to_material(img, new_texture, new_material, "BUMP")
+                       add_texture_to_material(img, new_texture, contextMaterial, "BUMP")
                        
                elif (new_chunk.ID==MAT_TRANSPARENCY):
                        read_chunk(file, temp_chunk)
                        temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
                        data=struct.unpack("H", temp_data)
                        temp_chunk.bytes_read+=2
-                       new_material.setAlpha(1-(float(data[0])/100))
+                       contextMaterial.setAlpha(1-(float(data[0])/100))
                        new_chunk.bytes_read+=temp_chunk.bytes_read
-                       
-               else:
-                       skip_to_end(file,new_chunk)
-               
-               previous_chunk.bytes_read+=new_chunk.bytes_read
 
-######################################################
-# process a main chunk
-######################################################
-def process_main_chunk(file,previous_chunk,new_object_list):
-       
-       #spare chunks
-       new_chunk=chunk()
-       temp_chunk=chunk()
 
-       #Go through the main chunk
-       while (previous_chunk.bytes_read<previous_chunk.length):
-               read_chunk(file, new_chunk)
+               elif (new_chunk.ID==OBJECT_LAMP): # Basic lamp support.
+                       # print "Found an OBJECT_MESH chunk"
+                       #if contextLamp != None: # Write context mesh if we have one.
+                       #       putContextLamp(contextLamp)
+                       
+                       #print 'LAMP!!!!!!!!!'
+                       temp_data=file.read(STRUCT_SIZE_3FLOAT)
+                       
+                       data=struct.unpack("3f", temp_data)
+                       new_chunk.bytes_read+=STRUCT_SIZE_3FLOAT
+                       x,y,z =tuple(data)
+                       
+                       
+                       contextLamp[0] = Object.New('Lamp')
+                       contextLamp[1] = Lamp.New()
+                       contextLamp[0].link(contextLamp[1])
+                       scn.link(contextLamp[0])
+                       
+                       
+                       
+                       #print "number of faces: ", num_faces
+                       #print x,y,z
+                       contextLamp[0].setLocation(x,y,z)
+                       
+                       # Reset matrix
+                       contextMatrix = Mathutils.Matrix(); contextMatrix.identity()    
+                       #print contextLamp.name, '"""""""'
+                       
+                       
+               elif (new_chunk.ID==OBJECT_MESH):
+                       # print "Found an OBJECT_MESH chunk"
+                       if contextMesh != None: # Write context mesh if we have one.
+                               putContextMesh(contextMesh)
+                       
+                       contextMesh = Mesh.New()
+                       contextMeshUV = None
+                       #contextMesh.vertexUV= 1 # Make sticky coords.
+                       # Reset matrix
+                       contextMatrix = Blender.Mathutils.Matrix(); contextMatrix.identity()
                
-               if (new_chunk.ID==VERSION):
-                       temp_data=file.read(struct.calcsize("I"))
-                       data=struct.unpack("I", temp_data)
-                       version=data[0]
-                       new_chunk.bytes_read+=4 #read the 4 bytes for the version number
-                       if (version>3): #this loader works with version 3 and below, but may not with 4 and above
-                               print "\tNon-Fatal Error:  Version greater than 3, may not load correctly: ", version
+               elif (new_chunk.ID==OBJECT_VERTICES):
+                       # print "Found an OBJECT_VERTICES chunk"
+                       #print "object_verts: length: ", new_chunk.length
+                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+                       data=struct.unpack("H", temp_data)
+                       new_chunk.bytes_read+=2
+                       num_verts=data[0]
+                       # print "number of verts: ", num_verts
+                       def getvert():
+                               temp_data=file.read(STRUCT_SIZE_3FLOAT)
+                               new_chunk.bytes_read += STRUCT_SIZE_3FLOAT #12: 3 floats x 4 bytes each
+                               data=struct.unpack("3f", temp_data)
+                               return Vector(data[0],data[1],data[2])
+                       
+                       contextMesh.verts.extend( [getvert() for i in xrange(num_verts)] )
+                       #print "object verts: bytes read: ", new_chunk.bytes_read
 
-               elif (new_chunk.ID==EDITOR_BLOCK):
-                       while(new_chunk.bytes_read<new_chunk.length):
-                               read_chunk(file, temp_chunk)
-                               if (temp_chunk.ID==MATERIAL_BLOCK):
-                                       process_material_block(file, temp_chunk)
-                               elif (temp_chunk.ID==OBJECT_BLOCK):
-                                       process_object_block(file, temp_chunk,new_object_list)
+               elif (new_chunk.ID==OBJECT_FACES):
+                       # print "Found an OBJECT_FACES chunk"
+                       #print "object faces: length: ", new_chunk.length
+                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+                       data=struct.unpack("H", temp_data)
+                       new_chunk.bytes_read+=2
+                       num_faces=data[0]
+                       #print "number of faces: ", num_faces
+                       
+                       """
+                       
+                       for counter in xrange(num_faces):
+                               temp_data=file.read(STRUCT_SIZE_4UNSIGNED_SHORT)
+                               new_chunk.bytes_read += STRUCT_SIZE_4UNSIGNED_SHORT #4 short ints x 2 bytes each
+                               data=struct.unpack("4H", temp_data)
+                               
+                               #insert the mesh info into the faces, don't worry about data[3] it is a 3D studio thing
+                               contextMesh.faces.extend([contextMesh.verts[data[i]] for i in xrange(3) ])
+                               f = contextMesh.faces[-1]
+                               if contextMeshUV:
+                                       contextMesh.faceUV= 1 # Make sticky coords.
+                                       f.uv = [ contextMeshUV[data[i]] for i in xrange(3) ]
+                       
+                       """
+                       
+                       def getface():
+                               temp_data=file.read(STRUCT_SIZE_4UNSIGNED_SHORT)
+                               new_chunk.bytes_read += STRUCT_SIZE_4UNSIGNED_SHORT #4 short ints x 2 bytes each
+                               data=struct.unpack("4H", temp_data)
+                               verts = [contextMesh.verts[data[i]] for i in xrange(3) ]
+                               
+                               if verts[0]==verts[1] or verts[0]==verts[2] or verts[1]==verts[2]:
+                                       return None
                                else:
-                                       skip_to_end(file,temp_chunk)
+                                       return verts
+                       
+                       contextFaceMapping = {} # So error faces dont unsync the this.
+                       #contextMesh.faces.extend( [getface() for i in xrange(num_faces)] )
+                       for i in xrange(num_faces):
+                               ok=0
+                               face= getface()
+                               if face:
+                                       lenback = len(contextMesh.faces)
+                                       contextMesh.faces.extend( face )
+                                       if len(contextMesh.faces) != lenback:
+                                               ok=1
+                                               contextFaceMapping[i] = len(contextMesh.faces)-1
+                               if not ok:
+                                       contextFaceMapping[i] = None
                                        
-                               new_chunk.bytes_read+=temp_chunk.bytes_read
-               else: 
-                       skip_to_end(file,new_chunk)
+                       
+                       #print 'LENFACEWS', len(contextMesh.faces), num_faces
+                       if contextMeshUV:
+                               contextMesh.faceUV= 1
+                               for f in contextMesh.faces:
+                                       f.uv = [contextMeshUV[v.index] for v in f.v ]
+                       
+                       #print "object faces: bytes read: ", new_chunk.bytes_read
+
+               elif (new_chunk.ID==OBJECT_MATERIAL):
+                       # print "Found an OBJECT_MATERIAL chunk"
+                       material_name=""
+                       material_name = read_string(file)
+                       new_chunk.bytes_read += len(material_name)+1 # remove 1 null character.
+
+                       #look up the material in all the materials
+                       material_found=0
+                       for mat in Material.Get():
+                               
+                               #found it, add it to the mesh
+                               if(mat.name==material_name):
+                                       if len(contextMesh.materials) >= 15:
+                                               print "\tCant assign more than 16 materials per mesh, keep going..."
+                                               break
+                                       else:
+                                               meshHasMat = 0
+                                               for myMat in contextMesh.materials:
+                                                       if myMat.name == mat.name:
+                                                               meshHasMat = 1
+                                               
+                                               if meshHasMat == 0:
+                                                       contextMesh.materials =  contextMesh.materials + [mat]
+                                                       material_found=1
+                                                       
+                                                       #figure out what material index this is for the mesh
+                                                       for mat_counter in xrange(len(contextMesh.materials)):
+                                                               if contextMesh.materials[mat_counter].name == material_name:
+                                                                       mat_index=mat_counter
+                                                                       #print "material index: ",mat_index
+                                                       
+                                               
+                                               break # get out of this for loop so we don't accidentally set material_found back to 0
+                               else:
+                                       material_found=0
+                                       # print "Not matching: ", mat.name, " and ", material_name
+                       #print contextMesh.materials
+                       if material_found == 1:
+                               contextMaterial = mat
+                               #read the number of faces using this material
+                               temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+                               data=struct.unpack("H", temp_data)
+                               new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+                               num_faces_using_mat=data[0]
+                               
+                               #list of faces using mat
+                               for face_counter in xrange(num_faces_using_mat):
+                                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+                                       new_chunk.bytes_read += STRUCT_SIZE_UNSIGNED_SHORT
+                                       data=struct.unpack("H", temp_data)
+                                       facemap = contextFaceMapping[data[0]]
+                                       if facemap != None: # Face map can be None when teh face has bad data.
+                                               face = contextMesh.faces[facemap]
+                                               face.mat = mat_index
+                                               
+                                               
+                                               mname = MATDICT[contextMaterial.name]
+                                               
+                                               try:
+                                                       img = TEXTURE_DICT[mname]
+                                               except:
+                                                       img = None
+                                               
+                                               if img:
+                                                       contextMesh.faceUV = 1
+                                                       #print 'Assigning image', img.name
+                                                       face.mode |= TEXMODE
+                                                       face.image = img
+                                               
+                       else:
+                               #read past the information about the material you couldn't find
+                               #print "Couldn't find material.  Reading past face material info"
+                               buffer_size=new_chunk.length-new_chunk.bytes_read
+                               binary_format=str(buffer_size)+"c"
+                               temp_data=file.read(struct.calcsize(binary_format))
+                               new_chunk.bytes_read+=buffer_size
+                       
+                       #print "object mat: bytes read: ", new_chunk.bytes_read
+
+               elif (new_chunk.ID == OBJECT_UV):
+                       # print "Found an OBJECT_UV chunk"
+                       temp_data=file.read(STRUCT_SIZE_UNSIGNED_SHORT)
+                       data=struct.unpack("H", temp_data)
+                       new_chunk.bytes_read+=2
+                       num_uv=data[0]
+                       def getuv():
+                               temp_data=file.read(STRUCT_SIZE_2FLOAT)
+                               new_chunk.bytes_read += STRUCT_SIZE_2FLOAT #2 float x 4 bytes each
+                               data=struct.unpack("2f", temp_data)
+                               return Vector(data[0], data[1])
+                               
+                       contextMeshUV = [ getuv() for i in xrange(num_uv) ]
+                       '''
+                       for counter in xrange(num_uv):
+                               temp_data=file.read(STRUCT_SIZE_2FLOAT)
+                               new_chunk.bytes_read += STRUCT_SIZE_2FLOAT #2 float x 4 bytes each
+                               data=struct.unpack("2f", temp_data)
+                               
+                               #insert the insert the UV coords in the vertex data
+                               contextMeshUV[counter].uvco = data
+                       '''
+               
+               elif (new_chunk.ID == OBJECT_TRANS_MATRIX):
+                       # print "Found an OBJECT_TRANS_MATRIX chunk"
+                       
+                       temp_data=file.read(STRUCT_SIZE_4x3MAT)
+                       data = list( struct.unpack("ffffffffffff", temp_data) )
+                       new_chunk.bytes_read += STRUCT_SIZE_4x3MAT 
+                       
+                       contextMatrix = Blender.Mathutils.Matrix(\
+                        data[:3] + [0],\
+                        data[3:6] + [0],\
+                        data[6:9] + [0],\
+                        data[9:] + [1])
+               
+               
+               
+               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"
+                       buffer_size=new_chunk.length-new_chunk.bytes_read
+                       binary_format=str(buffer_size)+"c"
+                       temp_data=file.read(struct.calcsize(binary_format))
+                       new_chunk.bytes_read+=buffer_size
+
+
+               #update the previous 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 contextMesh != None:
+               putContextMesh(contextMesh)
        
-               previous_chunk.bytes_read+=new_chunk.bytes_read
+       for ob in objectList:
+               ob.sel = 1
 
-#***********************************************
-# main entry point for loading 3ds files
-#***********************************************
-def load_3ds (filename):
-       current_chunk=chunk()
-       print "--------------------------------"
-       print 'Importing "%s"' % filename
-       time1 = Blender.sys.time()  #for timing purposes
-       file=open(filename,"rb")
-       new_object_list = []
+def load_3ds(filename):
+       print '\n\nImporting "%s"' % filename
+       
+       # 
+       for ob in Scene.GetCurrent().getChildren():
+               ob.sel = 0
+       time1 = Blender.sys.time()
        
        global FILENAME
        FILENAME=filename
+       current_chunk=chunk()
        
-       read_chunk(file, current_chunk)
+       file=open(filename,"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: ", filename
                file.close()
                return
-       
-       process_main_chunk(file, current_chunk, new_object_list)
+
+       process_next_chunk(file, filename, current_chunk)
        
        # Select all new objects.
-       for ob in new_object_list: ob.sel = 1
-       
        print 'finished importing: "%s" in %.4f sec.' % (filename, (Blender.sys.time()-time1))
        file.close()
 
-#***********************************************
-# MAIN
-#***********************************************
-def my_callback(filename):
-       load_3ds(filename)
 
-Blender.Window.FileSelector(my_callback, "Import 3DS", '*.3ds')
+
+if __name__  == '__main__':
+       Blender.Window.FileSelector(load_3ds, "Import 3DS", '*.3ds')
 
 # For testing compatibility
-'''
+
+"""
 TIME = Blender.sys.time()
 import os
-for _3ds in os.listdir('/3ds/'):
-       if _3ds.lower().endswith('3ds'):
-               print _3ds
-               newScn = Scene.New(_3ds)
-               newScn.makeCurrent()
-               my_callback('/3ds/' + _3ds)
-
-print "TOTAL TIME: ", Blender.sys.time() - TIME
-'''
+os.system('find /metavr/ -iname "*.3ds" > /tmp/temp3ds_list')
+file = open('/tmp/temp3ds_list', 'r')
+lines = file.readlines()[200:]
+file.close()           
+for i, _3ds in enumerate(lines):
+       _3ds= _3ds[:-1]
+       print "Importing", _3ds, i
+       _3ds_file = _3ds.split('/')[-1].split('\\')[-1]
+       newScn = Scene.New(_3ds_file)
+       newScn.makeCurrent()
+       my_callback(_3ds)
+
+print "TOTAL TIME: %.6f" % (Blender.sys.time() - TIME)
+"""
\ No newline at end of file