X-Git-Url: http://git.tdb.fi/?a=blobdiff_plain;f=blender%2Fio_mesh_mspgl%2Fexport_mspgl.py;h=c0fd96e9b5e71550f9a0b90bf1aeef2b113b5089;hb=95cc5788bd736be92b3810d3fea398fadc8865b1;hp=6de38f8722935d884f45c4fbc441bca1e28926f7;hpb=5028e8accde81677fc4a50c771b955cf324851b2;p=libs%2Fgl.git

diff --git a/blender/io_mesh_mspgl/export_mspgl.py b/blender/io_mesh_mspgl/export_mspgl.py
index 6de38f87..c0fd96e9 100644
--- a/blender/io_mesh_mspgl/export_mspgl.py
+++ b/blender/io_mesh_mspgl/export_mspgl.py
@@ -1,5 +1,3 @@
-# $Id: mesh_export.py 137 2010-12-05 19:22:35Z tdb $
-
 import bpy
 
 class VertexCache:
@@ -71,10 +69,14 @@ class Exporter:
 		self.optimize_cache = False
 		self.cache_size = 64
 		self.export_lines = True
+		self.export_uv = "UNIT0"
 		self.tbn_vecs = False
+		self.tbn_uvtex = ""
 		self.compound = False
 		self.object = False
 		self.material_tex = False
+		self.textures = "REF"
+		self.smoothing = "MSPGL"
 
 	def stripify(self, mesh, progress = None):
 		for f in mesh.faces:
@@ -92,6 +94,7 @@ class Exporter:
 		island_strips = []
 		while 1:
 			if not island:
+				# No current island; find any unused face to start from
 				queue = []
 				for f in mesh.faces:
 					if not f.flag:
@@ -102,38 +105,49 @@ class Exporter:
 				if not queue:
 					break
 
+				# Find all faces connected to the first one
 				while queue:
-					f = queue[0]
-					del queue[0]
-					island.append(f)
+					face = queue.pop(0)
+					island.append(face)
 
-					for e in f.edges:
-						other = e.other_face(f)
-						if other and not other.flag:
-							other.flag = True
-							queue.append(other)
+					for n in f.get_neighbors():
+						if not n.flag:
+							n.flag = True
+							queue.append(n)
 
+				# Unflag the island for the next phase
 				for f in island:
 					f.flag = False
 
+			# Find an unused face with as few unused neighbors as possible, but
+			# at least one.  This heuristic gives a preference to faces in corners
+			# or along borders of a non-closed island.
 			best = 5
 			face = None
 			for f in island:
 				if f.flag:
 					continue
-				score = 0
-				for e in f.edges:
-					other = e.other_face(f)
-					if other and not other.flag:
-						score += 1
+
+				score = sum(not n.flag for n in f.get_neighbors())
 				if score>0 and score<best:
 					face = f
 					best = score
 
-			if not face:
+			if face:
+				# Create a strip starting from the face.  This will flag the faces.
+				strip = mesh.create_strip(face, self.max_strip_len)
+				if strip:
+					island_strips.append(strip)
+				else:
+					face.flag = True
+			else:
+				# Couldn't find a candidate face for starting a strip, so we're
+				# done with this island
 				while island_strips:
 					best = 0
 					if cache:
+						# Find the strip that benefits the most from the current
+						# contents of the vertex cache
 						best_hits = 0
 						for i in range(len(island_strips)):
 							hits = cache.test_strip(island_strips[i])
@@ -141,28 +155,23 @@ class Exporter:
 								best = i
 								best_hits = hits
 
-					s = island_strips[best]
-					del island_strips[best]
-					strips.append(s)
+					strip = island_strips.pop(best)
+					strips.append(strip)
 
 					if cache:
-						cache.fetch_strip(s)
+						cache.fetch_strip(strip)
 
 				faces_done += len(island)
 				if progress:
 					progress.set_progress(float(faces_done)/len(mesh.faces))
 
+				# Collect any faces that weren't used in strips
 				loose += [f for f in island if not f.flag]
 				for f in island:
 					f.flag = True
 
 				island = []
 				island_strips = []
-				continue
-
-			strip = mesh.create_strip(face, self.max_strip_len)
-			if strip:
-				island_strips.append(strip)
 
 		if cache:
 			cache = VertexCache(self.cache_size)
