#!BPY

""" 

Name: '3D Studio'

Blender: 233

Group: 'Import'

Tip: 'Import from 3DS file format. (.3ds)'

"""

######################################################

# 3ds Importer

# By:  Bob Holcomb and Richard Lärkäng

# Date: 22 APR 04

# Ver: 0.7

######################################################

# This script imports a 3ds file and the materials

#  into blender for editing.  Hopefully

# this will make it into a future version as an import

# feature of the menu.  Loader is based on 3ds loader

# from www.gametutorials.com(Thanks DigiBen).

######################################################

######################################################

# Importing modules

######################################################

import Blender

from Blender import NMesh, Scene, Object, Material

from Blender.BGL import *

from Blender.Draw import *

from Blender.Window import *

from Blender.Image import *

from Blender.Material import *

import sys, struct, string, types

from types import *

import os

from os import path

######################################################

# Data Structures

######################################################

#Some of the chunks that we will see

#----- Primary Chunk, at the beginning of each file

PRIMARY=19789 #0x4D4D

#------ Main Chunks

OBJECTINFO=15677	#0x3D3D				// This gives the version of the mesh and is found right before the material and object information

VERSION=2			#0x0002				// This gives the version of the .3ds file

EDITKEYFRAME=45056	#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=40960		#0xA000				// This holds the material name

MATAMBIENT=40976	#0xA010

MATDIFFUSE=40992	#0xA020				// This holds the color of the object/material

MATSPECULAR=41008	#0xA030

MATMAP=41472		#0xA200				// This is a header for a new material

MATMAPFILE=41728	#0xA300				// This holds the file name of the texture

OBJECT_MESH=16640	#0x4100				// This lets us know that we are reading a new object

#------ sub defines of OBJECT_MESH

OBJECT_VERTICES=16656	#0x4110			// The objects vertices

OBJECT_FACES=16672		#0x4120			// The objects faces

OBJECT_MATERIAL=16688	#0x4130			// This is found if the object has a material, either texture map or color

OBJECT_UV=16704			#0x4140			// The UV texture coordinates

OBJECT_TRANS_MATRIX=16736	#0x4160		// The translation matrix of the object 54 bytes

#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="

	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):

	s=""

	index=0

	#print "reading a string"

	#read in the characters till we get a null character

	temp_data=file.read(struct.calcsize("c"))

	data=struct.unpack("c", temp_data)

	s=s+(data[0])

	#print "string: ",s

	while(ord(s[index])!=0):

		index+=1

		temp_data=file.read(struct.calcsize("c"))

		data=struct.unpack("c", temp_data)

		s=s+(data[0])

		#print "string: ",s

	#remove the null character from the string

	the_string=s[:-1]

	return str(the_string)

######################################################

# IMPORT

######################################################

