]> git.tdb.fi Git - libs/gl.git/blob - blender/io_mspgl/export_object.py
Use a #pragma as shader stage delimiter
[libs/gl.git] / blender / io_mspgl / export_object.py
1 import os
2 import mathutils
3
4 def linear_to_srgb(l):
5         if l<0.0031308:
6                 return 12.92*l
7         else:
8                 return 1.055*(l**(1/2.4))-0.055
9
10 def image_name(i):
11         fp = i.filepath
12         if fp:
13                 return os.path.split(fp)[1]
14         else:
15                 return i.name
16
17 def external_name(out_file, ext, index):
18         path, base = os.path.split(out_file.filename)
19         base = os.path.splitext(base)[0]
20         if index>0:
21                 base += "_lod{}".format(index)
22         return path, base+ext
23
24
25 class ObjectExporter:
26         def __init__(self):
27                 self.material_tex = False
28                 self.srgb_colors = True
29                 self.textures = "REF"
30                 self.separate_mesh = False
31                 self.shared_mesh = True
32                 self.separate_tech = False
33                 self.external_tech = True
34                 self.shared_tech = True
35                 self.export_lods = True
36
37         def export(self, context, out_file, objs=None, progress=None):
38                 if objs is None:
39                         obj = context.active_object
40                 else:
41                         obj = objs[0]
42
43                 lods = [obj]
44                 for c in obj.children:
45                         if c.lod_for_parent:
46                                 if c.lod_index>=len(lods):
47                                         lods += [None]*(c.lod_index+1-len(lods))
48                                 lods[c.lod_index] = c
49
50                 from .outfile import open_output
51                 out_file = open_output(out_file)
52
53                 p1 = max(((v.co, v.co.length) for v in obj.data.vertices), key=lambda x:x[1])[0]
54                 p2 = max(((v.co, (v.co-p1).length) for v in obj.data.vertices), key=lambda x:x[1])[0]
55                 center = (p1+p2)/2
56                 radius = (p1-p2).length/2
57                 for v in obj.data.vertices:
58                         d = v.co-center
59                         if d.length>radius:
60                                 center += d*(1-radius/d.length)/2
61                                 radius = (radius+d.length)/2
62
63                 out_file.write("bounding_sphere_hint", center[0], center[1], center[2], radius)
64
65                 prev_mesh = None
66                 prev_tech = (None, None)
67                 for i, l in enumerate(lods):
68                         if i>0:
69                                 out_file.begin("level_of_detail", i)
70                                 objs = [l]
71
72                         if i==0 or l.data.name!=prev_mesh:
73                                 mesh = self.export_object_mesh(context, out_file, l, objs, progress)
74                                 prev_mesh = l.data.name
75
76                         same_tech = True
77                         mat = None
78                         if l.material_slots and l.material_slots[0].material:
79                                 mat = l.material_slots[0].material.name
80                                 if mat!=prev_tech[1]:
81                                         same_tech = False
82                         if self.external_tech and l.technique!=prev_tech[0]:
83                                 same_tech = False
84                         if i==0 or not same_tech:
85                                 self.export_object_technique(l, mesh, out_file, i)
86                                 prev_tech = (l.technique, mat)
87
88                         if i>0:
89                                 out_file.end()
90
91         def export_object_mesh(self, context, out_file, lod, objs, progress):
92                 from .export_mesh import MeshExporter
93                 mesh_export = MeshExporter()
94                 for k, v in self.__dict__.items():
95                         setattr(mesh_export, k, v)
96
97                 lod_index = 0
98                 if lod.lod_for_parent:
99                         lod_index = lod.lod_index
100
101                 if self.separate_mesh:
102                         from .outfile import open_output
103                         path, name = external_name(out_file, ".mesh", lod_index)
104                         if self.shared_mesh:
105                                 name = lod.data.name+".mesh"
106                         mesh_out = open_output(os.path.join(path, name))
107                         mesh = mesh_export.export(context, mesh_out, objs, progress)
108                         out_file.write("mesh", '"{}"'.format(name))
109                 else:
110                         out_file.begin("mesh")
111                         mesh = mesh_export.export(context, out_file, objs, progress)
112                         out_file.end()
113
114                 return mesh
115
116         def export_object_technique(self, obj, mesh, out_file, lod_index):
117                 if self.srgb_colors:
118                         self.colormap = linear_to_srgb
119                 else:
120                         self.colormap = lambda x: x
121
122                 material = None
123                 if obj.material_slots:
124                         material = obj.material_slots[0].material
125
126                 from .outfile import open_output
127                 path, name = external_name(out_file, ".tech", lod_index)
128
129                 if self.external_tech and obj.technique:
130                         if obj.inherit_tech and material and (obj.override_material or material.texture_slots):
131                                 out_file.begin("technique")
132                                 out_file.begin("inherit", '"{}"'.format(obj.technique))
133                                 for slot in material.texture_slots:
134                                         if slot and slot.texture.type=="IMAGE":
135                                                 name = image_name(slot.texture.image)
136                                                 if slot.use_map_color_diffuse:
137                                                         out_file.write("texture", '"diffuse_map"', '"{}"'.format(name))
138                                                 elif slot.use_map_normal:
139                                                         out_file.write("texture", '"normal_map"', '"{}"'.format(name))
140                                 if obj.override_material:
141                                         mat_name = material.name+".mat"
142                                         mat_out = open_output(os.path.join(path, mat_name))
143                                         self.export_material(material, mat_out)
144                                         out_file.write("material", '""', '"{}"'.format(mat_name))
145                                 out_file.end()
146                                 out_file.end()
147                         else:
148                                 out_file.write("technique", '"{}"'.format(obj.technique))
149                 elif self.separate_tech:
150                         if self.shared_tech and material:
151                                 name = material.name+".tech"
152                         tech_out = open_output(os.path.join(path, name))
153                         self.export_technique_definition(material, mesh, tech_out)
154                         out_file.write("technique", '"{}"'.format(name))
155                 else:
156                         out_file.begin("technique")
157                         self.export_technique_definition(material, mesh, out_file)
158                         out_file.end()
159
160         def export_technique_definition(self, material, mesh, out_file):
161                 out_file.begin("pass", '""')
162                 if material:
163                         cm = self.colormap
164
165                         if self.material_tex:
166                                 out_file.begin("material")
167                                 out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
168                                 out_file.end()
169                                 index = 0
170                                 for u in mesh.uv_layers:
171                                         if u.name=="material_tex":
172                                                 index = u.unit
173                                 out_file.begin("texunit", index)
174                                 out_file.begin("texture2d")
175                                 out_file.write("min_filter", "NEAREST")
176                                 out_file.write("mag_filter", "NEAREST")
177                                 out_file.write("storage", "RGB", len(mesh.materials), 1)
178                                 texdata = '"'
179                                 for m in mesh.materials:
180                                         color = [int(cm(c)*255) for c in m.diffuse_color*mat.diffuse_intensity]
181                                         texdata += "\\x%02X\\x%02X\\x%02X"%tuple(color)
182                                 texdata += '"'
183                                 out_file.write("raw_data", texdata)
184                                 out_file.end()
185                                 out_file.end()
186                         else:
187                                 out_file.begin("material")
188                                 self.export_material(material, out_file)
189                                 out_file.end()
190
191                         if self.textures!="NONE":
192                                 for slot in material.texture_slots:
193                                         if not slot:
194                                                 continue
195
196                                         tex = slot.texture
197                                         if tex.type!="IMAGE":
198                                                 continue
199
200                                         if slot.uv_layer:
201                                                 for u in mesh.uv_layers:
202                                                         if u.name==slot.uv_layer:
203                                                                 index = u.unit
204                                         else:
205                                                 index = mesh.uv_layers[0].unit
206
207                                         out_file.begin("texunit", index)
208                                         if self.textures=="INLINE":
209                                                 out_file.begin("texture2d")
210                                                 out_file.write("min_filter", "LINEAR")
211                                                 out_file.write("storage", "RGBA", tex.image.size[0], tex.image.size[1])
212                                                 texdata = '"'
213                                                 for p in tex.image.pixels:
214                                                         texdata += "\\x%02X"%int(p*255)
215                                                 texdata += '"'
216                                                 out_file.write("raw_data", texdata)
217                                                 out_file.end()
218                                         else:
219                                                 out_file.write("texture", '"%s"'%image_name(tex.image))
220                                         out_file.end()
221
222                 out_file.end()
223
224         def export_material(self, mat, out_file):
225                 cm = self.colormap
226                 if any((s and s.use_map_color_diffuse) for s in mat.texture_slots):
227                         out_file.write("diffuse", 1.0, 1.0, 1.0, 1.0)
228                         amb = cm(mat.ambient)
229                         out_file.write("ambient", amb, amb, amb, 1.0)
230                 else:
231                         diff = mat.diffuse_color*mat.diffuse_intensity
232                         out_file.write("diffuse", cm(diff.r), cm(diff.g), cm(diff.b), 1.0)
233                         amb = diff*mat.ambient
234                         out_file.write("ambient", cm(amb.r), cm(amb.g), cm(amb.b), 1.0)
235                 spec = mat.specular_color*mat.specular_intensity
236                 out_file.write("specular", spec.r, spec.g, spec.b, 1.0)
237                 out_file.write("shininess", mat.specular_hardness);