#!BPY

"""
Name: 'Unreal Static Mesh'
Blender: 232
Group: 'Export'
Tooltip: 'Export selected mesh, using ASE File-Format (*.ase)'
"""

# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~ Unreal SM-Export V1.0 - 2004 by Doc Holiday ~
# ~ ------------------------------------------- ~
# ~  testet with Blender 2.32 and UnrealED 3.0  ~
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~ press Alt+P to start                        ~
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
# ~ Please don't scroll down, very chaotic Code ~ :)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

import Blender
from Blender import sys as SYS
from Blender.BGL import *
from Blender.Draw import *
from math import *

# ========================================================================
# =====================         GLOBAL STUFF        ======================
# ========================================================================
wannaPath = 0
Ysep = SYS.sep
Ypath = SYS.dirname(SYS.progname)+Ysep
Bver = Blender.Get("version")

# global Variables
# ~~~~~~~~~~~~~~~~
Exit = Blender.Draw.Create(0)
GlobSet = Blender.Draw.Create(0)
try: iniF = open(Ypath+"USM_Ex.ini","r")
except:
	Path = SYS.dirname(Blender.Get('filename'))+Ysep
	scale = Blender.Draw.Create(1)
	useDefMat = Blender.Draw.Create(1)
	ExpoLog = Blender.Draw.Create(0)
else:
	Path = iniF.readline()[:-1]
	scale = Blender.Draw.Create(int(iniF.readline()[:-1]))
	useDefMat = Blender.Draw.Create(int(iniF.readline()[:-1]))
	ExpoLog = Blender.Draw.Create(int(iniF.readline()[:-1]))
	iniF.close()

# some Colors
# ~~~~~~~~~~~
white = (1.0,1.0,1.0)
black = (0.0,0.0,0.0)
blue = (.73,.73,.76)
dgray = (.4,.4,.4)
red = (.7,.0,.3)
lred = (.9,.3,.6)
green = (.70,.75,.70)
sand = (1.0,.9,.7)
back = (.7,.7,.7)
gold = (.83,.75,.49)
steel = (.61,.61,.66)
silver_blue = (.73,.73,.76)

def WinSize():
	size=Buffer(GL_FLOAT, 4)
	glGetFloatv(GL_SCISSOR_BOX, size)
	return size.list

# Global Dimensions & Color
# ~~~~~~~~~~~~~~~~~~~~~~~~~
H_Col = silver_blue # -------------------------------------------- Global Color
Border = (H_Col[0]-.2,H_Col[1]-.2,H_Col[2]-.2)
Glanz = (H_Col[0]+.2,H_Col[1]+.2,H_Col[2]+.2)
GH = 227
GB = 340
# ~~~~~~~~~~~~~~~~~~~~~~~~~
oWS = WinSize()
#print oWS
Bord_L = 10
Bord_R = Bord_L+GB
Bord_M = (Bord_R-Bord_L)/2.0
Boden = 10
Top = Boden+GH

Export = 0
CurrOb = None
ObInfo = ["None","--","--","--","--","--","--","--","--","--","--"]

# ========================================================================
# =======================         OTHER STUFF        =====================
# ========================================================================

def saveINI():
	iniF = open(Ypath+"USM_Ex.ini","w")
	iniF.write(Path+"\n")
	iniF.write(str(scale.val)+"\n")
	iniF.write(str(useDefMat.val)+"\n")
	iniF.write(str(ExpoLog.val)+"\n")
	iniF.close()

LogFile = None
def pLog(s):
	global LogFile
	if ExpoLog.val == 1: print s
	elif ExpoLog.val == 2:
		if not LogFile: LogFile = open(Path+ObInfo[0]+"_Log.txt","w")
		LogFile.write(s+"\n")
		if s.count("Have a nice Day! :)"):
			LogFile.close()
			LogFile = None

def Fileback(n):
	global Path
	Path = SYS.dirname(n)+Ysep

def unpack(ser):
	CodeST = "...{}[]~|<>!%&?*+-;:="
	Result = ""
	for po in range(len(ser)):
		st = ser[po]
		if st in CodeST:
			Result += ser[po+1]*(CodeST.index(st)-1)
			po += 1
		else:
			Result += st
	Result = Result.replace("Y","00000000")
	return Result.replace("X","FFFFFFFF")

def HeadText(t):
	apply(glColor3d,dgray)
	glRasterPos2i(Bord_L+79,Top-18)
	Text(t)
	glRasterPos2i(Bord_R-133,Top-17)
	Text("(2004 by Doc Holiday)")
	apply(glColor3d,white)
	glRasterPos2i(Bord_L+78,Top-17)
	Text(t)

