#!BPY

""" 
Name: 'Metasequoia Object (.mqo)...'
Blender: 237
Group: 'Import'
Tooltip: 'Import from MQO file format. (.mqo)'
"""

__author__ = ["Ry"]
__url__ = ("http://jyoken.net")
__version__ = "0.93"
__bpydoc__ = """\

mqo Importer

This script imports a mqo file and the materials into Blender for editing.

Changes:

"""

# Importing modules

import Blender, meshtools
from Blender import NMesh, Scene, Object, Material, Image, Texture

import sys, struct, string, math

import os
import re

RE_FLOAT = "[-+]?(\d+(\.\d*)?|\d*\.\d+)([eE][-+]?\d+)?"

RESIZE = 0.01

nmaterials=0
materials=[]
uniqueInt=0

texturedict={}


######################################################
# Helper functions
######################################################

def read_split(file):
	return file.readline().split(" ")

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():
				print "uniqueName:",newName
				return newName
			else:
				newName = '%s.%d' % (name, uniqueInt)
				uniqueInt +=1
		except ValueError:
			if newName not in NMesh.GetNames():
				print "uniqueName:",newName
				return newName
			else:
				newName = '%s.%d' % (name, uniqueInt)
				uniqueInt +=1


def add_texture_to_material(image, texture, material, mapto):
	if mapto=="DIFFUSE":
		map=Texture.MapTo.COL
	elif mapto=="SPECULAR":
		map=Texture.MapTo.SPEC
	elif mapto=="OPACITY":
		map=Texture.MapTo.ALPHA
		flg=material.getMode()|Material.Modes['RAYTRANSP']
		material.setMode(flg)
	elif mapto=="BUMP":
		map=Texture.MapTo.NOR
	else:
		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.UV,map)
			material.getTextures()[index].blendmode=Texture.BlendModes.MULTIPLY
			return
		else:
			index+=1
		if index>10:
			print "\tError: Cannot add diffuse map.  Too many textures"

##
## MQOローダ(仮)
##
##

def load_header(file):
	header=file.readline()
	format=file.readline()

	header=header.strip("\r\n")
	format=format.strip("\r\n")

	if(header!="Metasequoia Document"):
		print "\tError: It is not mqo file."
		print "header is :"+header+"*"
		return -1
	if(format!="Format Text Ver 1.0"):
		print "\tError: This format is not supported."
		return -1
	print "support format"
	return 0

# マテリアルを解析

def lex_material(content,name):
	global materials

	new_material=Blender.Material.New()
	new_material.setName(name)
	
	for i in range(0,len(content)):
		k=content[i].split("(")
		print k[0]+"*"
		
		if(k[0]=="shader"):
			shader=int(re.split( " ",content[i].rstrip("\)")[7:] )[0])
			
			#0 classic
			#1 constant
			#2 lambert
			#3 phong
			#4 blinn
			if shader==3 :
				new_material.setSpecShader(Material.Shaders.SPEC_PHONG)
			elif shader==4:
				new_material.setSpecShader(Material.Shaders.SPEC_BLINN)
			
			print "shader: ", shader
		elif(k[0]=="col"):
			col=[float(c) for c in re.split( " ",content[i].rstrip("\)")[4:] )]
			new_material.setRGBCol(col[:3])
			new_material.setAlpha(col[3])
			if col[3]<1:
				flg=new_material.getMode()|Material.Modes['RAYTRANSP']
				new_material.setMode(flg)
			print "col: ", col
		elif(k[0]=="dif"):
			dif=float(re.split( " ",content[i].rstrip("\)")[4:] )[0])
			new_material.setRef(dif)
			print "dif: ", dif
		elif(k[0]=="amb"):
			amb=float(re.split( " ",content[i].rstrip("\)")[4:] )[0])
			#new_material.mirCol=[amb,amb,amb]
			new_material.setAmb(amb)
			print "amb: ", amb
		elif(k[0]=="emi"):
			emi=float(re.split( " ",content[i].rstrip("\)")[4:] )[0])
			new_material.setEmit(emi)
			print "emi: ", emi
		elif(k[0]=="spc"):
			spc=float(re.split( " ",content[i].rstrip("\)")[4:] )[0])
			#new_material.specCol=[spc,spc,spc]
			new_material.setSpec(spc)
			print "spc: ", spc
		elif(k[0]=="power"):
			pw=float(re.split( " ",content[i].rstrip("\)")[6:] )[0])
			new_material.setHardness( int(pw*2.5+1) )
			print "power: ", pw
		elif(k[0]=="tex"):
			tex=re.split( " ",content[i].rstrip("\)")[4:] )[0].strip('"')
			print "tex: ",tex
			new_texture=Blender.Texture.New('Diffuse')
			new_texture.setType('Image')
			
			try:
				img = Image.Load(tex)
				texturedict[new_material.name]=img
			except IOError:
				fname = os.path.join( os.path.dirname(FILENAME), tex)
				try:
					img = Image.Load(fname)
					texturedict[new_material.name]=img
				except IOError:
					print "\tERROR: failed to load image ",tex
					texturedict[new_material.name] = None # Dummy
					img=Blender.Image.New(fname,1,1,24) #blank image
			#add the map to the material in the right channel
			add_texture_to_material(img, new_texture, new_material, "DIFFUSE")
			
		elif(k[0]=="aplane"):
			tex=re.split( " ",content[i].rstrip("\)")[7:] )[0].strip('"')
			print "aplane: ",tex
			new_texture=Blender.Texture.New('Opacity')
			new_texture.setType('Image')
			
			try:
				img = Image.Load(tex)
				texturedict[new_material.name]=img
			except IOError:
				fname = os.path.join( os.path.dirname(FILENAME), tex)
				try:
					img = Image.Load(fname)
					texturedict[new_material.name]=img
				except IOError:
					print "\tERROR: failed to load image ",tex
					texturedict[new_material.name] = None # Dummy
					img=Blender.Image.New(fname,1,1,24) #blank image
			#add the map to the material in the right channel
			add_texture_to_material(img, new_texture, new_material, "OPACITY")

	materials.append(new_material)