def process_next_object_chunk(file, previous_chunk, mesh):

	new_chunk=chunk()

	temp_chunk=chunk()

	while (previous_chunk.bytes_read

		#read the next chunk

		read_chunk(file, new_chunk)

		if (new_chunk.ID==OBJECT_MESH):

			print "Found an OBJECT_MESH chunk"

			print "object_mesh: lenght: ", new_chunk.length

			process_next_object_chunk(file, new_chunk, mesh)

			print "object mesh: bytes read: ", new_chunk.bytes_read

		elif (new_chunk.ID==OBJECT_VERTICES):

			print "Found an OBJECT_VERTICES chunk"

			print "object_verts: lenght: ", new_chunk.length

			temp_data=file.read(struct.calcsize("H"))

			data=struct.unpack("H", temp_data)

			new_chunk.bytes_read+=2

			num_verts=data[0]

			print "number of verts: ", num_verts

			for counter in range (0,num_verts):

				temp_data=file.read(struct.calcsize("3f"))

				new_chunk.bytes_read+=12 #3 floats x 4 bytes each

				data=struct.unpack("3f", temp_data)

				v=NMesh.Vert(data[0],data[1],data[2])

				mesh.verts.append(v)

			print "object verts: bytes read: ", new_chunk.bytes_read

		elif (new_chunk.ID==OBJECT_FACES):

			print "Found an OBJECT_FACES chunk"

			print "object faces: lenght: ", new_chunk.length

			temp_data=file.read(struct.calcsize("H"))

			data=struct.unpack("H", temp_data)

			new_chunk.bytes_read+=2

			num_faces=data[0]

			print "number of faces: ", num_faces

			for counter in range(0,num_faces):

				temp_data=file.read(struct.calcsize("4H"))

				new_chunk.bytes_read+=8 #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()

				f.v.append(mesh.verts[data[0]])

				f.v.append(mesh.verts[data[1]])

				f.v.append(mesh.verts[data[2]])

				mesh.faces.append(f)

			print "object faces: bytes read: ", new_chunk.bytes_read

		elif (new_chunk.ID==OBJECT_MATERIAL):

			print "Found an OBJECT_MATERIAL chunk"

			print "object material: length: ", new_chunk.length

			material_name=""

			material_name=str(read_string(file))

			#plus one for the null character that gets removed

			new_chunk.bytes_read+=(len(material_name)+1)

			print "material_name: ", material_name

			#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(mesh.materials)>=15):

						result=Blender.Draw.PupMenu("Cannot assign more than 16 materials to a mesh: Continue?%t|OK")

						break;

					else:

						mesh.addMaterial(mat)

						material_found=1

						print "found material: ",mat.name

						#figure out what material index this is for the mesh

						for mat_counter in range(0,len(mesh.materials)):

							if mesh.materials[mat_counter].name==material_name:

								mat_index=mat_counter

								print "material index: ",mat_index

						#break out of this for loop so we don't accidentally set material_found back to 0

						break

				else:

					material_found=0

					#print "Not matching: ", mat.name, " and ", material_name

			if(material_found==1):

				#read the number of faces using this material

				temp_data=file.read(struct.calcsize("H"))

				data=struct.unpack("H", temp_data)

				new_chunk.bytes_read+=2

				num_faces_using_mat=data[0]

				print "number of faces using this material: ", num_faces_using_mat

				#list of faces using mat

				for face_counter in range(0,num_faces_using_mat):

					temp_data=file.read(struct.calcsize("H"))

					new_chunk.bytes_read+=2

					data=struct.unpack("H", temp_data)

					#print "face #: ", data[0]

					mesh.faces[data[0]].materialIndex=mat_index

			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"

			print "object uv: lenght: ", new_chunk.length

			temp_data=file.read(struct.calcsize("H"))

			data=struct.unpack("H", temp_data)

			new_chunk.bytes_read+=2

			num_uv=data[0]

			print "number of UV: ", num_uv

			for counter in range(0,num_uv):

				temp_data=file.read(struct.calcsize("2f"))

				new_chunk.bytes_read+=8 #2 float x 4 bytes each

				data=struct.unpack("2f", temp_data)

				#insert the insert the UV coords in the vertex data

				mesh.verts[counter].uvco[0]=data[0]

				mesh.verts[counter].uvco[1]=data[1]

			#turn on the sticky UV coords for this mesh

			mesh.hasVertexUV(1)

			print "object uv: bytes read: ", new_chunk.bytes_read

		else:

			print "Found some other Object chunk: ",hex(new_chunk.ID)

			print "object faces: length: ", new_chunk.length

			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 other: bytes read: ", new_chunk.bytes_read

		previous_chunk.bytes_read+=new_chunk.bytes_read

		print "Bytes left in this Object chunk: ", previous_chunk.length-previous_chunk.bytes_read

def process_next_material_chunk(file, previous_chunk, mat):

	new_chunk=chunk()

	temp_chunk=chunk()

	while (previous_chunk.bytes_read

		#read the next chunk

		read_chunk(file, new_chunk)

		if (new_chunk.ID==MATNAME):

			print "Found a MATNAME chunk"

			material_name=""

			material_name=str(read_string(file))

			#plus one for the null character that ended the string

			new_chunk.bytes_read+=(len(material_name)+1)

			print "material_name: ", material_name

			mat.setName(material_name)

			print "mat.name: ", mat.name

		elif (new_chunk.ID==MATAMBIENT):

			print "Found a MATAMBIENT chunk"

			read_chunk(file, temp_chunk)

			temp_data=file.read(struct.calcsize("3B"))

			data=struct.unpack("3B", temp_data)

			temp_chunk.bytes_read+=3

			r=data[0]

			g=data[1]

			b=data[2]

			mat.setMirCol(float(r)/255, float(g)/255, float(b)/255)

			new_chunk.bytes_read+=temp_chunk.bytes_read

		elif (new_chunk.ID==MATDIFFUSE):

			print "Found a MATDIFFUSE chunk"

			read_chunk(file, temp_chunk)

			temp_data=file.read(struct.calcsize("3B"))

			data=struct.unpack("3B", temp_data)

			temp_chunk.bytes_read+=3

			r=data[0]

			g=data[1]

			b=data[2]

			mat.setRGBCol(float(r)/255, float(g)/255, float(b)/255)

			new_chunk.bytes_read+=temp_chunk.bytes_read

		elif (new_chunk.ID==MATSPECULAR):

			print "Found a MATSPECULAR chunk"

			read_chunk(file, temp_chunk)

			temp_data=file.read(struct.calcsize("3B"))

			data=struct.unpack("3B", temp_data)

			temp_chunk.bytes_read+=3

			r=data[0]

			g=data[1]

			b=data[2]

			mat.setSpecCol(float(r)/255, float(g)/255, float(b)/255)

			new_chunk.bytes_read+=temp_chunk.bytes_read

		elif (new_chunk.ID==MATMAP):

			print "Found a MATMAP chunk"

			#recurse into this one

			process_next_material_chunk(file, new_chunk, mat)

		elif (new_chunk.ID==MATMAPFILE):

			print "Found a MATMAPFILE chunk"

			texture_name=""

			texture_name=str(read_string(file))

			#plus one for the null character that gets removed

			new_chunk.bytes_read+=(len(texture_name)+1)

		else:

			print "Found some other Material chunk: ",hex(new_chunk.ID)

			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

		previous_chunk.bytes_read+=new_chunk.bytes_read

		print "Bytes left in this Material chunk: ", previous_chunk.length-previous_chunk.bytes_read

def process_next_chunk(file, previous_chunk):

	#a spare chunk

	new_chunk=chunk()

	temp_chunk=chunk()

	#loop through all the data for this chunk (previous chunk) and see what it is

	while (previous_chunk.bytes_read

		#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"

			print "version: lenght: ", new_chunk.length

			#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 "Non-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"

			print "object info: lenght: ", new_chunk.length

			#recursively go through the rest of the file

			process_next_chunk(file, 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):

			print "found an OBJECT chunk"

			print "object length: ", new_chunk.length

			#make a mesh

			mesh=NMesh.New()

			mesh.name=str(read_string(file))

			print "mesh name: ", mesh.name

			#plus one for the null character that gets removed

			new_chunk.bytes_read+=(len(mesh.name)+1)

			process_next_object_chunk(file, new_chunk, mesh)

			#put the object into blender at the cursor location

			mesh_obj=NMesh.PutRaw(mesh)

			cursor_pos=Blender.Window.GetCursorPos()

			mesh_obj.setLocation(float(cursor_pos[0]),float(cursor_pos[1]),float(cursor_pos[2]))

		#is it a material chunk?

		elif (new_chunk.ID==MATERIAL):

			print "found a MATERIAL chunk"

			material=Material.New()

			process_next_material_chunk(file, new_chunk, material)

		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

def load_3ds (filename):

	current_chunk=chunk()

	file=open(filename,"rb")

	#here we go!

	print "reading the first chunk"

	read_chunk(file, current_chunk)

	if (current_chunk.ID!=PRIMARY):

		print "Fatal Error:  Not a valid 3ds file: ", filename

		Exit()

	process_next_chunk(file, current_chunk)

	file.close()

#***********************************************

# MAIN

#***********************************************

def my_callback(filename):

	load_3ds(filename)

Blender.Window.FileSelector(my_callback, "Import 3DS")