def examineOb():
	global CurrOb, ObInfo, TexList, Mesh, smooby
	ObList = Blender.Object.GetSelected()

	if ObList: CurrOb = ObList[0]
	else: CurrOb = None
	ObInfo = ["None","--","--","--","--","--","--","--","--","--","--"]
	if CurrOb:
		ObInfo[0] = CurrOb.getName()
		Mesh = CurrOb.getData()
		if not hasattr(Mesh,"verts") or not Mesh.verts: ObInfo[4], ObInfo[10] = "No Mesh","INVALID"
		else:
			ObInfo[4] = len(Mesh.verts)
			ObInfo[3] = ObInfo[5] = ObInfo[6] = ObInfo[7] = ObInfo[9] = smfa = smooby = 0
			ObInfo[2] = "No"
			TexList = []
			EdgeList = []
			LostVerts = range(len(Mesh.verts))

			ObInfo[10] = "VALID"
			for f in Mesh.faces:
				# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Check smooth Faces
				if f.smooth: smfa = 1

				# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Check Faces
				lfa = len(f.v)
				if lfa == 3: ObInfo[5] += 1
				elif lfa == 4:
					ObInfo[6] += 1
				else:
					ObInfo[7] += 1
					EdgeList.append(f)

				# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Check Vertex Color
				if lfa >= 3 and ObInfo[2] != "Yes":
					for co in f.col:
						if co.r + co.g + co.b != 765:
							ObInfo[2] = "Yes"
							break

				# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Check Textures
				if lfa >= 3:
					ftex = f.image
					if ftex and ObInfo[3] >= 0:
						if ftex not in TexList:
							ObInfo[3] += 1
							TexList.append(ftex)
					else: ObInfo[3] = -1

				# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ List lost Verts
				for ve in f.v:
					if ve.index in LostVerts: LostVerts.remove(ve.index)

			if LostVerts: ObInfo[8], ObInfo[10] = str(len(LostVerts))+" - INVALID","INVALID"
			else: ObInfo[8] = "No"
			if ObInfo[3] <= 0: ObInfo[3] = ObInfo[10] = "INVALID"
			if ObInfo[6]: ObInfo[6],ObInfo[10] = str(ObInfo[6])+" - INVALID","INVALID"
			else: ObInfo[6] = "No"
			if ObInfo[7]: ObInfo[7], ObInfo[10] = str(ObInfo[7])+" - INVALID","INVALID"
			else: ObInfo[7] = "No"

			ObInfo[9] = len(filter(lambda n: n.name.lower().count("smooth."),Mesh.materials))
			if not ObInfo[9]:
				ObInfo[9] = smfa
				smooby = 1 # --------- smooth by Faces
			else:
				smooby = 2 # --------- smooth by Material
			if not ObInfo[9]: ObInfo[9] = "nothing smooth"
			if Mesh.materials and not useDefMat.val: ObInfo[1] = Mesh.materials[0].name
			else: ObInfo[1] = "use default"

# ========================================================================
# =====================         GRAPHIC STUFF        =====================
# ========================================================================

# (PosX, PosY, Breit, Hoch, Woelbung, Farbe, Spezial, Spezial invers)
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
def Rund(px,py,breit,hoch,flat,col,spec,rev):
	cC = 0
	for cl in range(hoch):
		cC = -cos(cl/float(hoch)*pi)*flat/100
		nC = (col[0]+cC,col[1]+cC,col[2]+cC)
		if not spec:
			glBegin(GL_LINES)
			apply(glColor3d,nC)
			glVertex2i(px,py+cl)
			glVertex2i(px+breit,py+cl)
			glEnd()
		else:
			dC = (nC[0]-.2,nC[1]-.2,nC[2]-.2)
			bC = (nC[0]-.4,nC[1]-.4,nC[2]-.4)
			gC = (nC[0]+.2,nC[1]+.2,nC[2]+.2)

			if rev: cLi = (nC,bC,dC)
			else: cLi = (dC,gC,nC)
			
			glShadeModel(GL_SMOOTH)
			glBegin(GL_LINE_STRIP)

			apply(glColor3d,cLi[0])	
			glVertex2i(px,py+cl)
			glVertex2i(px+spec-2+cl,py+cl)

			apply(glColor3d,cLi[1])
			glVertex2i(px+spec-1+cl,py+cl)

			apply(glColor3d,cLi[2])
			glVertex2i(px+spec+cl,py+cl)
			glVertex2i(px+breit,py+cl)

			glEnd()
			glShadeModel(GL_FLAT)

def Flach(px,py,breit,hoch,flat,col):
	flt =flat/100.0
	glShadeModel(GL_SMOOTH)
	glBegin(GL_QUADS)

	glColor3d(col[0]-flt,col[1]-flt,col[2]-flt)	
	glVertex2i(px,py)
	glVertex2i(px+breit,py)

	glColor3d(col[0]+flt,col[1]+flt,col[2]+flt)
	glVertex2i(px+breit,py+hoch)
	glVertex2i(px,py+hoch)


	glEnd()
	glShadeModel(GL_FLAT)

def Dot(px,py,flat,col):
	DotList = ((-.05,-.1,-.1),(.05,.0,-.1),(.1,.05,-.05))
	glBegin(GL_POINTS)
	for ze in range(3):
		for sp in range(3):
			cC = DotList[ze][sp]*flat
			apply(glColor3d,map(lambda nc: nc+cC,col))
			glVertex2i(px+sp,py+ze)
	glEnd()