@@ -173,6 +182,8 @@ class Exporter:
 
 			for s in strips:
 				if big_strip:
+					# Generate glue elements, ensuring that the next strip begins at
+					# an even position
 					glue = [big_strip[-1], s[0]]
 					if len(big_strip)%2:
 						glue += [s[0]]
@@ -186,6 +197,8 @@ class Exporter:
 					total_hits += cache.fetch_strip(s)
 
 			for f in loose:
+				# Add loose faces to the end.  This wastes space, using five
+				# elements per triangle and six elements per quad.
 				if len(big_strip)%2:
 					order = (-1, -2, 0, 1)
 				else:
@@ -228,7 +241,7 @@ class Exporter:
 		mesh = None
 		bmeshes = []
 		for o in objs:
-			bmesh = o.create_mesh(context.scene, True, "PREVIEW")
+			bmesh = o.to_mesh(context.scene, True, "PREVIEW")
 			bmeshes.append(bmesh)
 			if not mesh:
 				mesh = Mesh(bmesh)
@@ -236,20 +249,44 @@ class Exporter:
 				mesh.splice(Mesh(bmesh))
 
 		progress.set_task("Smoothing", 0.05, 0.35)
-		mesh.split_smooth()
+		if self.smoothing=="NONE":
+			mesh.flatten_faces()
+		mesh.split_smooth(progress)
 
-		mesh.compute_normals()
+		if self.smoothing!="BLENDER":
+			mesh.compute_normals()
 
-		if self.material_tex:
+		if self.material_tex and mesh.materials:
 			mesh.generate_material_uv()
 
-		if mesh.has_uv:
-			progress.set_task("Splitting UVs", 0.35, 0.65)
-			mesh.split_uv()
+		texunits = []
+		if mesh.uv_layers and self.export_uv!="NONE":
+			# Figure out which UV layers to export
+			if self.export_uv=="UNIT0":
+				if mesh.uv_layers[0].unit==0:
+					texunits = [0]
+			else:
+				texunits = range(len(mesh.uv_layers))
+			texunits = [(i, mesh.uv_layers[i]) for i in texunits]
+			texunits = [u for u in texunits if not u[1].hidden]
 
-			mesh.compute_uv()
 			if self.tbn_vecs:
-				mesh.compute_tbn()
+				# TBN coordinates must be generated before vertices are split by any other layer
+				uv_names = [u.name for i, u in texunits]
+				if self.tbn_uvtex in uv_names:
+					tbn_index = uv_names.index(self.tbn_uvtex)
+					unit = texunits[tbn_index]
+					del texunits[tbn_index]
+					texunits.insert(0, unit)
+
+			for i, u in texunits:
+				progress.set_task("Splitting UVs", 0.35+0.3*i/len(texunits), 0.35+0.3*(i+1)/len(texunits))
+				mesh.split_uv(i, progress)
+				if self.tbn_vecs and u.name==self.tbn_uvtex:
+					mesh.compute_uv()
+					mesh.compute_tbn(i)
+
+			mesh.compute_uv()
 
 		strips = []
 		loose = mesh.faces
@@ -264,29 +301,38 @@ class Exporter:
 			out_file.begin("mesh")
 
 		fmt = "NORMAL3"
-		if mesh.has_uv:
-			fmt += "_TEXCOORD2"
+		if texunits:
+			for i, u in texunits:
+				if u.unit==0:
+					fmt += "_TEXCOORD2"
+				else:
+					fmt += "_TEXCOORD2%d"%u.unit
 			if self.tbn_vecs:
 				fmt += "_ATTRIB33_ATTRIB34"
 		fmt += "_VERTEX3"
 		out_file.begin("vertices", fmt)
 		normal = None
-		uv = None
+		uvs = [None]*len(texunits)
 		tan = None
 		bino = None
 		for v in mesh.vertices:
 			if v.normal!=normal:
 				out_file.write("normal3", *v.normal)
 				normal = v.normal
