]> git.tdb.fi Git - libs/gl.git/blob - blender/io_mspgl/properties.py
Flip normal if a surface faces away from the camera
[libs/gl.git] / blender / io_mspgl / properties.py
1 import bpy
2
3 class MspGLSceneProperties(bpy.types.Panel):
4         bl_idname = "SCENE_PT_mspgl_properties"
5         bl_label = "MspGL properties"
6         bl_space_type = "PROPERTIES"
7         bl_region_type = "WINDOW"
8         bl_context = "scene"
9
10         def draw(self, context):
11                 scene = context.scene
12
13                 self.layout.prop(scene, "export_disposition")
14
15 class MspGLWorldProperties(bpy.types.Panel):
16         bl_idname = "WORLD_PT_mspgl_properties"
17         bl_label = "MspGL properties"
18         bl_space_type = "PROPERTIES"
19         bl_region_type = "WINDOW"
20         bl_context = "world"
21
22         def draw(self, context):
23                 world = context.scene.world
24
25                 self.layout.prop(world, "use_sky")
26                 if world.use_sky:
27                         self.layout.prop(world, "sun_light")
28
29 class MspGLMeshProperties(bpy.types.Panel):
30         bl_idname = "MESH_PT_mspgl_properties"
31         bl_label = "MspGL properties"
32         bl_space_type = "PROPERTIES"
33         bl_region_type = "WINDOW"
34         bl_context = "data"
35
36         @classmethod
37         def poll(cls, context):
38                 return context.active_object.type=="MESH"
39
40         def draw(self, context):
41                 mesh = context.active_object.data
42
43                 self.layout.prop(mesh, "smoothing")
44                 self.layout.prop(mesh, "use_strips")
45
46                 self.layout.separator()
47
48                 col = self.layout.column()
49                 col.label(text="Data selection")
50                 col.prop(mesh, "use_lines")
51                 col.prop(mesh, "vertex_groups")
52                 col.prop(mesh, "max_groups_per_vertex")
53
54                 self.layout.separator()
55
56                 col = self.layout.column()
57                 col.label(text="Texturing")
58                 col.prop(mesh, "use_uv")
59                 col.prop(mesh, "tangent_vecs")
60                 col.prop(mesh, "tangent_uvtex")
61
62 class MspGLObjectProperties(bpy.types.Panel):
63         bl_idname = "OBJECT_PT_mspgl_properties"
64         bl_label = "MspGL properties"
65         bl_space_type = "PROPERTIES"
66         bl_region_type = "WINDOW"
67         bl_context = "object"
68
69         @classmethod
70         def poll(cls, context):
71                 return context.active_object.type=="MESH"
72
73         def draw(self, context):
74                 obj = context.active_object
75
76                 self.layout.prop(obj, "compound")
77                 self.layout.prop(obj, "lod_for_parent")
78                 if obj.lod_for_parent:
79                         self.layout.prop(obj, "lod_index")
80
81 class MspGLMaterialProperties(bpy.types.Panel):
82         bl_idname = "MATERIAL_PT_mspgl_properties"
83         bl_label = "MspGL properties"
84         bl_space_type = "PROPERTIES"
85         bl_region_type = "WINDOW"
86         bl_context = "material"
87
88         @classmethod
89         def poll(cls, context):
90                 return context.active_object.active_material is not None
91
92         def draw(self, context):
93                 mat = context.active_object.active_material
94                 if not mat:
95                         return
96
97                 self.layout.prop(mat, "render_mode")
98                 if mat.render_mode=='CUSTOM':
99                         self.layout.label(text="Render methods")
100                         self.layout.template_list("MATERIAL_UL_mspgl_render_methods", "", mat, "render_methods", mat, "active_render_method_index")
101                         row = self.layout.row()
102                         row.operator("material.add_render_method")
103                         row.operator("material.remove_render_method")
104
105                         if mat.active_render_method_index<len(mat.render_methods):
106                                 method = mat.render_methods[mat.active_render_method_index]
107                                 self.layout.prop(method, "tag")
108                                 self.layout.prop(method, "shader")
109                                 self.layout.prop(method, "use_material")
110
111                         self.layout.separator()
112                 elif mat.render_mode=='EXTERNAL':
113                         self.layout.prop(mat, "technique")
114                 if mat.render_mode=='BUILTIN':
115                         self.layout.prop(mat, "receive_shadows")
116                         self.layout.prop(mat, "image_based_lighting")
117                 self.layout.prop(mat, "array_atlas")
118                 if mat.array_atlas:
119                         self.layout.prop(mat, "array_layer")
120                 if mat.render_mode!='EXTERNAL':
121                         self.layout.prop(mat, "material_atlas")
122                 if mat.render_mode=='CUSTOM':
123                         self.layout.separator()
124                         self.layout.label(text="Uniform values")
125                         self.layout.template_list("MATERIAL_UL_mspgl_uniforms", "", mat, "uniforms", mat, "active_uniform_index")
126                         row = self.layout.row()
127                         row.operator("material.add_uniform")
128                         row.operator("material.remove_uniform")
129
130                         if mat.active_uniform_index<len(mat.uniforms):
131                                 uniform = mat.uniforms[mat.active_uniform_index]
132                                 self.layout.prop(uniform, "name")
133                                 self.layout.prop(uniform, "size")
134                                 row = self.layout.row(align=True)
135                                 row.label(text="Values")
136                                 for i in range(uniform.size):
137                                         row.prop(uniform, "values", text="", index=i)
138
139 class MspGLTextureNodeProperties(bpy.types.Panel):
140         bl_idname = "NODE_PT_mspgl_properties"
141         bl_label = "MspGL properties"
142         bl_space_type = "NODE_EDITOR"
143         bl_region_type = "UI"
144         bl_category = "Item"
145
146         @classmethod
147         def poll(cls, context):
148                 node = context.active_node
149                 return node and node.type=='TEX_IMAGE'
150
151         def draw(self, context):
152                 node = context.active_node
153                 if not node:
154                         return
155
156                 self.layout.prop(node, "use_mipmap")
157                 self.layout.prop(node, "max_anisotropy")
158
159 class MspGLLightProperties(bpy.types.Panel):
160         bl_idname = "LIGHT_PT_mspgl_properties"
161         bl_label = "MspGL properties"
162         bl_space_type = "PROPERTIES"
163         bl_region_type = "WINDOW"
164         bl_context = "data"
165
166         @classmethod
167         def poll(cls, context):
168                 return context.active_object.type=="LIGHT"
169
170         def draw(self, context):
171                 light = context.active_object.data
172
173                 if light.use_shadow:
174                         self.layout.prop(light, "shadow_map_size")
175
176 class MspGLRenderProperties(bpy.types.Panel):
177         bl_idname = "RENDER_PT_mspgl_properties"
178         bl_label = "MspGL properties"
179         bl_space_type = "PROPERTIES"
180         bl_region_type = "WINDOW"
181         bl_context = "render"
182
183         def draw(self, context):
184                 scene = context.scene
185                 self.layout.prop(scene, "use_hdr")
186                 if scene.eevee.use_gtao:
187                         self.layout.prop(scene, "ao_samples")
188
189 class MspGLRenderMethod(bpy.types.PropertyGroup):
190         tag: bpy.props.StringProperty(name="Tag", description="Tag of the render method")
191         shader: bpy.props.StringProperty(name="Shader", description="Shader to use")
192         use_material: bpy.props.BoolProperty(name="Use material", description="Use material properties in this render method")
193
194 class MspGLRenderMethodList(bpy.types.UIList):
195         bl_idname = "MATERIAL_UL_mspgl_render_methods"
196
197         def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
198                 method = item
199                 if self.layout_type=="GRID":
200                         layout.label(text="", icon_value=icon)
201                 else:
202                         layout.prop(method, "tag", text="", emboss=False, icon_value=icon)
203                         layout.label(text=(method.shader or "(no shader)"))
204
205 class MspGLUniform(bpy.types.PropertyGroup):
206         name: bpy.props.StringProperty(name="Name", description="Name of the uniform variable")
207         size: bpy.props.IntProperty(name="Size", description="Number of elements in the uniform", min=1, max=4, default=4)
208         values: bpy.props.FloatVectorProperty(name="Values", description="Values stored in the uniform", size=4)
209
210 class MspGLUniformList(bpy.types.UIList):
211         bl_idname = "MATERIAL_UL_mspgl_uniforms"
212
213         def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
214                 uniform = item
215                 if self.layout_type=="GRID":
216                         layout.label(text="", icon_value=icon)
217                 else:
218                         layout.prop(uniform, "name", text="", emboss=False, icon_value=icon)
219                         layout.label(text="({})".format(", ".join("{:.3f}".format(v) for v in uniform.values[:uniform.size])))
220
221 classes = [MspGLSceneProperties, MspGLWorldProperties, MspGLMeshProperties, MspGLObjectProperties, MspGLMaterialProperties,
222         MspGLTextureNodeProperties, MspGLLightProperties, MspGLRenderProperties, MspGLRenderMethod,
223         MspGLRenderMethodList, MspGLUniform, MspGLUniformList]
224
225 def register_properties():
226         for c in classes:
227                 bpy.utils.register_class(c)
228
229         bpy.types.Scene.export_disposition = bpy.props.EnumProperty(name="Export disposition", description="What to do with this scene during project export", default="IGNORE",
230                 items=(("IGNORE", "Ignore", "The scene won't be exported"),
231                         ("CONTENTS", "Contents only", "Objects in the scene will be exported, but not the scene itself"),
232                         ("SCENE", "Scene", "The scene will be exported"),
233                         ("SEQUENCE", "Sequence", "The scene will be exported along with a rendering sequence")))
234         bpy.types.Scene.use_hdr = bpy.props.BoolProperty(name="High dynamic range", description="Use a range render target with a floating point format", default=False)
235         bpy.types.Scene.ao_samples = bpy.props.IntProperty(name="Ambient occlusion samples", description="Number of samples to use for ambient occlusion", min=8, max=128, default=32)
236
237         bpy.types.World.use_sky = bpy.props.BoolProperty(name="Realtime sky", description="Use a realtime rendered sky background", default=False)
238         bpy.types.World.sun_light = bpy.props.PointerProperty(type=bpy.types.Light, name="Sun", description="Light to use as sun for the sky")
239
240         bpy.types.Mesh.smoothing = bpy.props.EnumProperty(name="Smoothing", description="Smoothing method to use", default="MSPGL",
241                 items=(("NONE", "None", "No smoothing"),
242                         ("BLENDER", "Blender", "Use Blender's vertex normals"),
243                         ("MSPGL", "MspGL", "Compute vertex normals internally")))
244         bpy.types.Mesh.use_lines = bpy.props.BoolProperty(name="Include lines", description="Include edges without faces as lines", default=False)
245         bpy.types.Mesh.use_strips = bpy.props.BoolProperty(name="Use strips", description="Combine the mesh's triangles into triangle strips", default=True)
246         bpy.types.Mesh.vertex_groups = bpy.props.BoolProperty(name="Vertex groups", description="Include vertex groups and weights", default=False)
247         bpy.types.Mesh.max_groups_per_vertex = bpy.props.IntProperty(name="Max groups", description="Maximum amount of groups per vertex", min=1, max=4, default=2)
248         bpy.types.Mesh.use_uv = bpy.props.EnumProperty(name="Use UV", description="Use UV coordinates", default="UNIT0",
249                 items=(("NONE", "None", "Ignore all UV coordinates"),
250                         ("UNIT0", "Unit 0", "Use UV coordinates for unit 0"),
251                         ("ALL", "All", "Use all UV coordinates")))
252         bpy.types.Mesh.tangent_vecs = bpy.props.EnumProperty(name="Tangent vectors", description="Compute tangent vectors for vertices", default="AUTO",
253                 items=(("NO", "No", "Do not export tangent vectors"),
254                         ("AUTO", "Auto", "Automatically determine the need for tangent vectors"),
255                         ("YES", "Yes", "Always export tangent vectors")))
256         bpy.types.Mesh.tangent_uvtex = bpy.props.StringProperty(name="Tangent UV layer", description="UV layer to use as basis for tangent vectors", default="")
257
258         bpy.types.Object.compound = bpy.props.BoolProperty(name="Compound with parent", description="Join this object to its parent when exporting")
259         bpy.types.Object.lod_for_parent = bpy.props.BoolProperty(name="LoD for parent", description="This object is a level of detail for its parent")
260         bpy.types.Object.lod_index = bpy.props.IntProperty(name="LoD index", description="Index of the level of detail", min=1, max=16, default=1)
261
262         bpy.types.Material.render_mode = bpy.props.EnumProperty(name="Render mode", description="How this material should be rendered", default="BUILTIN",
263                 items=(("BUILTIN", "Built-in", "Use built-in shaders"),
264                         ("CUSTOM", "Custom shaders", "Use custom shaders"),
265                         ("EXTERNAL", "External technique", "Use an externally defined technique")))
266         bpy.types.Material.technique = bpy.props.StringProperty(name="Custom technique", description="Name of an external technique to use for rendering")
267         bpy.types.Material.render_methods = bpy.props.CollectionProperty(type=MspGLRenderMethod, name="Render methods", description="Custom render methods to use for rendering")
268         bpy.types.Material.active_render_method_index = bpy.props.IntProperty("Active render method index")
269         bpy.types.Material.receive_shadows = bpy.props.BoolProperty(name="Receive shadows", description="Receive shadows from a shadow map", default=True)
270         bpy.types.Material.image_based_lighting = bpy.props.BoolProperty(name="Image based lighting", description="Use an environment map for ambient lighting", default=False)
271         bpy.types.Material.array_atlas = bpy.props.BoolProperty(name="Texture array atlas", description="The material is stored in a texture array")
272         bpy.types.Material.array_layer = bpy.props.IntProperty("Texture array layer", description="Layer of the texture array atlas to use")
273         bpy.types.Material.material_atlas = bpy.props.BoolProperty(name="Material atlas", description="Make this material part of a material atlas")
274         bpy.types.Material.uniforms = bpy.props.CollectionProperty(type=MspGLUniform, name="Uniforms", description="Uniform variables to add to the technique")
275         bpy.types.Material.active_uniform_index = bpy.props.IntProperty("Active uniform index")
276
277         bpy.types.ShaderNodeTexImage.use_mipmap = bpy.props.BoolProperty(name="Use mipmaps", description="Use mipmaps (automatically generated) for the texture", default=True)
278         bpy.types.ShaderNodeTexImage.max_anisotropy = bpy.props.FloatProperty(name="Maximum anisotropy", description="Maximum anisotropy to use in texture filtering", min=1, max=16, default=1)
279
280         bpy.types.Light.shadow_map_size = bpy.props.EnumProperty(name="Shadow map size", description="Size of shadow map to use for rendering shadows", default="4096",
281                 items=(("256", "256", ""),
282                         ("512", "512", ""),
283                         ("1024", "1024", ""),
284                         ("2048", "2048", ""),
285                         ("4096", "4096", ""),
286                         ("8192", "8192", ""),
287                         ("16384", "16384", "")))
288
289 def unregister_properties():
290         for c in classes:
291                 bpy.utils.unregister_class(c)