From 734e7447277ef57e9ba509aa3ead0d7477c8175f Mon Sep 17 00:00:00 2001
From: Titus Tscharntke <titi_ger@users.sourceforge.net>
Date: Mon, 16 Jul 2012 21:43:35 +0000
Subject: [PATCH] new blender exporter from GAE for blender 2.63 and later

---
 source/tools/glexemel/g3d_support_b263.py | 742 ++++++++++++++++++++++
 1 file changed, 742 insertions(+)
 create mode 100644 source/tools/glexemel/g3d_support_b263.py

diff --git a/source/tools/glexemel/g3d_support_b263.py b/source/tools/glexemel/g3d_support_b263.py
new file mode 100644
index 000000000..1b6ba91c4
--- /dev/null
+++ b/source/tools/glexemel/g3d_support_b263.py
@@ -0,0 +1,742 @@
+# -*- coding: utf-8 -*-
+
+###########################################################################
+# Glest Model / Texture / UV / Animation Importer and Exporter
+# for the Game Glest that u can find http://www.glest.org
+# copyright 2005 By Andreas Becker (seltsamuel@yahoo.de)
+#
+# 2011/05/25: v0.1 alpha1
+# modified by William Zheng for Blender 2.57(loveheaven_zhengwei@hotmail.com)
+#
+# corrected by MrPostiga for Blender 2.58
+#
+# extended by Yggdrasil
+#
+# Started Date: 07 June 2005  Put Public 20 June 2005   
+#  Distributed under the GNU PUBLIC LICENSE
+#"""
+#Here an explanation of the V4 Format found at www.glest.org
+#================================
+#1. DATA TYPES
+#================================
+#G3D files use the following data types:
+#uint8: 8 bit unsigned integer
+#uint16: 16 bit unsigned integer
+#uint32: 32 bit unsigned integer
+#float32: 32 bit floating point
+#================================
+#2. OVERALL STRUCTURE
+#================================
+#- File header
+#- Model header
+#- Mesh header
+#- Texture names
+#- Mesh data
+#================================
+#2. FILE HEADER
+#================================
+#Code:
+#struct FileHeader{
+#   uint8 id[3];
+#   uint8 version;
+#};
+#This header is shared among all the versions of G3D, it identifies this file as a G3D model and provides information of the version.
+#id: must be "G3D"
+#version: must be 4, in binary (not '4')
+#================================
+#3. MODEL HEADER
+#================================
+#Code:
+#struct ModelHeader{
+#   uint16 meshCount;
+#   uint8 type;
+#};		   
+#meshCount: number of meshes in this model
+#type: must be 0
+#================================
+#4. MESH HEADER
+#================================
+#There is a mesh header for each mesh, there must be "meshCount" headers in a file but they are not consecutive, texture names and mesh data are stored in between.
+#Code:
+#struct MeshHeader{
+#   uint8 name[64];
+#   uint32 frameCount;
+#   uint32 vertexCount;
+#   uint32 indexCount;
+#   float32 diffuseColor[3];
+#   float32 specularColor[3];
+#   float32 specularPower;
+#   float32 opacity;
+#   uint32 properties;
+#   uint32 textures;
+#};
+#name: name of the mesh
+#frameCount: number of keyframes in this mesh
+#vertexCount: number of vertices in each frame
+#indexCount: number of indices in this mesh (the number of triangles is indexCount/3)
+#diffuseColor: RGB diffuse color
+#specularColor: RGB specular color (currently unused)
+#specularPower: specular power (currently unused)
+##properties: property flags
+#Code:
+#enum MeshPropertyFlag{
+#		mpfCustomColor= 1,
+#		mpfTwoSided= 2
+#};
+#mpfTwoSided: meshes in this mesh are rendered by both sides, if this flag is not present only "counter clockwise" faces are rendered
+#mpfCustomColor: alpha in this model is replaced by a custom color, usually the player color
+#textures: texture flags, only 0x1 is currently used, indicating that there is a diffuse texture in this mesh.
+#================================
+#4. TEXTURE NAMES
+#================================
+#A list of uint8[64] texture name values. One for each texture in the mesh. If there are no textures in the mesh no texture names are present. In practice since Glest only uses 1 texture for each mesh the number of texture names should be 0 or 1.
+#================================
+#5. MESH DATA
+#================================
+#After each mesh header and texture names the mesh data is placed.
+#vertices: frameCount * vertexCount * 3, float32 values representing the x, y, z vertex coords for all frames
+#normals: frameCount * vertexCount * 3, float32 values representing the x, y, z normal coords for all frames
+#texture coords: vertexCount * 2, float32 values representing the s, t tex coords for all frames (only present if the mesh has 1 texture at least)
+#indices: indexCount, uint32 values representing the indices
+###########################################################################
+
+bl_info = {
+	"name": "G3D Mesh Import/Export",
+	"author": "various, see head of script",
+	"version": (0, 5, 1),
+	"blender": (2, 63, 0),
+	#"api": 36079,
+	"location": "File > Import-Export",
+	"description": "Import/Export .g3d file",
+	"warning": "",
+	"wiki_url": "",
+	"tracker_url": "",
+	"category": "Import-Export"}
+###########################################################################
+# Importing Structures needed (must later verify if i need them really all)
+###########################################################################
+import bpy
+from bpy.props import StringProperty
+from bpy_extras.image_utils import load_image
+from bpy_extras.io_utils import ImportHelper, ExportHelper
+
+import sys, struct, string, types
+from types import *
+import os
+from os import path
+from os.path import dirname
+###########################################################################
+# Variables that are better Global to handle
+###########################################################################
+imported = []   #List of all imported Objects
+toexport = []   #List of Objects to export (actually only meshes)
+sceneID  = None #Points to the active Blender Scene
+def unpack_list(list_of_tuples):
+	l = []
+	for t in list_of_tuples:
+		l.extend(t)
+	return l
+###########################################################################
+# Declaring Structures of G3D Format
+###########################################################################
+class G3DHeader:							#Read first 4 Bytes of file should be G3D + Versionnumber
+	binary_format = "<3cB"
+	def __init__(self, fileID):
+		temp = fileID.read(struct.calcsize(self.binary_format))
+		data = struct.unpack(self.binary_format,temp)
+		self.id = str(data[0]+data[1]+data[2], "utf-8")
+		self.version = data[3]
+
+class G3DModelHeaderv3:					 #Read Modelheader in V3 there is only the number of Meshes in file
+	binary_format = "<I"
+	def __init__(self, fileID):
+		temp = fileID.read(struct.calcsize(self.binary_format))
+		data = struct.unpack(self.binary_format,temp)
+		self.meshcount = data[0]
+
+class G3DModelHeaderv4:					 #Read Modelheader: Number of Meshes and Meshtype (must be 0)
+	binary_format = "<HB"
+	def __init__(self, fileID):
+		temp = fileID.read(struct.calcsize(self.binary_format))
+		data = struct.unpack(self.binary_format,temp)
+		self.meshcount = data[0]
+		self.mtype = data[1]
+		
+class G3DMeshHeaderv3:										 #Read Meshheader
+	binary_format = "<7I64c"
+	def __init__(self,fileID):
+		temp = fileID.read(struct.calcsize(self.binary_format))
+		data = struct.unpack(self.binary_format,temp)
+		self.framecount = data[0]				 #Framecount = Number of Animationsteps
+		self.normalframecount= data[1]		 #Number of Normal Frames actualli equal to Framecount
+		self.texturecoordframecount= data[2]#Number of Frames of Texturecoordinates seems everytime to be 1
+		self.colorframecount= data[3]		  #Number of Frames of Colors seems everytime to be 1
+		self.vertexcount= data[4]				  #Number of Vertices in each Frame
+		self.indexcount= data[5]					   #Number of Indices in Mesh (Triangles = Indexcount/3)
+		self.properties= data[6]					   #Property flags
+		if self.properties & 1:					  #PropertyBit is Mesh Textured ?
+			self.hastexture = False
+			self.texturefilename = None
+		else:
+			self.texturefilename = "".join([str(x, "ascii") for x in data[7:-1] if x[0]< 127 ])
+			self.hastexture = True
+		if self.properties & 2:					  #PropertyBit is Mesh TwoSided ?
+			self.istwosided = True
+		else:
+			self.istwosided = False
+		if self.properties & 4:					  #PropertyBit is Mesh Alpha Channel custom Color in Game ?
+			self.customalpha = True
+		else:
+			self.customalpha = False
+		
+class G3DMeshHeaderv4:										 #Read Meshheader
+	binary_format = "<64c3I8f2I"
+	texname_format = "<64c"
+	def __init__(self,fileID):
+		temp = fileID.read(struct.calcsize(self.binary_format))
+		data = struct.unpack(self.binary_format,temp)
+		self.meshname = "".join([str(x, "ascii") for x in data[0:64] if x[0] < 127 ]) #Name of Mesh every Char is a  String on his own
+		self.framecount = data[64]				#Framecount = Number of Animationsteps
+		self.vertexcount = data[65]			   #Number of Vertices in each Frame
+		self.indexcount = data[66]				#Number of Indices in Mesh (Triangles = Indexcount/3)
+		self.diffusecolor = data[67:70]	   #RGB diffuse color
+		self.specularcolor = data[70:73]	  #RGB specular color (unused)
+		self.specularpower = data[73]		 #Specular power (unused)
+		self.opacity = data[74]					   #Opacity
+		self.properties= data[75]				  #Property flags
+		self.textures = data[76]					  #Texture flag
+		if self.properties & 1:					  #PropertyBit is Mesh Alpha Channel custom Color in Game ?
+			self.customalpha = True
+		else:
+			self.customalpha = False
+		if self.properties & 2:					  #PropertyBit is Mesh TwoSided ?
+			self.istwosided = True
+		else:
+			self.istwosided = False
+		if self.textures & 1:						#PropertyBit is Mesh Textured ?
+			temp = fileID.read(struct.calcsize(self.texname_format))
+			data = struct.unpack(self.texname_format,temp)
+			self.texturefilename = "".join([str(x, "ascii") for x in data[0:-1] if x[0] < 127 ])
+			self.hastexture = True
+		else:
+			self.hastexture = False
+			self.texturefilename = None
+
+class G3DMeshdataV3:											   #Calculate and read the Mesh Datapack
+	def __init__(self,fileID,header):
+		#Calculation of the Meshdatasize to load because its variable
+		#Animationframes * Vertices per Animation * 3 (Each Point are 3 Float X Y Z Coordinates)
+		vertex_format = "<%if" % int(header.framecount * header.vertexcount * 3)
+		#The same for Normals
+		normals_format = "<%if" % int(header.normalframecount * header.vertexcount * 3)
+		#Same here but Textures are 2D so only 2 Floats needed for Position inside Texture Bitmap
+		texturecoords_format = "<%if" % int(header.texturecoordframecount * header.vertexcount * 2)
+		#Colors in format RGBA
+		colors_format = "<%if" % int(header.colorframecount * 4)
+		#Indices
+		indices_format = "<%iI" % int(header.indexcount)
+		#Load the Meshdata as calculated above
+		self.vertices = struct.unpack(vertex_format,fileID.read(struct.calcsize(vertex_format)))
+		self.normals = struct.unpack(normals_format,fileID.read(struct.calcsize(normals_format)))
+		self.texturecoords = struct.unpack(texturecoords_format,fileID.read(struct.calcsize(texturecoords_format)))
+		self.colors = struct.unpack(colors_format,fileID.read(struct.calcsize(colors_format)))
+		self.indices = struct.unpack(indices_format ,fileID.read(struct.calcsize(indices_format)))
+
+class G3DMeshdataV4:											   #Calculate and read the Mesh Datapack
+	def __init__(self,fileID,header):
+		#Calculation of the Meshdatasize to load because its variable
+		#Animationframes * Points (Vertex) per Animation * 3 (Each Point are 3 Float X Y Z Coordinates)
+		vertex_format = "<%if" % int(header.framecount * header.vertexcount * 3)
+		#The same for Normals
+		normals_format = "<%if" % int(header.framecount * header.vertexcount * 3)
+		#Same here but Textures are 2D so only 2 Floats needed for Position inside Texture Bitmap
+		texturecoords_format = "<%if" % int(header.vertexcount * 2)
+		#Indices
+		indices_format = "<%iI" % int(header.indexcount)
+		#Load the Meshdata as calculated above
+		self.vertices = struct.unpack(vertex_format,fileID.read(struct.calcsize(vertex_format)))
+		self.normals = struct.unpack(normals_format,fileID.read(struct.calcsize(normals_format)))
+		if header.hastexture:
+			self.texturecoords = struct.unpack(texturecoords_format,fileID.read(struct.calcsize(texturecoords_format)))
+		self.indices = struct.unpack(indices_format ,fileID.read(struct.calcsize(indices_format)))
+
+def createMesh(filename,header,data):						  #Create a Mesh inside Blender
+	mesh = bpy.data.meshes.new(header.meshname)		#New Mesh
+	meshobj = bpy.data.objects.new(header.meshname+'Object', mesh)	 #New Object for the new Mesh
+	scene = bpy.context.scene
+	scene.objects.link(meshobj)
+	scene.update()
+	uvcoords = []
+	image = None
+	if header.hastexture:												  #Load Texture when assigned
+		texturefile = dirname(filename)+os.sep+header.texturefilename
+		image = bpy.data.images.load(texturefile) #load_image(texturefile, dirname(filename))
+		for x in range(0,len(data.texturecoords),2): #Prepare the UV
+			uvcoords.append([data.texturecoords[x],data.texturecoords[x+1]])
+	
+	vertsCO = []
+	vertsNormal = []
+	for x in range(0,header.vertexcount*3,3):	   #Get the Vertices and Normals into empty Mesh
+		vertsCO.extend([(data.vertices[x],data.vertices[x+1],data.vertices[x+2])])
+		vertsNormal.extend([(data.normals[x],data.normals[x+1],data.normals[x+2])])
+		#vertsCO.extend([(data.vertices[x+(header.framecount-1)*header.vertexcount*3],data.vertices[x+(header.framecount-1)*header.vertexcount*3+1],data.vertices[x+(header.framecount-1)*header.vertexcount*3+2])])
+		#vertsNormal.extend([(data.normals[x+(header.framecount-1)*header.vertexcount*3],data.normals[x+(header.framecount-1)*header.vertexcount*3+1],data.normals[x+(header.framecount-1)*header.vertexcount*3+2])])
+	mesh.vertices.add(len(vertsCO))
+	mesh.vertices.foreach_set("co", unpack_list(vertsCO))
+	mesh.vertices.foreach_set("normal", unpack_list(vertsNormal))
+	
+	faces = []
+	faceuv = []
+	for i in range(0,len(data.indices),3):			  #Build Faces into Mesh
+		faces.extend([data.indices[i], data.indices[i+1], data.indices[i+2], 0])
+		if header.hastexture:	   
+			uv = []
+			u0 = uvcoords[data.indices[i]][0]
+			v0 = uvcoords[data.indices[i]][1]
+			uv.append([u0,v0])
+			u1 = uvcoords[data.indices[i+1]][0]
+			v1 = uvcoords[data.indices[i+1]][1]
+			uv.append([u1,v1])
+			u2 = uvcoords[data.indices[i+2]][0]
+			v2 = uvcoords[data.indices[i+2]][1]
+			uv.append([u2,v2])
+			faceuv.append([uv,0,0,0])
+		else:
+			uv = []
+			uv.append([0,0])
+			uv.append([0,0])
+			uv.append([0,0])
+			faceuv.append([uv,0,0,0])
+	mesh.faces.add(len(faces)//4)
+	mesh.faces.foreach_set("vertices_raw", faces)
+	mesh.faces.foreach_set("use_smooth", [True] * len(mesh.faces))
+	mesh.show_double_sided = header.istwosided
+	mesh.update_tag()
+	mesh.update()   #Update changes to Mesh
+	#===================================================================================================
+	#Material Setup
+	#===================================================================================================
+	if header.hastexture:	   
+		materialname = "pskmat"
+		materials = []
+		texture = bpy.data.textures.new(name=header.texturefilename,type='IMAGE')
+		texture.image = image
+		matdata = bpy.data.materials.new(materialname + '1')
+		slot = matdata.texture_slots.add()
+		slot.texture = texture
+		slot.texture_coords = 'UV'
+		if header.isv4:
+			matdata.diffuse_color = (header.diffusecolor[0], header.diffusecolor[1],header.diffusecolor[2])
+			matdata.alpha = header.opacity
+			matdata.specular_color = (header.specularcolor[0], header.specularcolor[1],header.specularcolor[2])
+		matdata.use_face_texture_alpha = header.customalpha
+		materials.append(matdata)
+
+		for material in materials:
+			#add material to the mesh list of materials
+			mesh.materials.append(material)
+
+		countm = 0
+		psktexname="psk" + str(countm)
+		mesh.uv_textures.new(name=psktexname)
+		if (len(faceuv) > 0):
+			for countm in range(len(mesh.uv_textures)):
+				mesh.update()
+				uvtex = mesh.uv_textures[countm] #add one uv texture
+				mesh.update()
+				for i, face in enumerate(mesh.faces):
+					blender_tface = uvtex.data[i] #face
+					mfaceuv = faceuv[i]
+					if countm == faceuv[i][1]:
+						face.material_index = faceuv[i][1]
+						blender_tface.uv1 = mfaceuv[0][0] #uv = (0,0)
+						blender_tface.uv2 = mfaceuv[0][1] #uv = (0,0)
+						blender_tface.uv3 = mfaceuv[0][2] #uv = (0,0)
+						blender_tface.image = image
+					else:
+						blender_tface.uv1 = [0,0]
+						blender_tface.uv2 = [0,0]
+						blender_tface.uv3 = [0,0]
+	mesh.update()
+	imported.append(meshobj)			#Add to Imported Objects
+	sk = meshobj.shape_key_add()
+	#mesh.shape_keys.use_relative = False
+	#sk.interpolation = 'KEY_LINEAR'
+	for x in range(1,header.framecount):	#Put in Vertex Positions for Keyanimation
+		#print("Frame"+str(x))
+		sk = meshobj.shape_key_add()
+		for i in range(0,header.vertexcount*3,3):
+			sk.data[i//3].co[0]= data.vertices[x*header.vertexcount*3 + i]
+			sk.data[i//3].co[1]= data.vertices[x*header.vertexcount*3 + i +1]
+			sk.data[i//3].co[2]= data.vertices[x*header.vertexcount*3 + i +2]
+		#meshobj.keyframe_insert("location",-1, frame=(x+1))
+		#meshobj.keyframe_insert(data_path="data.vertices", frame=(x+1))
+	mesh.update()
+	return
+###########################################################################
+# Import
+###########################################################################
+def G3DLoader(filepath):			#Main Import Routine
+	global imported, sceneID
+	print ("\nNow Importing File: " + filepath)
+	fileID = open(filepath,"rb")
+	header = G3DHeader(fileID)
+	print ("\nHeader ID         : " + header.id)
+	print ("Version           : " + str(header.version))
+	if header.id != "G3D":
+		print ("This is Not a G3D Model File")
+		fileID.close
+		return
+	if header.version not in (3, 4):
+		print ("The Version of this G3D File is not Supported")
+		fileID.close
+		return
+	#in_editmode = Blender.Window.EditMode()			 #Must leave Editmode when active
+	#if in_editmode: Blender.Window.EditMode(0)
+	sceneID = bpy.context.scene						  #Get active Scene
+	#scenecontext=sceneID.getRenderingContext()		  #To Access the Start/Endframe its so hidden i searched till i got angry :-)
+	basename=os.path.basename(filepath).split('.')[0]   #Generate the Base Filename without Path + extension
+	imported = []
+	maxframe=0
+	if header.version == 3:
+		modelheader = G3DModelHeaderv3(fileID)
+		print ("Number of Meshes  : " + str(modelheader.meshcount))
+		for x in range(modelheader.meshcount):
+			meshheader = G3DMeshHeaderv3(fileID)
+			meshheader.isv4 = False	
+			print ("\nMesh Number         : " + str(x+1))
+			print ("framecount            : " + str(meshheader.framecount))
+			print ("normalframecount      : " + str(meshheader.normalframecount))
+			print ("texturecoordframecount: " + str(meshheader.texturecoordframecount))
+			print ("colorframecount       : " + str(meshheader.colorframecount))
+			print ("pointcount            : " + str(meshheader.vertexcount))
+			print ("indexcount            : " + str(meshheader.indexcount))
+			print ("texturename           : " + str(meshheader.texturefilename))
+			print ("hastexture            : " + str(meshheader.hastexture))
+			print ("istwosided            : " + str(meshheader.istwosided))
+			print ("customalpha           : " + str(meshheader.customalpha))
+			meshheader.meshname = basename+str(x+1)	 #Generate Meshname because V3 has none
+			if meshheader.framecount > maxframe: maxframe = meshheader.framecount #Evaluate the maximal animationsteps
+			meshdata = G3DMeshdataV3(fileID,meshheader)
+			createMesh(filepath,meshheader,meshdata)
+		fileID.close
+		bpy.context.scene.frame_start=1
+		bpy.context.scene.frame_end=maxframe
+		bpy.context.scene.frame_current=1
+		anchor = bpy.data.objects.new('Empty', None)
+		anchor.select = True
+		bpy.context.scene.objects.link(anchor)
+		for ob in imported:
+				ob.parent = anchor
+		bpy.context.scene.update()
+		return
+	if header.version == 4:
+		modelheader = G3DModelHeaderv4(fileID)
+		print ("Number of Meshes  : " + str(modelheader.meshcount))
+		for x in range(modelheader.meshcount):
+			meshheader = G3DMeshHeaderv4(fileID)
+			meshheader.isv4 = True	  
+			print ("\nMesh Number   : " + str(x+1))
+			print ("meshname        : " + str(meshheader.meshname))
+			print ("framecount      : " + str(meshheader.framecount))
+			print ("vertexcount     : " + str(meshheader.vertexcount))
+			print ("indexcount      : " + str(meshheader.indexcount))
+			print ("diffusecolor    : %1.6f %1.6f %1.6f" %meshheader.diffusecolor)
+			print ("specularcolor   : %1.6f %1.6f %1.6f" %meshheader.specularcolor)
+			print ("specularpower   : %1.6f" %meshheader.specularpower)
+			print ("opacity         : %1.6f" %meshheader.opacity)
+			print ("properties      : " + str(meshheader.properties))
+			print ("textures        : " + str(meshheader.textures))
+			print ("texturename     : " + str(meshheader.texturefilename))
+			if len(meshheader.meshname) ==0:	#When no Meshname in File Generate one
+					meshheader.meshname = basename+str(x+1)
+			if meshheader.framecount > maxframe: maxframe = meshheader.framecount #Evaluate the maximal animationsteps
+			meshdata = G3DMeshdataV4(fileID,meshheader)
+			createMesh(filepath,meshheader,meshdata)
+		fileID.close
+		
+		bpy.context.scene.frame_start=1
+		bpy.context.scene.frame_end=maxframe
+		bpy.context.scene.frame_current=1
+		anchor = bpy.data.objects.new('Empty', None)
+		anchor.select = True
+		bpy.context.scene.objects.link(anchor)
+		for ob in imported:
+				ob.parent = anchor
+		bpy.context.scene.update()
+		print ("Created a empty Object as 'Grip' where all imported Objects are parented to")
+		print ("To move the complete Meshes only select this empty Object and move it")
+		print ("All Done, have a good Day :-)\n\n")
+		return
+
+def G3DSaver(filepath, context, operator):
+	print ("\nNow Exporting File: " + filepath)
+
+	objs = context.selected_objects
+	if len(objs) == 0:
+		objs = bpy.data.objects
+
+	#get real meshcount as len(bpy.data.meshes) holds also old meshes
+	meshCount = 0
+	for obj in objs:
+		if obj.type == 'MESH':
+			meshCount += 1
+			if obj.mode != 'OBJECT': # we want to be in object mode
+				print("ERROR: mesh not in object mode")
+				operator.report({'ERROR'}, "mesh not in object mode")
+				return
+
+	if meshCount == 0:
+		print("ERROR: no meshes found")
+		operator.report({'ERROR'}, "no meshes found")
+		return
+
+	fileID = open(filepath,"wb")
+	# G3DHeader v4
+	fileID.write(struct.pack("<3cB", b'G', b'3', b'D', 4))
+	# G3DModelHeaderv4
+	fileID.write(struct.pack("<HB", meshCount, 0))
+	# meshes
+	#for mesh in bpy.data.meshes:
+	for obj in objs:
+		if obj.type != 'MESH':
+			continue
+		mesh = obj.data.copy()
+		diffuseColor = [1.0, 1.0, 1.0]
+		specularColor = [0.9, 0.9, 0.9]
+		opacity = 1.0
+		textures = 0
+		if len(mesh.materials) > 0:
+			# we have a texture, hopefully
+			material = mesh.materials[0]
+			if material.active_texture.type=='IMAGE' and len(mesh.uv_textures)>0:
+				diffuseColor = material.diffuse_color
+				specularColor = material.specular_color
+				opacity = material.alpha
+				textures = 1
+				texname = bpy.path.basename(material.active_texture.image.filepath)
+			else:
+				print("WARNING: active texture in first material isn't of type IMAGE or it's not unwrapped, texture ignored")
+				operator.report({'WARNING'}, "active texture in first material isn't of type IMAGE or it's not unwrapped, texture ignored")
+				#continue without texture
+
+		meshname = mesh.name
+		frameCount = context.scene.frame_end - context.scene.frame_start +1
+		#Real face count (triangles)
+		realFaceCount = 0
+		indices=[]
+		newverts=[]
+		mesh.calc_tessface() # tesselate n-polygons to triangles and quads
+		if textures == 1:
+			uvtex = mesh.tessface_uv_textures[0]
+			uvlist = []
+			uvlist[:] = [[0]*2 for i in range(len(mesh.vertices))]
+			s = set()
+			for face in mesh.tessfaces:
+				faceindices = [] # we create new faces when duplicating vertices
+				realFaceCount += 1
+				uvdata = uvtex.data[face.index]
+				for i in range(3):
+					vindex = face.vertices[i]
+					if vindex not in s:
+						s.add(vindex)
+						uvlist[vindex] = uvdata.uv[i]
+					elif uvlist[vindex] != uvdata.uv[i]:
+						# duplicate vertex because it takes part in different faces
+						# with different texcoords
+						newverts.append(vindex)
+						uvlist.append(uvdata.uv[i])
+						#FIXME: probably better with some counter
+						vindex = len(mesh.vertices) + len(newverts) -1
+
+					faceindices.append(vindex)
+				indices.extend(faceindices)
+
+				#FIXME: stupid copy&paste
+				if len(face.vertices) == 4:
+					faceindices = []
+					realFaceCount += 1
+					for i in [0,2,3]:
+						vindex = face.vertices[i]
+						if vindex not in s:
+							s.add(vindex)
+							uvlist[vindex] = uvdata.uv[i]
+						elif uvlist[vindex] != uvdata.uv[i]:
+							# duplicate vertex because it takes part in different faces
+							# with different texcoords
+							newverts.append(vindex)
+							uvlist.append(uvdata.uv[i])
+							#FIXME: probably better with some counter
+							vindex = len(mesh.vertices) + len(newverts) -1
+
+						faceindices.append(vindex)
+					indices.extend(faceindices)
+		else:
+			for face in mesh.tessfaces:
+				realFaceCount += 1
+				indices.extend(face.vertices[0:3])
+				if len(face.vertices) == 4:
+					realFaceCount += 1
+					# new face because quad got split
+					indices.append(face.vertices[0])
+					indices.append(face.vertices[2])
+					indices.append(face.vertices[3])
+
+
+		# abort when no triangles as it crashs g3dviewer
+		if realFaceCount == 0:
+			print("ERROR: no triangles found")
+			operator.report({'ERROR'}, "no triangles found")
+			return
+		indexCount = realFaceCount * 3
+		vertexCount = len(mesh.vertices) + len(newverts)
+		specularPower = 9.999999  # unused, same as old exporter
+		properties = 0
+		if mesh.g3d_customColor:
+			properties |= 1
+		if mesh.show_double_sided:
+			properties |= 2
+		if mesh.g3d_noSelect:
+			properties |= 4
+
+		#MeshData
+		vertices = []
+		normals = []
+		fcurrent = context.scene.frame_current
+		for i in range(context.scene.frame_start, context.scene.frame_end+1):
+			context.scene.frame_set(i)
+			#FIXME: not sure what's better: PREVIEW or RENDER settings
+			m = obj.to_mesh(context.scene, True, 'RENDER')
+			m.transform(obj.matrix_world)  # apply object-mode transformations
+			for vertex in m.vertices:
+				vertices.extend(vertex.co)
+				normals.extend(vertex.normal)
+
+			for nv in newverts:
+				vertices.extend(m.vertices[nv].co)
+				normals.extend(m.vertices[nv].normal)
+
+		context.scene.frame_set(fcurrent)
+
+		# MeshHeader
+		fileID.write(struct.pack("<64s3I8f2I",
+			bytes(meshname, "ascii"),
+			frameCount, vertexCount, indexCount,
+			diffuseColor[0], diffuseColor[1], diffuseColor[2],
+			specularColor[0], specularColor[1], specularColor[2],
+			specularPower, opacity,
+			properties, textures
+		))
+		#Texture names
+		if textures == 1: # only when we have one
+			fileID.write(struct.pack("<64s", bytes(texname, "ascii")))
+
+		# see G3DMeshdataV4
+		vertex_format = "<%if" % int(frameCount * vertexCount * 3)
+		normals_format = "<%if" % int(frameCount * vertexCount * 3)
+		texturecoords_format = "<%if" % int(vertexCount * 2)
+		indices_format = "<%iI" % int(indexCount)
+
+		fileID.write(struct.pack(vertex_format, *vertices))
+		fileID.write(struct.pack(normals_format, *normals))
+
+		# texcoords
+		if textures == 1: # only when we have one
+			texcoords = []
+			for uv in uvlist:
+				texcoords.extend(uv)
+			fileID.write(struct.pack(texturecoords_format, *texcoords))
+
+		fileID.write(struct.pack(indices_format, *indices))
+
+	fileID.close()
+	return
+
+
+#---=== Register ===
+class G3DPanel(bpy.types.Panel):
+	#bl_idname = "OBJECT_PT_G3DPanel"
+	bl_label = "G3D properties"
+	bl_space_type = 'PROPERTIES'
+	bl_region_type = 'WINDOW'
+	bl_context = "data"
+
+	@classmethod
+	def poll(cls, context):
+		return (context.object is not None and context.object.type == 'MESH')
+
+	def draw(self, context):
+		self.layout.prop(context.object.data, "g3d_customColor", text="team color")
+		self.layout.prop(context.object.data, "show_double_sided", text="double sided")
+		self.layout.prop(context.object.data, "g3d_noSelect", text="non-selectable")
+
+class ImportG3D(bpy.types.Operator, ImportHelper):
+	'''Load a G3D file'''
+	bl_idname = "importg3d.g3d"
+	bl_label = "Import G3D"
+
+	filename_ext = ".g3d"
+	filter_glob = StringProperty(default="*.g3d", options={'HIDDEN'})
+
+	def execute(self, context):
+		try:
+			G3DLoader(**self.as_keywords(ignore=("filter_glob",)))
+		except:
+			import traceback
+			traceback.print_exc()
+
+			return {'CANCELLED'}
+
+		return {'FINISHED'}
+
+class ExportG3D(bpy.types.Operator, ExportHelper):
+	'''Save a G3D file'''
+	bl_idname = "exportg3d.g3d"
+	bl_label = "Export G3D"
+
+	filename_ext = ".g3d"
+	filter_glob = StringProperty(default="*.g3d", options={'HIDDEN'})
+
+	def execute(self, context):
+		try:
+			G3DSaver(self.filepath, context, self)
+		except:
+			import traceback
+			traceback.print_exc()
+
+			return {'CANCELLED'}
+
+		return {'FINISHED'}
+
+def menu_func_import(self, context):
+	self.layout.operator(ImportG3D.bl_idname, text="Glest 3D File (.g3d)")
+
+def menu_func_export(self, context):
+	self.layout.operator(ExportG3D.bl_idname, text="Glest 3D File (.g3d)")
+
+def register():
+	# custom mesh properties
+	bpy.types.Mesh.g3d_customColor = bpy.props.BoolProperty()
+	bpy.types.Mesh.g3d_noSelect = bpy.props.BoolProperty()
+
+	bpy.utils.register_module(__name__)
+
+	bpy.types.INFO_MT_file_import.append(menu_func_import)
+	bpy.types.INFO_MT_file_export.append(menu_func_export)
+
+
+def unregister():
+	bpy.utils.unregister_module(__name__)
+
+	bpy.types.INFO_MT_file_import.remove(menu_func_import)
+	bpy.types.INFO_MT_file_export.remove(menu_func_export)
+
+if __name__ == '__main__':
+	register()
+#	main()
+
+	#G3DLoader("import.g3d")
+	#for obj in bpy.context.selected_objects:
+	#	obj.select = False  # deselect everything, so we get it all
+	#G3DSaver("test.g3d", bpy.context)
+