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