Add an option to export colors as sRGB

[libs/gl.git] / blender / io_mspgl / export_mesh.py

diff --git a/blender/io_mspgl/export_mesh.py b/blender/io_mspgl/export_mesh.py
index 3f0771fe426b60ad1a59d4fbeb47f85016c5a686..30a5b4630a145efaaa0829f1b118b176a5b4ff66 100644 (file)
--- a/blender/io_mspgl/export_mesh.py
+++ b/blender/io_mspgl/export_mesh.py
@@ -1,6 +1,13 @@
+import itertools
 import bpy
 from .outfile import OutFile
 
+def linear_to_srgb(l):
+       if l<0.0031308:
+               return 12.92*l
+       else:
+               return 1.055*(l**(1/2.4))-0.055
+
 class VertexCache:
        def __init__(self, size):
                self.size = size
@@ -46,8 +53,11 @@ class MeshExporter:
                self.compound = False
                self.object = False
                self.material_tex = False
+               self.srgb_colors = True
                self.textures = "REF"
                self.smoothing = "MSPGL"
+               self.export_groups = False
+               self.max_groups = 2
 
        def stripify(self, mesh, progress = None):
                for f in mesh.faces:
@@ -227,6 +237,18 @@ class MeshExporter:
                if self.smoothing!="BLENDER":
                        mesh.compute_normals()
 
+               if self.export_groups:
+                       mesh.sort_vertex_groups(self.max_groups)
+
+                       # Create a mapping from vertex group indices to bone indices
+                       group_index_map = dict((i, i) for i in range(len(objs[0].vertex_groups)))
+                       if objs[0].parent and objs[0].parent.type=="ARMATURE":
+                               armature = objs[0].parent.data
+                               bone_indices = dict((armature.bones[i].name, i) for i in range(len(armature.bones)))
+                               for g in objs[0].vertex_groups:
+                                       if g.name in bone_indices:
+                                               group_index_map[g.index] = bone_indices[g.name]
+
                if self.material_tex and mesh.materials:
                        mesh.generate_material_uv()
 
@@ -271,21 +293,24 @@ class MeshExporter:
                if self.object:
                        out_file.begin("mesh")
 
-               fmt = "NORMAL3"
+               fmt = ["NORMAL3"]
                if texunits:
                        for i, u in texunits:
                                if u.unit==0:
-                                       fmt += "_TEXCOORD2"
+                                       fmt.append("TEXCOORD2")
                                else:
-                                       fmt += "_TEXCOORD2%d"%u.unit
+                                       fmt.append("TEXCOORD2_%d"%u.unit)
                        if self.tbn_vecs:
-                               fmt += "_ATTRIB33_ATTRIB34"
-               fmt += "_VERTEX3"
-               out_file.begin("vertices", fmt)
+                               fmt += ["TANGENT3", "BINORMAL3"]
+               if self.export_groups:
+                       fmt.append("ATTRIB%d_5"%(self.max_groups*2))
+               fmt.append("VERTEX3")
+               out_file.begin("vertices", *fmt)
                normal = None
                uvs = [None]*len(texunits)
                tan = None
                bino = None
+               group = None
                for v in mesh.vertices:
                        if v.normal!=normal:
                                out_file.write("normal3", *v.normal)
@@ -299,11 +324,19 @@ class MeshExporter:
                                        uvs[i] = v.uvs[i]
                        if self.tbn_vecs:
                                if v.tan!=tan:
-                                       out_file.write("attrib3", 3, *v.tan)
+                                       out_file.write("tangent3", *v.tan)
                                        tan = v.tan
                                if v.bino!=bino:
-                                       out_file.write("attrib3", 4, *v.bino)
+                                       out_file.write("binormal3", *v.bino)
                                        bino = v.bino
+                       if self.export_groups:
+                               group_attr = [(group_index_map[g.group], g.weight*v.group_weight_scale) for g in v.groups[:self.max_groups]]
+                               while len(group_attr)<self.max_groups:
+                                       group_attr.append((0, 0.0))
+                               group_attr = list(itertools.chain(*group_attr))
+                               if group_attr!=group:
+                                       out_file.write("attrib%d"%len(group_attr), 5, *group_attr)
+                                       group = group_attr
                        out_file.write("vertex3", *v.co)
                out_file.end()
                for s in strips:
@@ -337,6 +370,11 @@ class MeshExporter:
                        out_file.begin("technique")
                        out_file.begin("pass", '""')
                        if mesh.materials:
+                               if self.srgb_colors:
+                                       cm = linear_to_srgb
+                               else:
+                                       cm = lambda x: x
+
                                if self.material_tex:
                                        out_file.begin("material")
                                        out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
@@ -352,7 +390,7 @@ class MeshExporter:
                                        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]
+                                               color = [int(cm(c)*255) for c in m.diffuse_color]
                                                texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
                                        texdata += '"'
                                        out_file.write("raw_data", texdata)
@@ -361,10 +399,15 @@ class MeshExporter:
                                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)
+                                       if any((s and s.use_map_color_diffuse) for s in mat.texture_slots):
+                                               out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
+                                               amb = cm(mat.ambient)
+                                               out_file.write("ambient", amb, amb, amb, 1.0)
+                                       else:
+                                               diff = mat.diffuse_color
+                                               out_file.write("diffuse", cm(diff.r), cm(diff.g), cm(diff.b), 1.0)
+                                               amb = diff*mat.ambient
+                                               out_file.write("ambient", cm(amb.r), cm(amb.g), cm(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);