def Logo(px,py):
	LPAL = {"0":(0.66, 0.71, 0.72), "1":(0.83, 0.87, 0.87), "2":(0.35, 0.38, 0.39), "3":(0.47, 0.52, 0.56), "4":(0.41, 0.47, 0.47), "5":(0.53, 0.6, 0.61), "6":(0.01, 0.02, 0.02), "7":(0.07, 0.09, 0.09), "8":(0.05, 0.06, 0.06), "9":(0.14, 0.16, 0.16), "A":(0.11, 0.13, 0.13), "B":(0.17, 0.2, 0.2), "C":(0.27, 0.3, 0.3), "D":(0.03, 0.04, 0.04), "E":(0.22, 0.24, 0.24), "F":(0.0, 0.0, 0.0)}
	APAL = {"0":1.0, "1":.98, "2":.95, "3":.9, "4":.82, "5":.72, "6":.56, "7":.44, "8":.31, "9":.22, "A":.13, "B":.08, "C":.05, "D":.03, "E":.1, "F":.0}
	LMAP = unpack("=X{FD668866~X}F6B224424CEE9D]X]FDE44CECEE]C42E7[X{F68}FD22}9AA7A{7889B9BC2ED}X~F8C6{FB39D8}787{8[D877BE2C96}XFFA248{FC2{879BB7787DD8779EB7}BC2CA}X72C9FF64B7A77{AEE{8AA9C24229F6D889ECE6{X[F6C2EFF63C|A79B99CC23{54CB6D8DA9BEB7{X}FBC26FFE27A7AA9AA79CE22433535502CED6BCC22BBA6{XF724EFFD49{A7BB9ABCC3535433[52EB9223442CE96XX~FD24CAFFCEB9A979B9C44305{3]5452992342433CEBDXX]FC24BDFF37A{9A9BE31105053~5455{453443502CBDXX}F8442ADF928AA99AABEBC1053305{3}103}53354533CCB8XX{FE5227FF2BAA9BB9CCBCA5035355422C23{155{35054{13BBDXXFF502C{F3B9BEBBEB2CE950234055CE99792110{3454223015BB6XX7102E{F4BEB{E9B92EB052C2544EBB99BA901434355BFF6B15B9XXC154C{F2CC}EBBEBEB05C2}49BB99B9A50343{5B88DFD55E9X~F20542{F3}CEBEEBEEB00C{424BB9A}93143}5B886D6F24C7X]F4054C{F4C2}C{B{E05243424B99A{9A51355055E9E96DDF93CX]F5134C{F4EC2CC2C{ECE05233244B9BA{9A51350053E79E9{DF959X[F015CE{F3EC2C2C2EC{E5043}4EB[9A31500{5EAA7E8D8DF32DX}F{1CB{F34B4{2CC2CCB00{2423{B9A99A50}535EA989AD8DDB0EFF76XC415E{F25BE4{2CC2CE50C24224BA9AA9B95135}3E}A78}D52FFAAXFFC12{FB0C9224}24210EC33C39A{9B9931344544CA9A7878D86257FD3DXFF30DFF715BE334422CC00C25343B9B9ECCE01422334E{A878878D90BFF09XFFD0A{F014BC334224C00330055EABEBEEB0034C543CA99A7A788D80CFF549DXF9E{FC102EC4424220151{03E9E99EBA51535545C{B{A7{8D44FFC0CCEXF7{FD01029C2{4201101005EBE99BBA51005055CBEEA7A7877842FFA1442X]FC112CBE23420010{15EBEBABBA511[0CBEB98A787A822FFD1032X]F65112B9BE2C01010015EBEB9{B51011015CBECCEBAA9B722FFA100CX~FA01042CE9C30110105EBC{BE95[100C9CEBBC9A9B72CFFB1052XXC{152B92511{015EECEE{B01010015CBCCB9BB9BBACCFFC1053XXF5{1}010010100E{CE{B010100502ECECB9BBEEA47FFC100BXXF80}10}101015CCECC{E51100505CECBCB99}B36FF41156XXFFE0110~10102E{CECC{1}05{CEBEBEEBEE5{F010EXX}FC<10055322C2423501105002ECE2C22CCB32FF8100DXX[FC{1010110543342{450320110104BC[2{C07FF213EXX~FC}10110545334433542440{1032BC{24CC43{F504{XFC0{1{02355]3433425{103BE2442CC0AFF9508{XFFB0{153C355{3{53344343{104BB242C53FF640B{X}FA00115220553530532334432011049E2243DFFB0C{X]F630013E305535{35544334233015EC238FFA3C}XF90014E2{345535]3}24{538FFA5E}X}FE5054335005035{3533442C4058FFA47}X~FE3033~5353433{433C6F6A9[X{F92|5~3549A6FFD6[X~FAC{53553442BA866]X~FBEC2{CEE8[F6XX}F")
	LALPHA = unpack("XX{FEEDCCBB~ABBCCDDE[XFFEE{FEEDBBA{9]8}9AABCDEE}X[FE{D{EDBA99{8>78899AABCDE}XFEDCBBCDDCB988654433{4566[78899ABCDE{X]FEDB{ABCCA852Y[0256[7889ABCEE{X{FEDB879ABB951YY00256[789ABDE{XFEDA6489AB72YY~0356{7889BCEEXX~FE83279AB6{Y{0256{789ABDEXX[FE920689A5{Y]046{789ABDEXX{FEB40589A4}Y15}78ABDEXXFFE5037897}Y{046{789BDEXXE80057892}Y}036{789BDEX~FB2046896}Y]036{789BDEX]F50056893}Y~026{78ABDX[FA1006788[Y026{78ABEX}F7{06786[Y0026{78ACEX{F50017784[Y{0367789ADEXFA{037784[Y}04{789BDXF6{037784[Y[05{78ACEX5{037784[Y[0166789BDE~F3{037784[Y]03{78ABD{E}F1{047784[Y~05{79A{CDE{F}048784[Y~026778ABBABDEFF}049885]Y4{79AA9ABDEF65104A996]Y26766AA99ABDEFF702BA97]Y067718A9889AC{F50ABA9]Y057725A98789B{FB39DCC2]Y47740488778A}F97FEE7]Y1776{05778A[FA{FC3[Y~02{7{03778AXFF7[Y~03778{03778AXFFD4[Y]04{7{03778AX{FA1[Y[04787{03779AX}F7[Y[05786{03789BX[F5[Y}06786{0578ACX[FB3[Y{07785{0689BDX]F8[Y003789400488ACEX~F7[Y04788100689BDXXF7[Y679500489ADEXXFF7}Y]0378810279ACEXX}F71}Y}058950069ACEXX]F81}Y0018970069ABD{X93}Y17993059ABDE{XFA5{Y]0179A6049ACDE{X}F83{Y{037AB605ABCDE{X]FD73{Y49AB637CCDE}XFFD73YY}016ABB67BDDE}X~F86331Y[0478ADE9C[X~F9632}13344789BDDE]X[F977}677ADD}EXX}F")

	glEnable(GL_BLEND)
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)

	glBegin(GL_POINTS)
	ml = -1
	for my in range(50):
		for mx in range(70):
			ml +=1
			col = LPAL[LMAP[ml]]
			glColor4f(col[0],col[1],col[2],APAL[LALPHA[ml]])
			glVertex2i(px+mx,py+my)
	glEnd()
	glDisable(GL_BLEND)
	LMAP = LALPHA = None

