Formatting and fixes

* Moved: some existing functions into new separate files to improve code
readability (detailed in __init__.py docstring)

* Remove: max_intersections deprecated in pov 3.8

* Add: Validate utf-8 characters with specific API function at session's
first script init

* Add : Icons to some text fields and inviting labels

* Change default camera normal perturbation value to non zero since its
use is first driven by a boolean toggle

* Change: lists (vectors and indices) are now exported in one line by
default for better manual scene overview and debugging

* Change: a couple of tooltips corrections

* Change : renamed many variables and functions to snake_case according
to recommanded style guides

* Fix : Heightfield primitive (forward slashes were expected for
displacement texture path)

* Fix : Text nippet insertion operator

* Fix : added console print tip to check executable path on failure to
process

* Fix : tweaked finished render say command for Linux

* Fix : interface of some shader nodes broken since 2.8 api changes

* Fix : export hair particles

1 files changed, 2290 insertions, 0 deletions

diff --git a/render_povray/shading_properties.py b/render_povray/shading_properties.py
new file mode 100755
index 00000000..18895eba
--- /dev/null
+++ b/render_povray/shading_properties.py
@@ -0,0 +1,2290 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# <pep8 compliant>
+"""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 (
+    FloatVectorProperty,
+    StringProperty,
+    BoolProperty,
+    IntProperty,
+    FloatProperty,
+    EnumProperty,
+    PointerProperty,
+)
+
+
+def check_material(mat):
+    """Check that material node tree is not empty if use node button is on"""
+    if mat is not None:
+        if mat.use_nodes:
+            if not mat.node_tree:  # FORMERLY : #mat.active_node_material is not None:
+                return True
+            return False
+        return True
+    return False
+
+
+def pov_context_tex_datablock(context):
+    """Texture context type recreated as deprecated in blender 2.8"""
+
+    idblock = context.brush
+    if idblock and context.scene.texture_context == 'OTHER':
+        return idblock
+
+    # idblock = bpy.context.active_object.active_material
+    idblock = context.view_layer.objects.active.active_material
+    if idblock and context.scene.texture_context == 'MATERIAL':
+        return idblock
+
+    idblock = context.scene.world
+    if idblock and context.scene.texture_context == 'WORLD':
+        return idblock
+
+    idblock = context.light
+    if idblock and context.scene.texture_context == 'LIGHT':
+        return idblock
+
+    if context.particle_system and context.scene.texture_context == 'PARTICLES':
+        idblock = context.particle_system.settings
+
+    return idblock
+
+    idblock = context.line_style
+    if idblock and context.scene.texture_context == 'LINESTYLE':
+        return idblock
+
+
+def active_texture_name_from_uilist(self, context):
+    """Name created texture slots the same as created texture"""
+    idblock = pov_context_tex_datablock(context)
+    # mat = context.view_layer.objects.active.active_material
+    if idblock is not None:
+        index = idblock.pov.active_texture_index
+        name = idblock.pov_texture_slots[index].name
+        newname = idblock.pov_texture_slots[index].texture
+        tex = bpy.data.textures[name]
+        tex.name = newname
+        idblock.pov_texture_slots[index].name = newname
+
+
+def active_texture_name_from_search(self, context):
+    """Texture rolldown to change the data linked by an existing texture"""
+    idblock = pov_context_tex_datablock(context)
+    # mat = context.view_layer.objects.active.active_material
+    if idblock is not None:
+        index = idblock.pov.active_texture_index
+        slot = idblock.pov_texture_slots[index]
+        name = slot.texture_search
+
+    try:
+        # tex = bpy.data.textures[name]
+        slot.name = name
+        slot.texture = name
+        # Switch paint brush to this texture so settings remain contextual
+        # bpy.context.tool_settings.image_paint.brush.texture = tex
+        # bpy.context.tool_settings.image_paint.brush.mask_texture = tex
+    except BaseException as e:
+        print(e.__doc__)
+        print('An exception occurred: {}'.format(e))
+        pass
+
+
+def brush_texture_update(self, context):
+
+    """Brush texture rolldown must show active slot texture props"""
+    idblock = pov_context_tex_datablock(context)
+    if idblock is not None:
+        # mat = context.view_layer.objects.active.active_material
+        idblock = pov_context_tex_datablock(context)
+        slot = idblock.pov_texture_slots[idblock.pov.active_texture_index]
+        tex = slot.texture
+
+        if tex:
+            # Switch paint brush to active texture so slot and settings remain contextual
+            bpy.context.tool_settings.image_paint.brush.texture = bpy.data.textures[tex]
+            bpy.context.tool_settings.image_paint.brush.mask_texture = bpy.data.textures[tex]
+
+
+class RenderPovSettingsMaterial(PropertyGroup):
+    """Declare material level properties controllable in UI and translated to POV."""
+
+    ######################Begin Old Blender Internal Props#########################
+    # former Space properties from  removed Blender Internal
+    use_limited_texture_context: BoolProperty(
+        name="",
+        description="Use the limited version of texture user (for ‘old shading’ mode)",
+        default=True,
+    )
+    texture_context: EnumProperty(
+        name="Texture context",
+        description="Type of texture data to display and edit",
+        items=(
+            ("MATERIAL", "", "Show material textures", "MATERIAL", 0),  # "Show material textures"
+            ("WORLD", "", "Show world textures", "WORLD", 1),  # "Show world textures"
+            ("LAMP", "", "Show lamp textures", "LIGHT", 2),  # "Show lamp textures"
+            (
+                "PARTICLES",
+                "",
+                "Show particles textures",
+                "PARTICLES",
+                3,
+            ),  # "Show particles textures"
+            (
+                "LINESTYLE",
+                "",
+                "Show linestyle textures",
+                "LINE_DATA",
+                4,
+            ),  # "Show linestyle textures"
+            (
+                "OTHER",
+                "",
+                "Show other data textures",
+                "TEXTURE_DATA",
+                5,
+            ),  # "Show other data textures"
+        ),
+        default="MATERIAL",
+    )
+
+    active_texture_index: IntProperty(
+        name="Index for texture_slots", default=0, update=brush_texture_update
+    )
+
+    transparency_method: EnumProperty(
+        name="Specular Shader Model",
+        description="Method to use for rendering transparency",
+        items=(
+            ("MASK", "Mask", "Mask the background"),
+            ("Z_TRANSPARENCY", "Z Transparency", "Use alpha buffer for transparent faces"),
+            ("RAYTRACE", "Raytrace", "Use raytracing for transparent refraction rendering"),
+        ),
+        default="MASK",
+    )
+
+    use_transparency: BoolProperty(
+        name="Transparency", description="Render material as transparent", default=False
+    )
+
+    alpha: FloatProperty(
+        name="Alpha",
+        description="Alpha transparency of the material",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    specular_alpha: FloatProperty(
+        name="Specular alpha",
+        description="Alpha transparency for specular areas",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    ambient: FloatProperty(
+        name="Ambient",
+        description="Amount of global ambient color the material receives",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    diffuse_color: FloatVectorProperty(
+        name="Diffuse color",
+        description=("Diffuse color of the material"),
+        precision=4,
+        step=0.01,
+        min=0,  # max=inf, soft_max=1,
+        default=(0.6, 0.6, 0.6),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    darkness: FloatProperty(
+        name="Darkness",
+        description="Minnaert darkness",
+        min=0.0,
+        max=2.0,
+        soft_min=0.0,
+        soft_max=2.0,
+        default=1.0,
+        precision=3,
+    )
+
+    diffuse_fresnel: FloatProperty(
+        name="Diffuse fresnel",
+        description="Power of Fresnel",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=1.0,
+        precision=3,
+    )
+
+    diffuse_fresnel_factor: FloatProperty(
+        name="Diffuse fresnel factor",
+        description="Blending factor of Fresnel",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=0.5,
+        precision=3,
+    )
+
+    diffuse_intensity: FloatProperty(
+        name="Diffuse intensity",
+        description="Amount of diffuse reflection multiplying color",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.8,
+        precision=3,
+    )
+
+    diffuse_ramp_blend: EnumProperty(
+        name="Diffuse ramp blend",
+        description="Blending method of the ramp and the diffuse color",
+        items=(
+            ("MIX", "Mix", ""),
+            ("ADD", "Add", ""),
+            ("MULTIPLY", "Multiply", ""),
+            ("SUBTRACT", "Subtract", ""),
+            ("SCREEN", "Screen", ""),
+            ("DIVIDE", "Divide", ""),
+            ("DIFFERENCE", "Difference", ""),
+            ("DARKEN", "Darken", ""),
+            ("LIGHTEN", "Lighten", ""),
+            ("OVERLAY", "Overlay", ""),
+            ("DODGE", "Dodge", ""),
+            ("BURN", "Burn", ""),
+            ("HUE", "Hue", ""),
+            ("SATURATION", "Saturation", ""),
+            ("VALUE", "Value", ""),
+            ("COLOR", "Color", ""),
+            ("SOFT_LIGHT", "Soft light", ""),
+            ("LINEAR_LIGHT", "Linear light", ""),
+        ),
+        default="MIX",
+    )
+
+    diffuse_ramp_factor: FloatProperty(
+        name="Factor",
+        description="Blending factor (also uses alpha in Colorband)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    diffuse_ramp_input: EnumProperty(
+        name="Input",
+        description="How the ramp maps on the surface",
+        items=(
+            ("SHADER", "Shader", ""),
+            ("ENERGY", "Energy", ""),
+            ("NORMAL", "Normal", ""),
+            ("RESULT", "Result", ""),
+        ),
+        default="SHADER",
+    )
+
+    diffuse_shader: EnumProperty(
+        name="Diffuse Shader Model",
+        description="How the ramp maps on the surface",
+        items=(
+            ("LAMBERT", "Lambert", "Use a Lambertian shader"),
+            ("OREN_NAYAR", "Oren-Nayar", "Use an Oren-Nayar shader"),
+            ("MINNAERT", "Minnaert", "Use a Minnaert shader"),
+            ("FRESNEL", "Fresnel", "Use a Fresnel shader"),
+        ),
+        default="LAMBERT",
+    )
+
+    diffuse_toon_size: FloatProperty(
+        name="Size",
+        description="Size of diffuse toon area",
+        min=0.0,
+        max=3.14,
+        soft_min=0.0,
+        soft_max=3.14,
+        default=0.5,
+        precision=3,
+    )
+
+    diffuse_toon_smooth: FloatProperty(
+        name="Smooth",
+        description="Smoothness of diffuse toon area",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.1,
+        precision=3,
+    )
+
+    emit: FloatProperty(
+        name="Emit",
+        description="Amount of light to emit",
+        min=0.0,
+        soft_min=0.0,  # max=inf, soft_max=inf,
+        default=0.0,
+        precision=3,
+    )
+
+    mirror_color: FloatVectorProperty(
+        name="Mirror color",
+        description=("Mirror color of the material"),
+        precision=4,
+        step=0.01,
+        min=0,  # max=inf, soft_max=1,
+        default=(0.6, 0.6, 0.6),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    roughness: FloatProperty(
+        name="Roughness",
+        description="Oren-Nayar Roughness",
+        min=0.0,
+        max=3.14,
+        soft_min=0.0,
+        soft_max=3.14,
+        precision=3,
+        default=0.5,
+    )
+
+    halo: BoolProperty(name="Halo", description=" Halo settings for the material", default=False)
+    # (was readonly in Blender2.79, never None)
+
+    line_color: FloatVectorProperty(
+        name="Line color",
+        description=("Line color used for Freestyle line rendering"),
+        precision=4,
+        step=0.01,
+        min=0,  # max=inf, soft_max=1,
+        default=(0.0, 0.0, 0.0),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    # diffuse_ramp:
+    ## Color ramp used to affect diffuse shading
+    ## Type:    ColorRamp, (readonly)
+
+    # cr_node = bpy.data.materials['Material'].node_tree.nodes['ColorRamp']
+    # layout.template_color_ramp(cr_node, "color_ramp", expand=True)
+
+    # ou
+
+    # class bpy.types.ColorRamp(bpy_struct)
+
+    line_priority: IntProperty(
+        name="Recursion Limit",
+        description="The line color of a higher priority is used at material boundaries",
+        min=0,
+        max=32767,
+        default=0,
+    )
+
+    specular_color: FloatVectorProperty(
+        name="Specular color",
+        description=("Specular color of the material "),
+        precision=4,
+        step=0.01,
+        min=0,  # max=inf, soft_max=1,
+        default=(1.0, 1.0, 1.0),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    specular_hardness: IntProperty(
+        name="Hardness",
+        description="How hard (sharp) the specular reflection is",
+        min=1,
+        max=511,
+        default=30,
+    )
+
+    specular_intensity: FloatProperty(
+        name="Intensity",
+        description="How intense (bright) the specular reflection is",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.1,
+        precision=3,
+    )
+
+    specular_ior: FloatProperty(
+        name="IOR",
+        description="Specular index of refraction",
+        min=-10.0,
+        max=10.0,
+        soft_min=0.0,
+        soft_max=10.0,
+        default=1.0,
+        precision=3,
+    )
+
+    ior: FloatProperty(
+        name="IOR",
+        description="Index of refraction",
+        min=-10.0,
+        max=10.0,
+        soft_min=0.0,
+        soft_max=10.0,
+        default=1.0,
+        precision=3,
+    )
+
+    specular_shader: EnumProperty(
+        name="Specular Shader Model",
+        description="How the ramp maps on the surface",
+        items=(
+            ("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"),
+        ),
+        default="COOKTORR",
+    )
+
+    specular_slope: FloatProperty(
+        name="Slope",
+        description="The standard deviation of surface slope",
+        min=0.0,
+        max=0.4,
+        soft_min=0.0,
+        soft_max=0.4,
+        default=0.1,
+        precision=3,
+    )
+
+    specular_toon_size: FloatProperty(
+        name="Size",
+        description="Size of specular toon area",
+        min=0.0,
+        max=0.53,
+        soft_min=0.0,
+        soft_max=0.53,
+        default=0.5,
+        precision=3,
+    )
+
+    specular_toon_smooth: FloatProperty(
+        name="Smooth",
+        description="Smoothness of specular toon area",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.1,
+        precision=3,
+    )
+
+    translucency: FloatProperty(
+        name="Translucency",
+        description="Amount of diffuse shading on the back side",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.0,
+        precision=3,
+    )
+
+    transparency_method: EnumProperty(
+        name="Specular Shader Model",
+        description="Method to use for rendering transparency",
+        items=(
+            ("MASK", "Mask", "Mask the background"),
+            ("Z_TRANSPARENCY", "Z Transparency", "Use an ior of 1 for transparent faces"),
+            ("RAYTRACE", "Raytrace", "Use raytracing for transparent refraction rendering"),
+        ),
+        default="MASK",
+    )
+
+    type: EnumProperty(
+        name="Type",
+        description="Material type defining how the object is rendered",
+        items=(
+            ("SURFACE", "Surface", "Render object as a surface"),
+            # TO UPDATE > USE wire MACRO AND CHANGE DESCRIPTION
+            ("WIRE", "Wire", "Render the edges of faces as wires (not supported in raytracing)"),
+            ("VOLUME", "Volume", "Render object as a volume"),
+            # TO UPDATE > USE halo MACRO AND CHANGE DESCRIPTION
+            ("HALO", "Halo", "Render object as halo particles"),
+        ),
+        default="SURFACE",
+    )
+
+    use_cast_shadows: BoolProperty(
+        name="Cast", description="Allow this material to cast shadows", default=True
+    )
+
+    use_cast_shadows_only: BoolProperty(
+        name="Cast Only",
+        description="Make objects with this material "
+        "appear invisible (not rendered), only "
+        "casting shadows",
+        default=False,
+    )
+
+    use_cubic: BoolProperty(
+        name="Cubic Interpolation",
+        description="Use cubic interpolation for diffuse " "values, for smoother transitions",
+        default=False,
+    )
+
+    use_diffuse_ramp: BoolProperty(
+        name="Ramp", description="Toggle diffuse ramp operations", default=False
+    )
+
+    use_light_group_exclusive: BoolProperty(
+        name="Exclusive",
+        description="Material uses the light group exclusively"
+        "- these lamps are excluded from other "
+        "scene lighting",
+        default=False,
+    )
+
+    use_light_group_local: BoolProperty(
+        name="Local",
+        description="When linked in, material uses local light" " group with the same name",
+        default=False,
+    )
+
+    use_mist: BoolProperty(
+        name="Use Mist",
+        description="Use mist with this material " "(in world settings)",
+        default=True,
+    )
+
+    use_nodes: BoolProperty(
+        name="Nodes",
+        # Add Icon in UI or here? icon='NODES'
+        description="Use shader nodes to render the material",
+        default=False,
+    )
+
+    use_object_color: BoolProperty(
+        name="Object Color",
+        description="Modulate the result with a per-object color",
+        default=False,
+    )
+
+    use_only_shadow: BoolProperty(
+        name="Shadows Only",
+        description="Render shadows as the material’s alpha "
+        "value, making the material transparent "
+        "except for shadowed areas",
+        default=False,
+    )
+
+    use_shadeless: BoolProperty(
+        name="Shadeless",
+        description="Make this material insensitive to " "light or shadow",
+        default=False,
+    )
+
+    use_shadows: BoolProperty(
+        name="Receive", description="Allow this material to receive shadows", default=True
+    )
+
+    use_sky: BoolProperty(
+        name="Sky",
+        description="Render this material with zero alpha, "
+        "with sky background in place (scanline only)",
+        default=False,
+    )
+
+    use_specular_ramp: BoolProperty(
+        name="Ramp", description="Toggle specular ramp operations", default=False
+    )
+
+    use_tangent_shading: BoolProperty(
+        name="Tangent Shading",
+        description="Use the material’s tangent vector instead"
+        "of the normal for shading - for "
+        "anisotropic shading effects",
+        default=False,
+    )
+
+    use_transparent_shadows: BoolProperty(
+        name="Receive Transparent",
+        description="Allow this object to receive transparent " "shadows cast through other object",
+        default=False,
+    )  # linked to fake caustics
+
+    use_vertex_color_light: BoolProperty(
+        name="Vertex Color Light",
+        description="Add vertex colors as additional lighting",
+        default=False,
+    )
+
+    use_vertex_color_paint: BoolProperty(
+        name="Vertex Color Paint",
+        description="Replace object base color with vertex "
+        "colors (multiply with ‘texture face’ "
+        "face assigned textures)",
+        default=False,
+    )
+
+    specular_ramp_blend: EnumProperty(
+        name="Specular ramp blend",
+        description="Blending method of the ramp and the specular color",
+        items=(
+            ("MIX", "Mix", ""),
+            ("ADD", "Add", ""),
+            ("MULTIPLY", "Multiply", ""),
+            ("SUBTRACT", "Subtract", ""),
+            ("SCREEN", "Screen", ""),
+            ("DIVIDE", "Divide", ""),
+            ("DIFFERENCE", "Difference", ""),
+            ("DARKEN", "Darken", ""),
+            ("LIGHTEN", "Lighten", ""),
+            ("OVERLAY", "Overlay", ""),
+            ("DODGE", "Dodge", ""),
+            ("BURN", "Burn", ""),
+            ("HUE", "Hue", ""),
+            ("SATURATION", "Saturation", ""),
+            ("VALUE", "Value", ""),
+            ("COLOR", "Color", ""),
+            ("SOFT_LIGHT", "Soft light", ""),
+            ("LINEAR_LIGHT", "Linear light", ""),
+        ),
+        default="MIX",
+    )
+
+    specular_ramp_factor: FloatProperty(
+        name="Factor",
+        description="Blending factor (also uses alpha in Colorband)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    specular_ramp_input: EnumProperty(
+        name="Input",
+        description="How the ramp maps on the surface",
+        items=(
+            ("SHADER", "Shader", ""),
+            ("ENERGY", "Energy", ""),
+            ("NORMAL", "Normal", ""),
+            ("RESULT", "Result", ""),
+        ),
+        default="SHADER",
+    )
+
+    irid_enable: BoolProperty(
+        name="Iridescence coating",
+        description="Newton's thin film interference (like an oil slick on a puddle of "
+        "water or the rainbow hues of a soap bubble.)",
+        default=False,
+    )
+
+    mirror_use_IOR: BoolProperty(
+        name="Correct Reflection",
+        description="Use same IOR as raytrace transparency to calculate mirror reflections. "
+        "More physically correct",
+        default=False,
+    )
+
+    mirror_metallic: BoolProperty(
+        name="Metallic Reflection",
+        description="mirror reflections get colored as diffuse (for metallic materials)",
+        default=False,
+    )
+
+    conserve_energy: BoolProperty(
+        name="Conserve Energy",
+        description="Light transmitted is more correctly reduced by mirror reflections, "
+        "also the sum of diffuse and translucency gets reduced below one ",
+        default=True,
+    )
+
+    irid_amount: FloatProperty(
+        name="amount",
+        description="Contribution of the iridescence effect to the overall surface color. "
+        "As a rule of thumb keep to around 0.25 (25% contribution) or less, "
+        "but experiment. If the surface is coming out too white, try lowering "
+        "the diffuse and possibly the ambient values of the surface",
+        min=0.0,
+        max=1.0,
+        soft_min=0.01,
+        soft_max=1.0,
+        default=0.25,
+    )
+
+    irid_thickness: FloatProperty(
+        name="thickness",
+        description="A very thin film will have a high frequency of color changes while a "
+        "thick film will have large areas of color",
+        min=0.0,
+        max=1000.0,
+        soft_min=0.1,
+        soft_max=10.0,
+        default=1,
+    )
+
+    irid_turbulence: FloatProperty(
+        name="turbulence",
+        description="This parameter varies the thickness",
+        min=0.0,
+        max=10.0,
+        soft_min=0.000,
+        soft_max=1.0,
+        default=0,
+    )
+
+    interior_fade_color: FloatVectorProperty(
+        name="Interior Fade Color",
+        description="Color of filtered attenuation for transparent " "materials",
+        precision=4,
+        step=0.01,
+        min=0.0,
+        soft_max=1.0,
+        default=(0, 0, 0),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    caustics_enable: BoolProperty(
+        name="Caustics",
+        description="use only fake refractive caustics (default) or photon based "
+        "reflective/refractive caustics",
+        default=True,
+    )
+
+    fake_caustics: BoolProperty(
+        name="Fake Caustics", description="use only (Fast) fake refractive caustics", default=True
+    )
+
+    fake_caustics_power: FloatProperty(
+        name="Fake caustics power",
+        description="Values typically range from 0.0 to 1.0 or higher. Zero is no caustics. "
+        "Low, non-zero values give broad hot-spots while higher values give "
+        "tighter, smaller simulated focal points",
+        min=0.00,
+        max=10.0,
+        soft_min=0.00,
+        soft_max=5.0,
+        default=0.15,
+    )
+
+    refraction_caustics: BoolProperty(
+        name="Refractive Caustics",
+        description="hotspots of light focused when going through the material",
+        default=True,
+    )
+
+    photons_dispersion: FloatProperty(
+        name="Chromatic Dispersion",
+        description="Light passing through will be separated according to wavelength. "
+        "This ratio of refractive indices for violet to red controls how much "
+        "the colors are spread out 1 = no dispersion, good values are 1.01 to 1.1",
+        min=1.0000,
+        max=10.000,
+        soft_min=1.0000,
+        soft_max=1.1000,
+        precision=4,
+        default=1.0000,
+    )
+
+    photons_dispersion_samples: IntProperty(
+        name="Dispersion Samples",
+        description="Number of color-steps for dispersion",
+        min=2,
+        max=128,
+        default=7,
+    )
+
+    photons_reflection: BoolProperty(
+        name="Reflective Photon Caustics",
+        description="Use this to make your Sauron's ring ;-P",
+        default=False,
+    )
+
+    refraction_type: EnumProperty(
+        items=[
+            ("1", "Z Transparency Fake Caustics", "use fake caustics"),
+            ("2", "Raytrace Photons Caustics", "use photons for refractive caustics"),
+        ],
+        name="Refraction Type:",
+        description="use fake caustics (fast) or true photons for refractive Caustics",
+        default="1",
+    )
+
+    ##################################CustomPOV Code############################
+    replacement_text: StringProperty(
+        name="Declared name:",
+        description="Type the variable name as declared either directly inlined "
+        "in your custom POV code from the text editor datablock (checked as a "
+        "source to render in it's side property panel), or this declaration can be "
+        "from an external .inc it points at. Here, name = texture {} expected",
+        default="",
+    )
+
+    # NODES
+
+    def use_material_nodes_callback(self, context):
+        """Identify if node has been added and if it is used yet or default"""
+
+        if hasattr(context.space_data, "tree_type"):
+            context.space_data.tree_type = "ObjectNodeTree"
+        mat = context.object.active_material
+        if mat.pov.material_use_nodes:
+            mat.use_nodes = True
+            tree = mat.node_tree
+            # tree.name = mat.name # XXX READONLY
+            links = tree.links
+            default = True
+            if len(tree.nodes) == 2:
+                o = 0
+                m = 0
+                for node in tree.nodes:
+                    if node.type in {"OUTPUT", "MATERIAL"}:
+                        tree.nodes.remove(node)
+                        default = True
+                for node in tree.nodes:
+                    if node.bl_idname == "PovrayOutputNode":
+                        o += 1
+                    if node.bl_idname == "PovrayTextureNode":
+                        m += 1
+                if o == 1 and m == 1:
+                    default = False
+            elif len(tree.nodes) == 0:
+                default = True
+            else:
+                default = False
+            if default:
+                output = tree.nodes.new("PovrayOutputNode")
+                output.location = 200, 200
+                tmap = tree.nodes.new("PovrayTextureNode")
+                tmap.location = 0, 200
+                links.new(tmap.outputs[0], output.inputs[0])
+                tmap.select = True
+                tree.nodes.active = tmap
+        else:
+            mat.use_nodes = False
+
+    def use_texture_nodes_callback(self, context):
+        """Identify texture nodes by filtering out output and composite ones"""
+
+        tex = context.object.active_material.active_texture
+        if tex.pov.texture_use_nodes:
+            tex.use_nodes = True
+            if len(tex.node_tree.nodes) == 2:
+                for node in tex.node_tree.nodes:
+                    if node.type in {"OUTPUT", "CHECKER"}:
+                        tex.node_tree.nodes.remove(node)
+        else:
+            tex.use_nodes = False
+
+    def node_active_callback(self, context):
+        """Synchronize active node with material before getting it"""
+
+        items = []  # XXX comment out > remove?
+        mat = context.material
+        mat.node_tree.nodes  # XXX comment out > remove?
+        for node in mat.node_tree.nodes:
+            node.select = False
+        for node in mat.node_tree.nodes:
+            if node.name == mat.pov.material_active_node:
+                node.select = True
+                mat.node_tree.nodes.active = node
+
+                return node
+
+    def node_enum_callback(self, context):
+        items = []
+        mat = context.material
+        nodes = mat.node_tree.nodes
+        for node in nodes:
+            items.append(("%s" % node.name, "%s" % node.name, ""))
+        return items
+
+    def pigment_normal_callback(self, context):
+        render = context.scene.pov.render  # XXX comment out > remove?
+        items = [("pigment", "Pigment", ""), ("normal", "Normal", "")]
+        # XXX Find any other such traces of hgpovray experiment > remove or deploy ?
+        if render == "hgpovray":
+            items = [
+                ("pigment", "Pigment", ""),
+                ("normal", "Normal", ""),
+                ("modulation", "Modulation", ""),
+            ]
+        return items
+
+    def glow_callback(self, context):
+        scene = context.scene
+        ob = context.object
+        ob.pov.mesh_write_as_old = ob.pov.mesh_write_as
+        if scene.pov.render == "uberpov" and ob.pov.glow:
+            ob.pov.mesh_write_as = "NONE"
+        else:
+            ob.pov.mesh_write_as = ob.pov.mesh_write_as_old
+
+    material_use_nodes: BoolProperty(
+        name="Use nodes", description="", update=use_material_nodes_callback, default=False
+    )
+
+    material_active_node: EnumProperty(
+        name="Active node", description="", items=node_enum_callback, update=node_active_callback
+    )
+
+    preview_settings: BoolProperty(name="Preview Settings", description="", default=False)
+
+    object_preview_transform: BoolProperty(name="Transform object", description="", default=False)
+
+    object_preview_scale: FloatProperty(name="XYZ", min=0.5, max=2.0, default=1.0)
+
+    object_preview_rotate: FloatVectorProperty(
+        name="Rotate", description="", min=-180.0, max=180.0, default=(0.0, 0.0, 0.0), subtype="XYZ"
+    )
+
+    object_preview_bgcontrast: FloatProperty(name="Contrast", min=0.0, max=1.0, default=0.5)
+
+
+class MaterialRaytraceTransparency(PropertyGroup):
+    """Declare transparency panel properties controllable in UI and translated to POV."""
+
+    depth: IntProperty(
+        name="Depth",
+        description="Maximum allowed number of light inter-refractions",
+        min=0,
+        max=32767,
+        default=2,
+    )
+
+    depth_max: FloatProperty(
+        name="Depth",
+        description="Maximum depth for light to travel through the "
+        "transparent material before becoming fully filtered (0.0 is disabled)",
+        min=0,
+        max=100,
+        default=0.0,
+    )
+
+    falloff: FloatProperty(
+        name="Falloff",
+        description="Falloff power for transmissivity filter effect (1.0 is linear)",
+        min=0.1,
+        max=10.0,
+        default=1.0,
+        precision=3,
+    )
+
+    filter: FloatProperty(
+        name="Filter",
+        description="Amount to blend in the material’s diffuse color in raytraced "
+        "transparency (simulating absorption)",
+        min=0.0,
+        max=1.0,
+        default=0.0,
+        precision=3,
+    )
+
+    fresnel: FloatProperty(
+        name="Fresnel",
+        description="Power of Fresnel for transparency (Ray or ZTransp)",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=0.0,
+        precision=3,
+    )
+
+    fresnel_factor: FloatProperty(
+        name="Blend",
+        description="Blending factor for Fresnel",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=1.250,
+        precision=3,
+    )
+
+    gloss_factor: FloatProperty(
+        name="Amount",
+        description="The clarity of the refraction. "
+        "(values < 1.0 give diffuse, blurry refractions)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    gloss_samples: IntProperty(
+        name="Samples",
+        description="frequency of the noise sample used for blurry refractions",
+        min=0,
+        max=1024,
+        default=18,
+    )
+
+    gloss_threshold: FloatProperty(
+        name="Threshold",
+        description="Threshold for adaptive sampling (if a sample "
+        "contributes less than this amount [as a percentage], "
+        "sampling is stopped)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.005,
+        precision=3,
+    )
+
+    ior: FloatProperty(
+        name="IOR",
+        description="Sets angular index of refraction for raytraced refraction",
+        min=-0.0,
+        max=10.0,
+        soft_min=0.25,
+        soft_max=4.0,
+        default=1.3,
+    )
+
+
+class MaterialRaytraceMirror(PropertyGroup):
+    """Declare reflection panel properties controllable in UI and translated to POV."""
+
+    bl_description = ("Raytraced reflection settings for the Material",)
+
+    use: BoolProperty(name="Mirror", description="Enable raytraced reflections", default=False)
+
+    depth: IntProperty(
+        name="Depth",
+        description="Maximum allowed number of light inter-reflections",
+        min=0,
+        max=32767,
+        default=2,
+    )
+
+    distance: FloatProperty(
+        name="Max Dist",
+        description="Maximum distance of reflected rays "
+        "(reflections further than this range "
+        "fade to sky color or material color)",
+        min=0.0,
+        max=100000.0,
+        soft_min=0.0,
+        soft_max=10000.0,
+        default=0.0,
+        precision=3,
+    )
+
+    fade_to: EnumProperty(
+        items=[
+            ("FADE_TO_SKY", "Fade to sky", ""),
+            ("FADE_TO_MATERIAL", "Fade to material color", ""),
+        ],
+        name="Fade-out Color",
+        description="The color that rays with no intersection within the "
+        "Max Distance take (material color can be best for "
+        "indoor scenes, sky color for outdoor)",
+        default="FADE_TO_SKY",
+    )
+
+    fresnel: FloatProperty(
+        name="Fresnel",
+        description="Power of Fresnel for mirror reflection",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=0.0,
+        precision=3,
+    )
+
+    fresnel_factor: FloatProperty(
+        name="Blend",
+        description="Blending factor for Fresnel",
+        min=0.0,
+        max=5.0,
+        soft_min=0.0,
+        soft_max=5.0,
+        default=1.250,
+        precision=3,
+    )
+
+    gloss_anisotropic: FloatProperty(
+        name="Anisotropic",
+        description="The shape of the reflection, from 0.0 (circular) "
+        "to 1.0 (fully stretched along the tangent",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    gloss_factor: FloatProperty(
+        name="Amount",
+        description="The shininess of the reflection  "
+        "(values < 1.0 give diffuse, blurry reflections)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    gloss_samples: IntProperty(
+        name="Noise",
+        description="Frequency of the noise pattern bumps averaged for blurry reflections",
+        min=0,
+        max=1024,
+        default=18,
+    )
+
+    gloss_threshold: FloatProperty(
+        name="Threshold",
+        description="Threshold for adaptive sampling (if a sample "
+        "contributes less than this amount [as a percentage], "
+        "sampling is stopped)",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.005,
+        precision=3,
+    )
+
+    mirror_color: FloatVectorProperty(
+        name="Mirror color",
+        description=("Mirror color of the material"),
+        precision=4,
+        step=0.01,
+        default=(1.0, 1.0, 1.0),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    reflect_factor: FloatProperty(
+        name="Reflectivity",
+        description="Amount of mirror reflection for raytrace",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+
+class MaterialSubsurfaceScattering(PropertyGroup):
+    r"""Declare SSS/SSTL properties controllable in UI and translated to POV."""
+
+    bl_description = ("Subsurface scattering settings for the material",)
+
+    use: BoolProperty(
+        name="Subsurface Scattering",
+        description="Enable diffuse subsurface scatting " "effects in a material",
+        default=False,
+    )
+
+    back: FloatProperty(
+        name="Back",
+        description="Back scattering weight",
+        min=0.0,
+        max=10.0,
+        soft_min=0.0,
+        soft_max=10.0,
+        default=1.0,
+        precision=3,
+    )
+
+    color: FloatVectorProperty(
+        name="Scattering color",
+        description=("Scattering color"),
+        precision=4,
+        step=0.01,
+        default=(0.604, 0.604, 0.604),
+        options={"ANIMATABLE"},
+        subtype="COLOR",
+    )
+
+    color_factor: FloatProperty(
+        name="Color",
+        description="Blend factor for SSS colors",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=1.0,
+        precision=3,
+    )
+
+    error_threshold: FloatProperty(
+        name="Error",
+        description="Error tolerance (low values are slower and higher quality)",
+        default=0.050,
+        precision=3,
+    )
+
+    front: FloatProperty(
+        name="Front",
+        description="Front scattering weight",
+        min=0.0,
+        max=2.0,
+        soft_min=0.0,
+        soft_max=2.0,
+        default=1.0,
+        precision=3,
+    )
+
+    ior: FloatProperty(
+        name="IOR",
+        description="Index of refraction (higher values are denser)",
+        min=-0.0,
+        max=10.0,
+        soft_min=0.1,
+        soft_max=2.0,
+        default=1.3,
+    )
+
+    radius: FloatVectorProperty(
+        name="RGB Radius",
+        description=("Mean red/green/blue scattering path length"),
+        precision=4,
+        step=0.01,
+        min=0.001,
+        default=(1.0, 1.0, 1.0),
+        options={"ANIMATABLE"},
+    )
+
+    scale: FloatProperty(
+        name="Scale", description="Object scale factor", default=0.100, precision=3
+    )
+
+    texture_factor: FloatProperty(
+        name="Texture",
+        description="Texture scattering blend factor",
+        min=0.0,
+        max=1.0,
+        soft_min=0.0,
+        soft_max=1.0,
+        default=0.0,
+        precision=3,
+    )
+
+
+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)
+
+    # ambient
+
+    # Amount of global ambient color the material receives
+    # Type: float in [0, 1], default 0.0
+
+    # 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
+
+    # game_settings
+
+    # Game material settings
+    # Type: MaterialGameSettings, (readonly, never None)
+
+    # 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’
+
+    # raytrace_mirror
+
+    # Raytraced reflection settings for the material
+    # Type: MaterialRaytraceMirror, (readonly, never None)
+
+    # raytrace_transparency
+
+    # Raytraced transparency settings for the material
+    # Type: MaterialRaytraceTransparency, (readonly, never None)
+
+    # 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)
+
+    # translucency
+
+    # Amount of diffuse shading on the back side
+    # Type: float in [0, 1], default 0.0
+
+    # transparency_method
+
+    # Method to use for rendering transparency
+
+    # MASK Mask, Mask the background.
+    # Z_TRANSPARENCY Z Transparency, Use alpha buffer for transparent faces.
+    # RAYTRACE Raytrace, Use raytracing for transparent refraction rendering.
+
+    # Type: enum in [‘MASK’, ‘Z_TRANSPARENCY’, ‘RAYTRACE’], default ‘MASK’
+
+    # 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_approximate
+
+    # Allow this material to cast shadows when using approximate ambient occlusion
+    # Type: boolean, default False
+
+    # use_cast_buffer_shadows
+
+    # Allow this material to cast shadows from shadow buffer lamps
+    # Type: boolean, default False
+
+    # 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.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.specular_shader in {'COOKTORR', 'PHONG'}:
+                col.prop(mat, "specular_hardness", text="Hardness")
+            elif mat.specular_shader == 'BLINN':
+
+                row.prop(mat, "specular_hardness", text="Hardness")
+                row.prop(mat, "specular_ior", text="IOR")
+            elif mat.specular_shader == 'WARDISO':
+                col.prop(mat, "specular_slope", text="Slope")
+            elif mat.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")
+
+
+    class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
+        bl_label = "Shading"
+        COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
+
+        @classmethod
+        def poll(cls, context):
+            mat = context.material
+            engine = context.scene.render.engine
+            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+        def draw(self, context):
+            layout = self.layout
+
+            mat = active_node_mat(context.material)
+
+            if mat.type in {'SURFACE', 'WIRE'}:
+                split = layout.split()
+
+                col = split.column()
+                sub = col.column()
+                sub.active = not mat.use_shadeless
+                sub.prop(mat, "emit")
+                sub.prop(mat, "ambient")
+                sub = col.column()
+                sub.prop(mat, "translucency")
+
+                col = split.column()
+                col.prop(mat, "use_shadeless")
+                sub = col.column()
+                sub.active = not mat.use_shadeless
+                sub.prop(mat, "use_tangent_shading")
+                sub.prop(mat, "use_cubic")
+
+
+    class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
+        bl_label = "Transparency"
+        COMPAT_ENGINES = {'BLENDER_RENDER'}
+
+        @classmethod
+        def poll(cls, context):
+            mat = context.material
+            engine = context.scene.render.engine
+            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+        def draw_header(self, context):
+            mat = context.material
+
+            if simple_material(mat):
+                self.layout.prop(mat, "use_transparency", text="")
+
+        def draw(self, context):
+            layout = self.layout
+
+            base_mat = context.material
+            mat = active_node_mat(context.material)
+            rayt = mat.raytrace_transparency
+
+            if simple_material(base_mat):
+                row = layout.row()
+                row.active = mat.use_transparency
+                row.prop(mat, "transparency_method", expand=True)
+
+            split = layout.split()
+            split.active = base_mat.use_transparency
+
+            col = split.column()
+            col.prop(mat, "alpha")
+            row = col.row()
+            row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
+            row.prop(mat, "specular_alpha", text="Specular")
+
+            col = split.column()
+            col.active = (not mat.use_shadeless)
+            col.prop(rayt, "fresnel")
+            sub = col.column()
+            sub.active = (rayt.fresnel > 0.0)
+            sub.prop(rayt, "fresnel_factor", text="Blend")
+
+            if base_mat.transparency_method == 'RAYTRACE':
+                layout.separator()
+                split = layout.split()
+                split.active = base_mat.use_transparency
+
+                col = split.column()
+                col.prop(rayt, "ior")
+                col.prop(rayt, "filter")
+                col.prop(rayt, "falloff")
+                col.prop(rayt, "depth_max")
+                col.prop(rayt, "depth")
+
+                col = split.column()
+                col.label(text="Gloss:")
+                col.prop(rayt, "gloss_factor", text="Amount")
+                sub = col.column()
+                sub.active = rayt.gloss_factor < 1.0
+                sub.prop(rayt, "gloss_threshold", text="Threshold")
+                sub.prop(rayt, "gloss_samples", text="Samples")
+
+
+    class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
+        bl_label = "Mirror"
+        bl_options = {'DEFAULT_CLOSED'}
+        COMPAT_ENGINES = {'BLENDER_RENDER'}
+
+        @classmethod
+        def poll(cls, context):
+            mat = context.material
+            engine = context.scene.render.engine
+            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+        def draw_header(self, context):
+            raym = active_node_mat(context.material).raytrace_mirror
+
+            self.layout.prop(raym, "use", text="")
+
+        def draw(self, context):
+            layout = self.layout
+
+            mat = active_node_mat(context.material)
+            raym = mat.raytrace_mirror
+
+            layout.active = raym.use
+
+            split = layout.split()
+
+            col = split.column()
+            col.prop(raym, "reflect_factor")
+            col.prop(mat, "mirror_color", text="")
+
+            col = split.column()
+            col.prop(raym, "fresnel")
+            sub = col.column()
+            sub.active = (raym.fresnel > 0.0)
+            sub.prop(raym, "fresnel_factor", text="Blend")
+
+            split = layout.split()
+
+            col = split.column()
+            col.separator()
+            col.prop(raym, "depth")
+            col.prop(raym, "distance", text="Max Dist")
+            col.separator()
+            sub = col.split(percentage=0.4)
+            sub.active = (raym.distance > 0.0)
+            sub.label(text="Fade To:")
+            sub.prop(raym, "fade_to", text="")
+
+            col = split.column()
+            col.label(text="Gloss:")
+            col.prop(raym, "gloss_factor", text="Amount")
+            sub = col.column()
+            sub.active = (raym.gloss_factor < 1.0)
+            sub.prop(raym, "gloss_threshold", text="Threshold")
+            sub.prop(raym, "gloss_samples", text="Samples")
+            sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
+
+
+    class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
+        bl_label = "Subsurface Scattering"
+        bl_options = {'DEFAULT_CLOSED'}
+        COMPAT_ENGINES = {'BLENDER_RENDER'}
+
+        @classmethod
+        def poll(cls, context):
+            mat = context.material
+            engine = context.scene.render.engine
+            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+        def draw_header(self, context):
+            mat = active_node_mat(context.material)
+            sss = mat.subsurface_scattering
+
+            self.layout.active = (not mat.use_shadeless)
+            self.layout.prop(sss, "use", text="")
+
+        def draw(self, context):
+            layout = self.layout
+
+            mat = active_node_mat(context.material)
+            sss = mat.subsurface_scattering
+
+            layout.active = (sss.use) and (not mat.use_shadeless)
+
+            row = layout.row().split()
+            sub = row.row(align=True).split(align=True, percentage=0.75)
+            sub.menu("MATERIAL_MT_sss_presets", text=bpy.types.MATERIAL_MT_sss_presets.bl_label)
+            sub.operator("material.sss_preset_add", text="", icon='ZOOMIN')
+            sub.operator("material.sss_preset_add", text="", icon='ZOOMOUT').remove_active = True
+
+            split = layout.split()
+
+            col = split.column()
+            col.prop(sss, "ior")
+            col.prop(sss, "scale")
+            col.prop(sss, "color", text="")
+            col.prop(sss, "radius", text="RGB Radius", expand=True)
+
+            col = split.column()
+            sub = col.column(align=True)
+            sub.label(text="Blend:")
+            sub.prop(sss, "color_factor", text="Color")
+            sub.prop(sss, "texture_factor", text="Texture")
+            sub.label(text="Scattering Weight:")
+            sub.prop(sss, "front")
+            sub.prop(sss, "back")
+            col.separator()
+            col.prop(sss, "error_threshold", text="Error")
+
+
+    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.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.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.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")
+
+    """
+
+
+#######################End Old Blender Internal Props##########################
+
+
+classes = (
+    RenderPovSettingsMaterial,
+    MaterialRaytraceTransparency,
+    MaterialRaytraceMirror,
+    MaterialSubsurfaceScattering,
+    MaterialStrandSettings,
+)
+
+
+def register():
+    for cls in classes:
+        register_class(cls)
+
+    bpy.types.Material.pov = PointerProperty(type=RenderPovSettingsMaterial)
+    bpy.types.Material.pov_raytrace_transparency = PointerProperty(
+        type=MaterialRaytraceTransparency
+    )
+    bpy.types.Material.pov_subsurface_scattering = PointerProperty(
+        type=MaterialSubsurfaceScattering
+    )
+    bpy.types.Material.strand = PointerProperty(type=MaterialStrandSettings)
+    bpy.types.Material.pov_raytrace_mirror = PointerProperty(type=MaterialRaytraceMirror)
+
+
+def unregister():
+    del bpy.types.Material.pov_subsurface_scattering
+    del bpy.types.Material.strand
+    del bpy.types.Material.pov_raytrace_mirror
+    del bpy.types.Material.pov_raytrace_transparency
+    del bpy.types.Material.pov
+
+    for cls in reversed(classes):
+        unregister_class(cls)