# SPDX-License-Identifier: GPL-2.0-or-later """Declare shading properties exported to POV textures.""" import bpy from bpy.utils import register_class, unregister_class from bpy.types import PropertyGroup from bpy.props import ( StringProperty, BoolProperty, FloatProperty, PointerProperty, ) class MaterialStrandSettings(PropertyGroup): """Declare strand properties controllable in UI and translated to POV.""" bl_description = ("Strand settings for the material",) blend_distance: FloatProperty( name="Distance", description="Worldspace distance over which to blend in the surface normal", min=0.0, max=10.0, soft_min=0.0, soft_max=10.0, default=0.0, precision=3, ) root_size: FloatProperty( name="Root", description="Start size of strands in pixels or Blender units", min=0.25, default=1.0, precision=5, ) shape: FloatProperty( name="Shape", description="Positive values make strands rounder, negative ones make strands spiky", min=-0.9, max=0.9, default=0.0, precision=3, ) size_min: FloatProperty( name="Minimum", description="Minimum size of strands in pixels", min=0.001, max=10.0, default=1.0, precision=3, ) tip_size: FloatProperty( name="Tip", description="End size of strands in pixels or Blender units", min=0.0, default=1.0, precision=5, ) use_blender_units: BoolProperty( name="Blender Units", description="Use Blender units for widths instead of pixels", default=False, ) use_surface_diffuse: BoolProperty( name="Surface diffuse", description="Make diffuse shading more similar to shading the surface", default=False, ) use_tangent_shading: BoolProperty( name="Tangent Shading", description="Use direction of strands as normal for tangent-shading", default=True, ) uv_layer: StringProperty( name="UV Layer", # icon="GROUP_UVS", description="Name of UV map to override", default="", ) width_fade: FloatProperty( name="Width Fade", description="Transparency along the width of the strand", min=0.0, max=2.0, default=0.0, precision=3, ) # halo # Halo settings for the material # Type: MaterialHalo, (readonly, never None) # darkness # Minnaert darkness # Type: float in [0, 2], default 0.0 # diffuse_color # Diffuse color of the material # Type: float array of 3 items in [0, inf], default (0.0, 0.0, 0.0) # diffuse_fresnel # Power of Fresnel # Type: float in [0, 5], default 0.0 # diffuse_fresnel_factor # Blending factor of Fresnel # Type: float in [0, 5], default 0.0 # diffuse_intensity # Amount of diffuse reflection # Type: float in [0, 1], default 0.0 # diffuse_ramp # Color ramp used to affect diffuse shading # Type: ColorRamp, (readonly) # diffuse_ramp_blend # Blending method of the ramp and the diffuse color # Type: enum in [‘MIX’, ‘ADD’, ‘MULTIPLY’, ‘SUBTRACT’, ‘SCREEN’, ‘DIVIDE’, ‘DIFFERENCE’, ‘DARKEN’, ‘LIGHTEN’, ‘OVERLAY’, ‘DODGE’, ‘BURN’, ‘HUE’, ‘SATURATION’, ‘VALUE’, ‘COLOR’, ‘SOFT_LIGHT’, ‘LINEAR_LIGHT’], default ‘MIX’ # diffuse_ramp_factor # Blending factor (also uses alpha in Colorband) # Type: float in [0, 1], default 0.0 # diffuse_ramp_input # How the ramp maps on the surface # Type: enum in [‘SHADER’, ‘ENERGY’, ‘NORMAL’, ‘RESULT’], default ‘SHADER’ # diffuse_shader # LAMBERT Lambert, Use a Lambertian shader. # OREN_NAYAR Oren-Nayar, Use an Oren-Nayar shader. # TOON Toon, Use a toon shader. # MINNAERT Minnaert, Use a Minnaert shader. # FRESNEL Fresnel, Use a Fresnel shader. # Type: enum in [‘LAMBERT’, ‘OREN_NAYAR’, ‘TOON’, ‘MINNAERT’, ‘FRESNEL’], default ‘LAMBERT’ # diffuse_toon_size # Size of diffuse toon area # Type: float in [0, 3.14], default 0.0 # diffuse_toon_smooth # Smoothness of diffuse toon area # Type: float in [0, 1], default 0.0 # emit # Amount of light to emit # Type: float in [0, inf], default 0.0 # halo # Halo settings for the material # Type: MaterialHalo, (readonly, never None) # invert_z # Render material’s faces with an inverted Z buffer (scanline only) # Type: boolean, default False # light_group # Limit lighting to lamps in this Group # Type: Group # line_color # Line color used for Freestyle line rendering # Type: float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0) # line_priority # The line color of a higher priority is used at material boundaries # Type: int in [0, 32767], default 0 # mirror_color # Mirror color of the material # Type: float array of 3 items in [0, inf], default (0.0, 0.0, 0.0) # node_tree # Node tree for node based materials # Type: NodeTree, (readonly) # offset_z # Give faces an artificial offset in the Z buffer for Z transparency # Type: float in [-inf, inf], default 0.0 # paint_active_slot # Index of active texture paint slot # Type: int in [0, 32767], default 0 # paint_clone_slot # Index of clone texture paint slot # Type: int in [0, 32767], default 0 # pass_index # Index number for the “Material Index” render pass # Type: int in [0, 32767], default 0 # physics # Game physics settings # Type: MaterialPhysics, (readonly, never None) # preview_render_type # Type of preview render # FLAT Flat, Flat XY plane. # SPHERE Sphere, Sphere. # CUBE Cube, Cube. # MONKEY Monkey, Monkey. # HAIR Hair, Hair strands. # SPHERE_A World Sphere, Large sphere with sky. # Type: enum in [‘FLAT’, ‘SPHERE’, ‘CUBE’, ‘MONKEY’, ‘HAIR’, ‘SPHERE_A’], default ‘FLAT’ # roughness # Oren-Nayar Roughness # Type: float in [0, 3.14], default 0.0 # shadow_buffer_bias # Factor to multiply shadow buffer bias with (0 is ignore) # Type: float in [0, 10], default 0.0 # shadow_cast_alpha # Shadow casting alpha, in use for Irregular and Deep shadow buffer # Type: float in [0.001, 1], default 0.0 # shadow_only_type # How to draw shadows # SHADOW_ONLY_OLD Shadow and Distance, Old shadow only method. # SHADOW_ONLY Shadow Only, Improved shadow only method. # SHADOW_ONLY_SHADED Shadow and Shading, Improved shadow only method which also renders lightless areas as shadows. # Type: enum in [‘SHADOW_ONLY_OLD’, ‘SHADOW_ONLY’, ‘SHADOW_ONLY_SHADED’], default ‘SHADOW_ONLY_OLD’ # shadow_ray_bias # Shadow raytracing bias to prevent terminator problems on shadow boundary # Type: float in [0, 0.25], default 0.0 # specular_color # Specular color of the material # Type: float array of 3 items in [0, inf], default (0.0, 0.0, 0.0) # specular_hardness # How hard (sharp) the specular reflection is # Type: int in [1, 511], default 0 # specular_intensity # How intense (bright) the specular reflection is # Type: float in [0, 1], default 0.0 # specular_ior # Specular index of refraction # Type: float in [1, 10], default 0.0 # specular_ramp # Color ramp used to affect specular shading # Type: ColorRamp, (readonly) # specular_ramp_blend # Blending method of the ramp and the specular color # Type: enum in [‘MIX’, ‘ADD’, ‘MULTIPLY’, ‘SUBTRACT’, ‘SCREEN’, ‘DIVIDE’, ‘DIFFERENCE’, ‘DARKEN’, ‘LIGHTEN’, ‘OVERLAY’, ‘DODGE’, ‘BURN’, ‘HUE’, ‘SATURATION’, ‘VALUE’, ‘COLOR’, ‘SOFT_LIGHT’, ‘LINEAR_LIGHT’], default ‘MIX’ # specular_ramp_factor # Blending factor (also uses alpha in Colorband) # Type: float in [0, 1], default 0.0 # specular_ramp_input # How the ramp maps on the surface # Type: enum in [‘SHADER’, ‘ENERGY’, ‘NORMAL’, ‘RESULT’], default ‘SHADER’ # specular_shader # COOKTORR CookTorr, Use a Cook-Torrance shader. # PHONG Phong, Use a Phong shader. # BLINN Blinn, Use a Blinn shader. # TOON Toon, Use a toon shader. # WARDISO WardIso, Use a Ward anisotropic shader. # Type: enum in [‘COOKTORR’, ‘PHONG’, ‘BLINN’, ‘TOON’, ‘WARDISO’], default ‘COOKTORR’ # specular_slope # The standard deviation of surface slope # Type: float in [0, 0.4], default 0.0 # specular_toon_size # Size of specular toon area # Type: float in [0, 1.53], default 0.0 # specular_toon_smooth # Smoothness of specular toon area # Type: float in [0, 1], default 0.0 # strand # Strand settings for the material # Type: MaterialStrand, (readonly, never None) # subsurface_scattering # Subsurface scattering settings for the material # Type: MaterialSubsurfaceScattering, (readonly, never None) # texture_paint_images # Texture images used for texture painting # Type: bpy_prop_collection of Image, (readonly) # texture_paint_slots # Texture slots defining the mapping and influence of textures # Type: bpy_prop_collection of TexPaintSlot, (readonly) # texture_slots # Texture slots defining the mapping and influence of textures # Type: MaterialTextureSlots bpy_prop_collection of MaterialTextureSlot, (readonly) # type # Material type defining how the object is rendered # SURFACE Surface, Render object as a surface. # WIRE Wire, Render the edges of faces as wires (not supported in raytracing). # VOLUME Volume, Render object as a volume. # HALO Halo, Render object as halo particles. # Type: enum in [‘SURFACE’, ‘WIRE’, ‘VOLUME’, ‘HALO’], default ‘SURFACE’ # use_cast_shadows # Allow this material to cast shadows # Type: boolean, default False # use_cast_shadows_only # Make objects with this material appear invisible (not rendered), only casting shadows # Type: boolean, default False # use_cubic # Use cubic interpolation for diffuse values, for smoother transitions # Type: boolean, default False # use_diffuse_ramp # Toggle diffuse ramp operations # Type: boolean, default False # use_face_texture # Replace the object’s base color with color from UV map image textures # Type: boolean, default False # use_face_texture_alpha # Replace the object’s base alpha value with alpha from UV map image textures # Type: boolean, default False # use_full_oversampling # Force this material to render full shading/textures for all anti-aliasing samples # Type: boolean, default False # use_light_group_exclusive # Material uses the light group exclusively - these lamps are excluded from other scene lighting # Type: boolean, default False # use_light_group_local # When linked in, material uses local light group with the same name # Type: boolean, default False # use_mist # Use mist with this material (in world settings) # Type: boolean, default False # use_nodes # Use shader nodes to render the material # Type: boolean, default False # use_object_color # Modulate the result with a per-object color # Type: boolean, default False # use_only_shadow # Render shadows as the material’s alpha value, making the material transparent except for shadowed areas # Type: boolean, default False # use_ray_shadow_bias # Prevent raytraced shadow errors on surfaces with smooth shaded normals (terminator problem) # Type: boolean, default False # use_raytrace # Include this material and geometry that uses it in raytracing calculations # Type: boolean, default False # use_shadeless # Make this material insensitive to light or shadow # Type: boolean, default False # use_shadows # Allow this material to receive shadows # Type: boolean, default False # use_sky # Render this material with zero alpha, with sky background in place (scanline only) # Type: boolean, default False # use_specular_ramp # Toggle specular ramp operations # Type: boolean, default False # use_tangent_shading # Use the material’s tangent vector instead of the normal for shading - for anisotropic shading effects # Type: boolean, default False # use_textures # Enable/Disable each texture # Type: boolean array of 18 items, default (False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False) # use_transparency # Render material as transparent # Type: boolean, default False # use_transparent_shadows # Allow this object to receive transparent shadows cast through other objects # Type: boolean, default False # use_uv_project # Use to ensure UV interpolation is correct for camera projections (use with UV project modifier) # Type: boolean, default False # use_vertex_color_light # Add vertex colors as additional lighting # Type: boolean, default False # use_vertex_color_paint # Replace object base color with vertex colors (multiply with ‘texture face’ face assigned textures) # Type: boolean, default False # volume # Volume settings for the material # Type: MaterialVolume, (readonly, never None) """ (mat.type in {'SURFACE', 'WIRE', 'VOLUME'}) "use_transparency") mat.use_transparency and mat.pov.transparency_method == 'Z_TRANSPARENCY' col.prop(mat, "use_raytrace") col.prop(mat, "use_full_oversampling") sub.prop(mat, "use_sky") col.prop(mat, "use_cast_shadows", text="Cast") col.prop(mat, "use_cast_shadows_only", text="Cast Only") col.prop(mat, "use_cast_buffer_shadows") sub.active = mat.use_cast_buffer_shadows sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha") col.prop(mat, "use_cast_approximate") col.prop(mat, "diffuse_color", text="") sub.active = (not mat.use_shadeless) sub.prop(mat, "diffuse_intensity", text="Intensity") col.prop(mat, "diffuse_shader", text="") col.prop(mat, "use_diffuse_ramp", text="Ramp") if mat.diffuse_shader == 'OREN_NAYAR': col.prop(mat, "roughness") elif mat.diffuse_shader == 'MINNAERT': col.prop(mat, "darkness") elif mat.diffuse_shader == 'TOON': row.prop(mat, "diffuse_toon_size", text="Size") row.prop(mat, "diffuse_toon_smooth", text="Smooth") elif mat.diffuse_shader == 'FRESNEL': row.prop(mat, "diffuse_fresnel", text="Fresnel") row.prop(mat, "diffuse_fresnel_factor", text="Factor") if mat.use_diffuse_ramp: col.template_color_ramp(mat, "diffuse_ramp", expand=True) row.prop(mat, "diffuse_ramp_input", text="Input") row.prop(mat, "diffuse_ramp_blend", text="Blend") col.prop(mat, "diffuse_ramp_factor", text="Factor") col.prop(mat, "specular_color", text="") col.prop(mat, "specular_intensity", text="Intensity") col.prop(mat, "specular_shader", text="") col.prop(mat, "use_specular_ramp", text="Ramp") if mat.pov.specular_shader in {'COOKTORR', 'PHONG'}: col.prop(mat, "specular_hardness", text="Hardness") elif mat.pov.specular_shader == 'BLINN': row.prop(mat, "specular_hardness", text="Hardness") row.prop(mat, "specular_ior", text="IOR") elif mat.pov.specular_shader == 'WARDISO': col.prop(mat, "specular_slope", text="Slope") elif mat.pov.specular_shader == 'TOON': row.prop(mat, "specular_toon_size", text="Size") row.prop(mat, "specular_toon_smooth", text="Smooth") if mat.use_specular_ramp: layout.separator() layout.template_color_ramp(mat, "specular_ramp", expand=True) layout.separator() row = layout.row() row.prop(mat, "specular_ramp_input", text="Input") row.prop(mat, "specular_ramp_blend", text="Blend") layout.prop(mat, "specular_ramp_factor", text="Factor") XXX remove unused props and relayout as done for transparent sky class MATERIAL_PT_halo(MaterialButtonsPanel, Panel): bl_label = "Halo" COMPAT_ENGINES = {'BLENDER_RENDER'} @classmethod def poll(cls, context): mat = context.material engine = context.scene.render.engine return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES) def draw(self, context): layout = self.layout mat = context.material # don't use node material halo = mat.pov.halo def number_but(layout, toggle, number, name, color): row = layout.row(align=True) row.prop(halo, toggle, text="") sub = row.column(align=True) sub.active = getattr(halo, toggle) sub.prop(halo, number, text=name, translate=False) if not color == "": sub.prop(mat, color, text="") split = layout.split() col = split.column() col.prop(mat, "alpha") col.prop(mat, "diffuse_color", text="") col.prop(halo, "seed") col = split.column() col.prop(halo, "size") col.prop(halo, "hardness") col.prop(halo, "add") layout.label(text="Options:") split = layout.split() col = split.column() col.prop(halo, "use_texture") col.prop(halo, "use_vertex_normal") col.prop(halo, "use_extreme_alpha") col.prop(halo, "use_shaded") col.prop(halo, "use_soft") col = split.column() number_but(col, "use_ring", "ring_count", iface_("Rings"), "mirror_color") number_but(col, "use_lines", "line_count", iface_("Lines"), "specular_color") number_but(col, "use_star", "star_tip_count", iface_("Star Tips"), "") class MATERIAL_PT_flare(MaterialButtonsPanel, Panel): bl_label = "Flare" COMPAT_ENGINES = {'BLENDER_RENDER'} @classmethod def poll(cls, context): mat = context.material engine = context.scene.render.engine return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES) def draw_header(self, context): halo = context.material.pov.halo self.layout.prop(halo, "use_flare_mode", text="") def draw(self, context): layout = self.layout mat = context.material # don't use node material halo = mat.pov.halo layout.active = halo.use_flare_mode split = layout.split() col = split.column() col.prop(halo, "flare_size", text="Size") col.prop(halo, "flare_boost", text="Boost") col.prop(halo, "flare_seed", text="Seed") col = split.column() col.prop(halo, "flare_subflare_count", text="Subflares") col.prop(halo, "flare_subflare_size", text="Subsize") """ classes = ( MaterialStrandSettings, ) def register(): for cls in classes: register_class(cls) bpy.types.Material.strand = PointerProperty(type=MaterialStrandSettings) def unregister(): del bpy.types.Material.strand for cls in reversed(classes): unregister_class(cls)