def BorderText(x,y,l,t,h=17):
	apply(glColor3d,Border)
	glRecti(x,y,x+l,y+h)
	apply(glColor3d,H_Col)
	glRecti(x+1,y+1,x+l-1,y+h-1)
	if t == "pfl":
		apply(glColor3d,Glanz)
		glBegin(GL_LINE_LOOP)
		map(lambda vi: apply(glVertex2i,vi),((x+2,y+9),(x+7,y+h-3),(x+7,y+4)))
		glEnd()
	elif t == "pfr":
		apply(glColor3d,Glanz)
		glBegin(GL_LINE_LOOP)
		map(lambda vi: apply(glVertex2i,vi),((x+l-3,y+9),(x+l-8,y+h-3),(x+l-8,y+4)))
		glEnd()
	else:
		apply(glColor3d,dgray)
		glRasterPos2i(x+4,y+5)
		Text(t)

def G_Box(x,y,xe,ye,s=0,t=""):
	glShadeModel(GL_SMOOTH)
	glBegin(GL_LINE_LOOP)
	for i in ((x,ye,0),(x,y+(ye-y)/2,1),(x,y,0),(xe,y,0),(xe,y+(ye-y)/2,1),(xe,ye,0)):
		if i[2]: apply(glColor3d,Glanz)
		else: apply(glColor3d,Border)
		glVertex2i(i[0],i[1])
	glEnd()
	if t:
		glEnable(GL_BLEND)
		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
		glBegin(GL_QUADS)
		apply(glColor3d,Border)
		glVertex2i(xe,ye)
		glVertex2i(x+1,ye)
		apply(glColor4d,(Border[0],Border[1],Border[2],0))
		glVertex2i(x+1,ye-12)
		glVertex2i(xe,ye-12)
		glEnd()
		glDisable(GL_BLEND)
		BorderText(x+5,ye-12,s,t)
	glShadeModel(GL_FLAT)

def WinShad():
	c1, c0 = (0,0,0,0.3),(0,0,0,0)
	glShadeModel(GL_SMOOTH)
	glEnable(GL_BLEND)
	glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA)
	glBegin(GL_QUAD_STRIP)
	apply(glColor4f,c1)
	glVertex2i(Bord_L+4,Boden-1)
	apply(glColor4f,c0)
	glVertex2i(Bord_L+4,Boden-5)
	apply(glColor4f,c1)
	glVertex2i(Bord_R,Boden-1)
	apply(glColor4f,c0)
	glVertex2i(Bord_R+4,Boden-5)
	apply(glColor4f,c1)
	glVertex2i(Bord_R,Top-4)
	apply(glColor4f,c0)
	glVertex2i(Bord_R+4,Top-4)
	glEnd()
	glDisable(GL_BLEND)
	glShadeModel(GL_FLAT)

# ========================================================================
# =======================        SOLIDS        ===========================
# ========================================================================

glNewList(1,GL_COMPILE) # ---------------------- Dots
Dot(0,0,2,H_Col)
glEndList()

glNewList(2,GL_COMPILE)

# Background Color
# ~~~~~~~~~~~~~~~~
glClearColor(.7,.7,.7,0.0)
glClear(GL_COLOR_BUFFER_BIT)

# Main Window
# ~~~~~~~~~~~
HB = (25,40)
Flach(Bord_L,Boden+HB[1],GB,GH-HB[0]-HB[1],10,H_Col)
Rund(Bord_L,Boden,GB,HB[1],20,H_Col,210,1)			# rund unten
Rund(Bord_L,Boden+GH-HB[0],GB,HB[0],20,H_Col,175,0)	# rund oben
Rund(Bord_L+15,Boden+10,-1,HB[1]-20,-15,Glanz,185,1)# rund innen