-			if v.uv!=uv:
-				out_file.write("texcoord2", *v.uv)
-				uv = v.uv
-			if v.tan!=tan:
-				out_file.write("attrib3", 3, *v.tan)
-				tan = v.tan
-			if v.bino!=bino:
-				out_file.write("attrib3", 4, *v.bino)
-				bino = v.bino
+			for i, u in texunits:
+				if v.uvs[i]!=uvs[i]:
+					if u.unit==0:
+						out_file.write("texcoord2", *v.uvs[i])
+					else:
+						out_file.write("multitexcoord2", u.unit, *v.uvs[i])
+					uvs[i] = v.uvs[i]
+			if self.tbn_vecs:
+				if v.tan!=tan:
+					out_file.write("attrib3", 3, *v.tan)
+					tan = v.tan
+				if v.bino!=bino:
+					out_file.write("attrib3", 4, *v.bino)
+					bino = v.bino
 			out_file.write("vertex3", *v.co)
 		out_file.end()
 		for s in strips:
@@ -319,31 +365,71 @@ class Exporter:
 			out_file.end()
 			out_file.begin("technique")
 			out_file.begin("pass", '""')
-			if self.material_tex:
-				out_file.begin("material")
-				out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
-				out_file.end()
-				out_file.begin("texunit", 0)
-				out_file.begin("texture2d")
-				out_file.write("min_filter", "NEAREST")
-				out_file.write("mag_filter", "NEAREST")
-				out_file.write("storage", "RGB", len(mesh.materials), 1)
-				texdata = '"'
-				for m in mesh.materials:
-					color = [int(c*255) for c in m.diffuse_color]
-					texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
-				texdata += '"'
-				out_file.write("raw_data", texdata)
-				out_file.end()
-				out_file.end()
-			elif mesh.materials:
-				m = mesh.materials[0]
-				out_file.begin("material")
-				out_file.write("diffuse", m.R, m.G, m.B, 1.0)
-				out_file.write("ambient", m.R*m.amb, m.G*m.amb, m.B*m.amb, 1.0)
-				out_file.write("specular", m.specR*m.spec, m.specG*m.spec, m.specB*m.spec, 1.0)
-				out_file.write("shininess", m.hard);
-				out_file.end()
+			if mesh.materials:
+				if self.material_tex:
+					out_file.begin("material")
+					out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
+					out_file.end()
+					index = 0
+					for u in mesh.uv_layers:
+						if u.name=="material_tex":
+							index = u.unit
+					out_file.begin("texunit", index)
+					out_file.begin("texture2d")
+					out_file.write("min_filter", "NEAREST")
+					out_file.write("mag_filter", "NEAREST")
+					out_file.write("storage", "RGB", len(mesh.materials), 1)
+					texdata = '"'
+					for m in mesh.materials:
+						color = [int(c*255) for c in m.diffuse_color]
+						texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
+					texdata += '"'
+					out_file.write("raw_data", texdata)
+					out_file.end()
+					out_file.end()
+				else:
+					mat = mesh.materials[0]
+					out_file.begin("material")
+					diff = mat.diffuse_color
+					out_file.write("diffuse", diff.r, diff.g, diff.b, 1.0)
+					amb = diff*mat.ambient
+					out_file.write("ambient", amb.r, amb.g, amb.b, 1.0)
+					spec = mat.specular_color*mat.specular_intensity
+					out_file.write("specular", spec.r, spec.g, spec.b, 1.0)
+					out_file.write("shininess", mat.specular_hardness);
+					out_file.end()
+
+				if self.textures!="NONE":
+					for slot in mesh.materials[0].texture_slots:
+						if not slot:
+							continue
+
+						tex = slot.texture
+						if tex.type!="IMAGE":
+							continue
+
+						if slot.uv_layer:
+							for u in mesh.uv_layers:
+								if u.name==slot.uv_layer:
+									index = u.unit
+						else:
+							index = mesh.uv_layers[0].unit
+
+						out_file.begin("texunit", index)
+						if self.textures=="INLINE":
+							out_file.begin("texture2d")
+							out_file.write("min_filter", "LINEAR")
+							out_file.write("storage", "RGBA", tex.image.size[0], tex.image.size[1])
+							texdata = '"'
+							for p in tex.image.pixels:
+								texdata += "\\x%02X"%int(p*255)
+							texdata += '"'
+							out_file.write("raw_data", texdata)
+							out_file.end()
+						else:
+							out_file.write("texture", '"%s"'%tex.image.name)
+						out_file.end()
+
 			out_file.end()
 			out_file.end()