# 頂点を解析

def lex_vertex(file,nvertex,mesh):
	global nmaterials

	for i in range(nvertex):
		r=file.readline()
		vv=[float(x)*RESIZE for x in r.split(" ")]
		v=NMesh.Vert(vv[0],-vv[2],vv[1])
		
		for j in range(nmaterials):
			mesh[j].verts.append(v)


## 三角形の面
def lex_face_sub3(content,mesh):
	m=0
	uv=[]
	for i in range(len(content)):
		k=content[i].split("(")
		if(k[0]=="V"):
			vt=[int(x) for x in re.split( " ",content[i].rstrip("\)")[2:] )]
			vt.reverse()
		elif(k[0]=="UV"):
			uvtmp=[float(x) for x in re.split( " ",content[i].rstrip("\)")[3:] )]
			subzero=0.
			for i in range(len(uvtmp)):
				if(math.floor(uvtmp[i])<subzero):
					print "uv is subzero"
					subzero=math.floor(uvtmp[i])
			if(subzero!=0.):
				for i in range(len(uvtmp)):
					uvtmp[i]-=subzero

			uv=[ (uvtmp[j*2],1-uvtmp[j*2+1]) for j in range(len(uvtmp)/2)]
			uv.reverse()
		elif(k[0]=="M"):
			m=int(content[i].rstrip("\)")[2:])
	f=NMesh.Face()
	for i in vt: f.v.append(mesh[m].verts[i])
	for i in uv: f.uv.append(i)
	f.smooth=True
	mesh[m].faces.append(f)


## 四角形の面
def lex_face_sub4(content,mesh):
	order1=[0,1,2]
	order2=[2,3,0]
	m=0
	for i in range(len(content)):
		k=content[i].split("(")
		if(k[0]=="V"):
			vttmp=[int(x) for x in re.split( " ",content[i].rstrip("\)")[2:] )]
			vt1=[vttmp[j] for j in order1]
			vt2=[vttmp[j] for j in order2]
		elif(k[0]=="UV"):
			uvtmp=[float(x) for x in re.split( " ",content[i].rstrip("\)")[3:] )]
			for i in range(len(uvtmp)):
				if(uvtmp[i]<0):
					print "uv under 0 ("+uvtmp[i]
					uvtmp[i]-=int(uvtmp[i])
					print "uv adjust ("+uvtmp[i]

			uv1=[ (uvtmp[j*2],uvtmp[j*2+1]) for j in order1]
			uv2=[ (uvtmp[j*2],uvtmp[j*2+1]) for j in order2]
		elif(k[0]=="M"):
			m=int(content[i].rstrip("\)")[2:])
		
		
		
	f=NMesh.Face(vt1)
	f.uv=uv1
	mesh[m].faces.append(f)
	f=NMesh.Face(vt2)
	f.uv=uv2
	mesh[m].faces.append(f)

#################################
# 面を解析