for Dotsp in range(Boden+5+HB[1],Top-HB[0]-5,10):
	glTranslated(Bord_L+5,Dotsp,0)
	glCallList(1)
	glLoadIdentity()
	glTranslated(Bord_R-8,Dotsp,0)
	glCallList(1)
	glLoadIdentity()

Logo(Bord_L+5,Top-35)
HeadText("SM-Export V1.0")

G_Box(Bord_L+15,Top-HB[0]-112,Bord_R-15,Top-HB[0]-18,s=92,t="Current Object")
G_Box(Bord_L+15,Boden+HB[1]+30,Bord_R-35,Boden+HB[1]+45)
apply(glColor3d,Border)
for tx in range(2):
	for ty in range(5):
		glRasterPos2f((Bord_L+20,Bord_M+14)[tx],Top-HB[0]-(45,60,75,90,105)[ty])
		Text(("Name:","Material:","V-Color:","Textures:","Vertices:","Triangles:","Quads:","Edges:","lost Verts:","SmoothGr:")[ty+tx*5])
WinShad()
glEndList()

# ========================================================================
# ==========================         Execute        ======================
# ========================================================================
def ExitProg():
	saveINI()
	glDeleteLists(1,2)
	Blender.Draw.Exit()

def ReFresh():
	global InsDrw
	InsDrw = 1
	Redraw()

def saveMat(Nam,spez,spc,subMat):
	pLog(">> writing Material: %s ..." % Nam)
	File.write("%s*MATERIAL_NAME \"%s\"\n" % (Tab*spc,Nam))
	File.write("%s*MATERIAL_CLASS \"%s\"\n" % (Tab*spc,("Standard","Multi/Sub-Object")[not subMat]))
	File.write("%s*MATERIAL_AMBIENT %.4f  %.4f  %.4f\n" % ((Tab*spc,spez[0][0],spez[0][1],spez[0][2])))
	File.write("%s*MATERIAL_DIFFUSE %.4f  %.4f  %.4f\n" % ((Tab*spc,spez[1][0],spez[1][1],spez[1][2])))
	File.write("%s*MATERIAL_SPECULAR %.4f  %.4f  %.4f\n" % ((Tab*spc,spez[2][0],spez[2][1],spez[2][2])))
	File.write("%s*MATERIAL_SHINE %.4f\n" % (Tab*spc,spez[3]))
	File.write("%s*MATERIAL_SHINESTRENGTH %.4f\n" % (Tab*spc,spez[4]))
	File.write("%s*MATERIAL_TRANSPARENCY %.4f\n" % (Tab*spc,spez[5]))
	File.write("%s*MATERIAL_WIRESIZE 1.0000\n" % (Tab*spc))

	if subMat:
		File.write("%s*MATERIAL_SHADING Blinn\n" % (Tab*spc))
		File.write("%s*MATERIAL_XP_FALLOFF 0.0000\n" % (Tab*spc))
		File.write("%s*MATERIAL_SELFILLUM 0.0000\n" % (Tab*spc))
		File.write("%s*MATERIAL_FALLOFF In\n" % (Tab*spc))
		File.write("%s*MATERIAL_XP_TYPE Filter\n" % (Tab*spc))
		File.write("%s*MAP_DIFFUSE {\n" % (Tab*spc))

		File.write("%s*MAP_NAME \"%s\"\n" % (Tab*(spc+1),Nam))
		File.write("%s*MAP_CLASS \"Bitmap\"\n" % (Tab*(spc+1)))
		File.write("%s*MAP_SUBNO 1\n" % (Tab*(spc+1)))
		File.write("%s*MAP_AMOUNT 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*BITMAP \"C:\\%s\"\n" % (Tab*(spc+1),Nam))
		File.write("%s*MAP_TYPE Screen\n" % (Tab*(spc+1)))
		File.write("%s*UVW_U_OFFSET 0.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_V_OFFSET 0.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_U_TILING 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_V_TILING 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_ANGLE 0.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_BLUR 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_BLUR_OFFSET 0.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_NOUSE_AMT 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_NOISE_SIZE 1.0000\n" % (Tab*(spc+1)))
		File.write("%s*UVW_NOISE_LEVEL 1\n" % (Tab*(spc+1)))
		File.write("%s*UVW_NOISE_PHASE 0.0000\n" % (Tab*(spc+1)))
		File.write("%s*BITMAP_FILTER Pyramidal\n" % (Tab*(spc+1)))
		File.write("%s}\n" % (Tab*spc))
	pLog("<< ... done\n")

