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)