def lex_face(file,nface,mesh):
	for i in range(nface):
		r=file.readline()
		nv=int(re.findall('\d',r)[0])
		content=re.findall('\w+\([\w\.\- ]+\)',r)
		if nv==3 :
			lex_face_sub3(content,mesh)
		elif nv==4 :
			lex_face_sub3(content,mesh)


#################################
# Object を解析する

def lex_object(file,name):
	global nmaterials
	global materials
	
	#print "GetName: ",obj_name
	#obj_name=name
	if nmaterials==0:
		#obj_name=[getUniqueName(name)]
		#obj_name=[meshtools.versioned_name(name)]
		new_mesh=[Blender.NMesh.New("Mesh")]
		m=1
	else:
		#obj_name=[]
		new_mesh=[]
		for i in range(nmaterials):
			#obj_name.append( getUniqueName(name) )
			#obj_name.append( meshtools.versioned_name(name) )
			new_mesh.append(Blender.NMesh.New("Mesh") )
		m=nmaterials
	
	#print obj_name
	
	while 1:
		r=file.readline()
		content=re.findall('\w+ [\d\+-\. ]+',r)
		print content
		k=content[0].split(' ')
		
		if(k[0]=="vertex"):
			nvertex=int(k[1])
			print "vertex: ", nvertex
			lex_vertex(file,nvertex,new_mesh)
			r=file.readline()
		elif(k[0]=="face"):
			nface=int(k[1])
			print "face: ", nface
			lex_face(file,nface,new_mesh)
			r=file.readline()
			
			if nmaterials==0:
				obj_name=getUniqueName(name)
				print obj_name
				meshtools.create_mesh(new_mesh[0].verts, new_mesh[0].faces, obj_name)
			else:
				for i in range(m):
					if new_mesh[i].faces!=[] :
						#new_mesh[i].addMaterial(materials[i])
						#meshtools.create_mesh(new_mesh[0].verts, new_mesh[i].faces, obj_name[i],materials[i])
						#mesh = Blender.NMesh.GetRaw()
						#meshtools.append_verts(mesh, new_mesh[0].verts, [])
						#meshtools.append_faces(mesh, new_mesh[i].faces, [], [])
						
						#mesh = Blender.NMesh.GetRaw()
						
						new_mesh[i].mode&=~Blender.Mesh.Modes["TWOSIDED"] #片面のみ描画
						new_mesh[i].addMaterial(materials[i])
						obj_name=getUniqueName(name)
						print obj_name
						Blender.NMesh.PutRaw(new_mesh[i], obj_name, 1)	# Name the Mesh
						Blender.Object.GetSelected()[0].name=obj_name		# Name the Object
						Blender.Redraw()
						
						##########################################
			
			
			return
		elif(k[0]=="color"):
			print "color: ", k[1:]

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

def load_all(file):
	global nmaterials
	
	target=""
	ex=1
	while ex:
		ex=0
		header=["\n"]
		footer=["\n"]
		
		while header!=[""]:
			header=read_split(file)
			print header[0]
			if(header[0]=="Object"):
				ex=1
				target="object"
				name=header[1].strip('"')
				print "ObjectName: ",name
				lex_object(file,name)
				break
			if(header[0]=="Material"):
				ex=1
				target="material"
				nmaterials=int(header[1])
				print "Materials: ",nmaterials
				for i in range(nmaterials):
					r=file.readline()
					name=re.findall('".+" ',r)[0].rstrip(" ").strip('"')
					content=re.findall('\w+\([\w\.\"\/ ]+\)',r)
					print i," : ",name
					lex_material(content,name)
				break
			elif(header[0]=="Scene"):
				ex=1
				
				break
			elif(header[0].strip("\r\n")=="Eof"):
				print "end of file"
				return
		
		while footer!=[""]:
			footer=read_split(file)
			if(footer[0].strip("\r\n")=="}"):
				break
		
		print "end of "+target

#***********************************************
# main entry point
#***********************************************

def load_mqo (filename):
	global materials
	print "--------------------------------"
	print 'Importing "%s"' % filename
	time1 = Blender.sys.time()  #for timing purposes
	file=open(filename,"rt")
	new_object_list = []
	
	global FILENAME
	FILENAME=filename
	
	if load_header(file):
		file.close()
		return
	
	load_all(file)
	
	
	
	
	Blender.Window.DrawProgressBar(1.0, '')
	
	print 'finished importing: "%s" in %.4f sec.' % (filename, (Blender.sys.time()-time1))
	file.close()

#***********************************************
# MAIN
#***********************************************

def my_callback(filename):
	load_mqo(filename)

Blender.Window.FileSelector(my_callback, "Import MQO", '*.mqo')