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