def Export():
	global MessCode, File, Tab
	File = None
	Tab = "\t"

	try: File = open(Path+ObInfo[0]+".ASE","w")
	except: MessCode = 3
	else: MessCode = 1
	ReFresh()
	if File:
		saveINI()
		# ------------------------------------------------------------------ Kopf
		# -----------------------------------------------------------------------
		pLog("\n~~ Unreal Static Mesh export ~~")
		pLog("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
		pLog("Exec Prog: Blender %.2f" % (Bver/100.0))
		pLog("exported from: %s" % SYS.basename(Blender.Get('filename')))
		pLog("FileName: %s.ASE" % ObInfo[0])
		pLog("Location: %s" % Path)
		pLog("ScaleFactor: %d" % scale.val)
		pLog("Smooth-Groups: %s%s\n" % (ObInfo[9],(("",""),(", defined by Faces",", defined by Material"))[ObInfo[9]!="nothing smooth"][smooby-1]))
		pLog(">> writing Header ...")

		File.write("*3DSMAX_ASCIIEXPORT    200\n")
		File.write("*COMMENT \"created by Unreal SM-Export 1.0 - 2004 Doc Holiday\"\n")
		File.write("*SCENE {\n")
		File.write("%s*SCENE_FILENAME \"%s\"\n" % (Tab, ObInfo[0]+".ASE"))
		File.write("%s*SCENE_FIRSTFRAME 0\n" % (Tab))
		File.write("%s*SCENE_LASTFRAME 100\n" % (Tab))
		File.write("%s*SCENE_FRAMESPEED 30\n" % (Tab))
		File.write("%s*SCENE_TICKSPERFRAME 160\n" % (Tab))
		File.write("%s*SCENE_BACKGROUND_STATIC 0.5000  0.5000  0.5000\n" % (Tab))
		File.write("%s*SCENE_AMBIENT_STATIC 0.0000  0.0000  0.0000\n" % (Tab))
		File.write("}\n")
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Materialien
		# ------------------------------------------------------------------------------
		File.write("*MATERIAL_LIST {\n")
		File.write("%s*MATERIAL_COUNT 1\n" % (Tab))
		File.write("%s*MATERIAL 0 {\n" % (Tab))

		if ObInfo[1] == "use default":
			MatSpez = [(0.5,0.5,0.5),(0.5,0.5,0.5),(0.9,0.9,0.9),0.1,0.0,0.0]
			saveMat("Default Material",MatSpez,2,0)
		else:
			MatSpez = []
			Mat = Mesh.materials[0]
			MatSpez.append(Mat.mirCol)
			MatSpez.append((Mat.R,Mat.G,Mat.B))
			MatSpez.append(Mat.specCol)
			MatSpez.append(Mat.hard/255.0)
			MatSpez.append(Mat.spec)
			MatSpez.append(1.0-Mat.alpha)
			saveMat(Mat.name,MatSpez,2,0)

		File.write("%s*NUMSUBMTLS %d\n" % (Tab*2,ObInfo[3]))

		for tc in range(len(TexList)):
			subM = TexList[tc]
			File.write("%s*SUBMATERIAL %d {\n" % (Tab*2,tc))

			TexN,TexE = subM.name.split(".")
			if TexE.lower() in ("jpg","png"): TexN += {"jpg":".bmp", "png":".tga"}[TexE]
			else: TexN += "."+TexE
			saveMat(TexN,MatSpez,3,tc+1)
			File.write("%s}\n" % (Tab*2))
		File.write("%s}\n" % (Tab))
		File.write("}\n")

		# ------------------------------------------------------------------ Objekte
		# --------------------------------------------------------------------------
		File.write("*GEOMOBJECT {\n")
		File.write("%s*NODE_NAME \"%s\"\n" % (Tab,ObInfo[0]))
		File.write("%s*NODE_TM {\n" % (Tab))

		File.write("%s*NODE_NAME \"%s\"\n" % (Tab*2,ObInfo[0]))
		File.write("%s*INHERIT_POS 0  0  0\n" % (Tab*2))
		File.write("%s*INHERIT_ROT 0  0  0\n" % (Tab*2))
		File.write("%s*INHERIT_SCL 0  0  0\n" % (Tab*2))
		File.write("%s*TM_ROW0 1.0000  0.0000  0.0000\n" % (Tab*2))
		File.write("%s*TM_ROW1 0.0000  1.0000  0.0000\n" % (Tab*2))
		File.write("%s*TM_ROW2 0.0000  0.0000  1.0000\n" % (Tab*2))
		File.write("%s*TM_ROW3 0.0000   0.0000   0.0000\n" % (Tab*2))
		File.write("%s*TM_POS 0.0000   0.0000   0.0000\n" % (Tab*2))
		File.write("%s*TM_ROTAXIS 0.0000  0.0000  0.0000\n" % (Tab*2))
		File.write("%s*TM_ROTANGLE 0.0000\n" % (Tab*2))
		File.write("%s*TM_SCALE 1.0000  1.0000  1.0000\n" % (Tab*2))
		File.write("%s*TM_SCALEAXIS 0.0000  0.0000  0.0000\n" % (Tab*2))
		File.write("%s*TM_SCALEAXISANG 0.0000\n" % (Tab*2))
		File.write("%s}\n" % (Tab))

		File.write("%s*MESH {\n" % (Tab))
		File.write("%s*TIMEVALUE 0\n" % (Tab*2))
		File.write("%s*MESH_NUMVERTEX %d\n" % (Tab*2,ObInfo[4]))
		File.write("%s*MESH_NUMFACES %d\n" % (Tab*2,ObInfo[5]))

		# ------------------------------------------------------------------ Verts
		# ------------------------------------------------------------------------
		pLog(">> writing %d Vertex Locations ..." % ObInfo[4])
		File.write("%s*MESH_VERTEX_LIST {\n" % (Tab*2))
		for vtx in Mesh.verts:
			File.write("%s*MESH_VERTEX  %d   %.4f   %.4f   %.4f\n" % (Tab*3,vtx.index,vtx.co[0]*scale.val,vtx.co[1]*scale.val,vtx.co[2]*scale.val))
		File.write("%s}\n" % (Tab*2))
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Faces
		# ------------------------------------------------------------------------
		pLog(">> writing %d Faces ..." % ObInfo[5])
		File.write("%s*MESH_FACE_LIST {\n" % (Tab*2))
		uvList = []
		FaceIDXList = []
		VIDXList = []
		UVList = []
		ColList = []
		FaceColList = []
		for fano in range(ObInfo[5]):
			fa = Mesh.faces[fano]

			FaceIDXList.append((fa.v[0].index,fa.v[1].index,fa.v[2].index))
			VIDX = []
			for tv in fa.uv:
				if not tv in UVList:
					UVList.append(tv)
					VIDX.append(len(UVList)-1)
				else: VIDX.append(UVList.index(tv))
			VIDXList.append(VIDX)

			CIDX = []
			for i in range(3):
				fc = (fa.col[i].r,fa.col[i].g,fa.col[i].b)
				if not fc in ColList:
					ColList.append(fc)
					CIDX.append(len(ColList)-1)
				else: CIDX.append(ColList.index(fc))
			FaceColList.append(CIDX)

			if not smooby: smoofa = 0
			elif smooby == 1: smoofa = fa.smooth
			else:
				mana = Mesh.materials[fa.mat].name
				if mana.lower().count("smooth."): smoofa = mana.split(".")[1]
				else: smoofa = 0

			wrst = "%s*MESH_FACE %d:  A: %d   B: %d   C: %d   AB: 1   BC: 1   CA: 1   " % (Tab*3,fano,FaceIDXList[-1][0],FaceIDXList[-1][1],FaceIDXList[-1][2])
			if smoofa: wrst += "*MESH_SMOOTHING %s%s" % (smoofa,Tab)
			wrst += "*MESH_MTLID %d\n" % TexList.index(fa.image)
			File.write(wrst)
		File.write("%s}\n" % (Tab*2))
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Textur Vertex
		# --------------------------------------------------------------------------------
		pLog(">> writing %d UV-Vertex ..." % len(UVList))
		File.write("%s*MESH_NUMTVERTEX %d\n" % (Tab*2,len(UVList)))
		File.write("%s*MESH_TVERTLIST {\n" % (Tab*2))

		for tvc in range(len(UVList)):
			tv = UVList[tvc]
			File.write("%s*MESH_TVERT  %d    %.4f    %.4f    0.0000\n" % (Tab*3,tvc,tv[0],tv[1]))
		File.write("%s}\n" % (Tab*2))
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Textur Faces
		# -------------------------------------------------------------------------------
		pLog(">> writing %d UV-Faces ..." % len(VIDXList))
		File.write("%s*MESH_NUMTVFACES %d\n" % (Tab*2,len(VIDXList)))
		File.write("%s*MESH_TFACELIST {\n" % (Tab*2))

		for tvc in range(len(VIDXList)):
			tv = VIDXList[tvc]
			File.write("%s*MESH_TFACE  %d    %d    %d    %d\n" % (Tab*3,tvc,tv[0],tv[1],tv[2]))
		File.write("%s}\n" % (Tab*2))
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Normals
		# --------------------------------------------------------------------------
		pLog(">> writing Normals ...")
		File.write("%s*MESH_NORMALS {\n" % (Tab*2))

		for fano in range(ObInfo[5]):
			fa = Mesh.faces[fano]
			File.write("%s*MESH_FACENORMAL  %d    %.4f    %.4f    %.4f\n" % (Tab*3,fano,fa.normal[0],fa.normal[1],fa.normal[2]))
			for vc in range(3):
				File.write("%s*MESH_VERTEXNORMAL  %d    %.4f    %.4f    %.4f\n" % (Tab*4,FaceIDXList[fano][vc],fa.v[vc].no[0],fa.v[vc].no[1],fa.v[vc].no[2]))
		File.write("%s}\n" % (Tab*2))
		pLog("<< ... done\n")

		# ------------------------------------------------------------------ Vertex Color
		# -------------------------------------------------------------------------------
		if ObInfo[2] == "Yes":
			pLog(">> writing %d Vertex Colors ..." % len(ColList))
			File.write("%s*MESH_NUMCVERTEX %d\n" % (Tab*2,len(ColList)))
			File.write("%s*MESH_CVERTLIST {\n" % (Tab*2))

			for cono in range(len(ColList)):
				co  = ColList[cono]
				File.write("%s*MESH_VERTCOL  %d    %.4f    %.4f    %.4f\n" % (Tab*3,cono,co[0]/255.0,co[1]/255.0,co[2]/255.0))
			File.write("%s}\n" % (Tab*2))
			pLog("<< ... done\n")

		# ------------------------------------------------------------------ Vertex Color Face
		# ------------------------------------------------------------------------------------
			pLog(">> writing %d Vertex Color-Faces ..." % len(FaceColList))
			File.write("%s*MESH_NUMCVFACES %d\n" % (Tab*2,len(FaceColList)))
			File.write("%s*MESH_CFACELIST {\n" % (Tab*2))

			for fano in range(len(FaceColList)):
				faco  = FaceColList[fano]
				File.write("%s*MESH_CFACE  %d    %d    %d    %d\n" % (Tab*3,fano,faco[0],faco[1],faco[2]))
			File.write("%s}\n" % (Tab*2))
			pLog("<< ... done\n")
		else:
			pLog("|> No Vertex Colors\n")

		# ------------------------------------------------------------------ Fertig
		# -------------------------------------------------------------------------
		pLog("|| finalizing File ...")
		File.write("%s}\n" % (Tab))
		File.write("%s*PROP_MOTIONBLUR 0\n" % (Tab))
		File.write("%s*PROP_CASTSHADOW 1\n" % (Tab))
		File.write("%s*PROP_RECVSHADOW 1\n" % (Tab))
		File.write("%s*MATERIAL_REF 0\n" % (Tab))
		File.write("}")

		File.close()
		pLog("|| ... export complete")
		pLog("\n   Have a nice Day! :)")
		MessCode = 2
		ReFresh()

# ========================================================================
# ==========================         GUI        ==========================
# ========================================================================
MessCode = 0
InsDrw = 1
Mouse = 1	# (1: IN, 0: OUT)
examineOb()
# ---------------------------
def draw():
	global InsDrw, Mouse, Path, MessCode, GlobSet, scale, useDefMat, ExpoLog
	glCallList(2)

	# ---------------------------- Mouse IO
	if InsDrw:
		InsDrw, Mouse = 0,1
	else: Mouse = 0
	# -------------------------------------
	#print Mouse

	for tx in range(2):
		for ty in range(5):
			ifos = str(ObInfo[ty+tx*5])
			if ifos.count("INVALID"): apply(glColor3d,red)
			else: apply(glColor3d,black)
			glRasterPos2f((Bord_L+74,Bord_M+76)[tx],Top-HB[0]-(45,60,75,90,105)[ty])
			Text(ifos)

	Blender.Draw.Button("...",3,Bord_R-30,Boden+HB[1]+30,15,15,"select FilePath")
	apply(glColor3d,Border)
	glRasterPos2i(Bord_L+20,Boden+HB[1]+34)
	maxtl = 281
	if not Path: Path = "C:"+Ysep
	schl,pt = 0,"Path: ... "
	if GetStringWidth(pt+Path) > maxtl:
		while not GetStringWidth(pt) > maxtl:
			schl += 1
			pt = "Path: ... "+Path[-schl:]
		pt = "Path: ... "+Path[-schl+1:]
	else: pt = "Path: "+Path
	Text(pt)
	wannaPath = 0

	GlobSet = Blender.Draw.Toggle("D",4,Bord_R-30,Boden+HB[1]+5,15,20,GlobSet.val,"default Settings ON/OFF")

	if not GlobSet.val:
		G_Box(Bord_L+15,Boden+HB[1]+5,Bord_L+73,Boden+HB[1]+25)
		if ObInfo[10].count("INVALID"): apply(glColor3d,red)
		else: apply(glColor3d,black)
		glRasterPos2i(Bord_L+16+(57-GetStringWidth(ObInfo[10]))/2,Boden+HB[1]+11)
		Text(ObInfo[10])

		if ObInfo[10] == "VALID" and not wannaPath and MessCode != 1:
			don = "Export to "+ObInfo[0]+".ASE"
			bn = 2
		else:
			don = ""
			bn = 200

		Blender.Draw.Button(don,bn,Bord_L+78,Boden+HB[1]+5,GB-113,20)
	else:
		scale = Blender.Draw.Number("Scale:",5,Bord_L+15,Boden+HB[1]+6,100,18,scale.val,1,1000,"global Scale Factor")
		useDefMat = Blender.Draw.Toggle("default Mat",6,Bord_L+120,Boden+HB[1]+6,100,18,useDefMat.val,"use always default Material")
		ExpoLog = Blender.Draw.Menu("Log Options%t|  None%x0|  to Box%x1|  to File%x2",7,Bord_L+225,Boden+HB[1]+6,80,18,ExpoLog.val,"export Log Options")	


	Blender.Draw.Button("Exit",1,Bord_R-85,Boden+10,70,20)

	if MessCode:
		apply(glColor3d,red)
		glRasterPos2i(Bord_L+25,Boden+15)
		Text(("writing File ...","writing File ... complete","FILE ERROR")[MessCode-1])
		MessCode = 0

def event(evt,val):
	global wannaPath
	if evt == ESCKEY and not wannaPath: ExitProg()
	if evt == MOUSEX and not Mouse:
		examineOb()
		ReFresh()

def bevent(evt):
	global wannaPath
	if evt==1: # --------------------------- Exit Button
		ExitProg()
	elif evt==2: # ------------------------- Export Button
		Export()
	elif evt ==3: # ------------------------ Path Button
		wannaPath = 1
		Blender.Window.FileSelector(Fileback,"choose Path")
		ReFresh()
	elif evt==4: # ------------------------- GlobSet Button
		ReFresh()
	elif evt==6: # ------------------------- DefMat Button
		if ObInfo[1] != "--":
			if Mesh.materials and not useDefMat.val: ObInfo[1] = Mesh.materials[0].name
			else: ObInfo[1] = "use default"
			ReFresh()

Blender.Draw.Register(draw,event,bevent)