Second pass to update properties for 2.8... To be continued

4 files changed, 1497 insertions, 76 deletions

diff --git a/render_povray/__init__.py b/render_povray/__init__.py
index 3b5980f0..ebbeebe6 100644
--- a/render_povray/__init__.py
+++ b/render_povray/__init__.py
@@ -547,6 +547,349 @@ class RenderPovSettingsScene(PropertyGroup):
 # Material POV properties.
 ###############################################################################
 class RenderPovSettingsMaterial(PropertyGroup):
+######################Begin Old Blender Internal Props#########################
+
+    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)
+            
+    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, default=0.5, precision=3)
+
+    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=50)
+            
+    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.5, 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 alpha buffer for transparent faces"),#TO DEPRECATE
+                   ("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"),
+                   ("WIRE", "Wire", "Render the edges of faces as wires (not supported in raytracing)"),#TO UPDATE > USE MACRO AND CHNGE DESCRIPTION
+                   ("VOLUME", "Volume", "Render object as a volume"),
+                   ("‘HALO’", "Halo", "Render object as halo particles")), #TO UPDATE > USE MACRO AND CHNGE DESCRIPTION
+            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", description="Use shader nodes to render the material",#Add Icon in UI or here? icon='NODES'
+            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 "
@@ -745,8 +1088,995 @@ class RenderPovSettingsMaterial(PropertyGroup):
     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 MaterialRaytraceMirror(PropertyGroup):
+    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="Samples",
+            description="Number of cone samples 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)
+
+    
+    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):
+    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=-10.0, max=10.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)
+                
+            # halo
+
+                # Halo settings for the material
+                # Type:	MaterialHalo, (readonly, never None)            
+            # alpha¶
+
+                # Alpha transparency of the material
+                # Type:	float in [0, 1], default 0.0
+
+            # 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_alpha
+
+                # Alpha transparency for specular areas
+                # Type:	float in [0, 1], 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##########################
 ###############################################################################
 # Povray Nodes
 ###############################################################################
@@ -2257,32 +3587,7 @@ class RenderPovSettingsWorld(PropertyGroup):
             precision=4, step=0.01, min=0, soft_max=1,
             default=(0.0, 0.0, 0.0), options={'ANIMATABLE'}, subtype='COLOR',
     )
-'''
-class WORLD_PT_POV_world(WorldButtonsPanel, Panel):
-    bl_label = "World"
-    #COMPAT_ENGINES = {'BLENDER_RENDER'}
-
-    def draw(self, context):
-        layout = self.layout
-
-        world = context.world
-
-        row = layout.row()
-        row.prop(world, "use_sky_paper")
-        row.prop(world, "use_sky_blend")
-        row.prop(world, "use_sky_real")
-
-        row = layout.row()
-        row.column().prop(world, "horizon_color")
-        col = row.column()
-        col.prop(world, "zenith_color")
-        col.active = world.use_sky_blend
-        row.column().prop(world, "ambient_color")
 
-        row = layout.row()
-        row.prop(world, "exposure")
-        row.prop(world, "color_range")
-'''
 ###############################################################################
 # Text POV properties.
 ###############################################################################
@@ -2342,6 +3647,8 @@ def register():
     register_class(RenderPovSettingsCamera)
     register_class(RenderPovSettingsWorld)
     register_class(RenderPovSettingsMaterial)
+    register_class(MaterialRaytraceMirror)    
+    register_class(MaterialSubsurfaceScattering)
     register_class(RenderPovSettingsObject)
     register_class(RenderPovSettingsScene)
     register_class(RenderPovSettingsText)
@@ -2364,6 +3671,8 @@ def register():
     bpy.types.Scene.pov = PointerProperty(type=RenderPovSettingsScene)
     #bpy.types.Modifier.pov = PointerProperty(type=RenderPovSettingsModifier)
     bpy.types.Material.pov = PointerProperty(type=RenderPovSettingsMaterial)
+    bpy.types.Material.pov_subsurface_scattering = PointerProperty(type=MaterialSubsurfaceScattering)
+    bpy.types.Material.pov_raytrace_mirror = PointerProperty(type=MaterialRaytraceMirror)
     bpy.types.Texture.pov = PointerProperty(type=RenderPovSettingsTexture)
     bpy.types.Object.pov = PointerProperty(type=RenderPovSettingsObject)
     bpy.types.Camera.pov = PointerProperty(type=RenderPovSettingsCamera)
diff --git a/render_povray/nodes.py b/render_povray/nodes.py
index 61e59c16..79c38a78 100644
--- a/render_povray/nodes.py
+++ b/render_povray/nodes.py
@@ -342,17 +342,17 @@ class PovrayMultiplyNode(Node, ObjectNodeTree):
     bl_label = 'Multiply'
     bl_icon = 'SOUND'
 
-    amount_x = FloatProperty(
+    amount_x : FloatProperty(
             name="X",
             description="Number of repeats",
             min=1.0, max=10000.0, default=1.0)
 
-    amount_y = FloatProperty(
+    amount_y : FloatProperty(
             name="Y",
             description="Number of repeats",
             min=1.0, max=10000.0, default=1.0)
 
-    amount_z = FloatProperty(
+    amount_z : FloatProperty(
             name="Z",
             description="Number of repeats",
             min=1.0, max=10000.0, default=1.0)
@@ -552,7 +552,7 @@ class PovrayBumpMapNode(Node, ObjectNodeTree):
     bl_label = 'Bump map'
     bl_icon = 'SOUND'
 
-    map_type = bpy.props.EnumProperty(
+    map_type : bpy.props.EnumProperty(
             name="Map type",
             description="",
             items=(
@@ -563,8 +563,8 @@ class PovrayBumpMapNode(Node, ObjectNodeTree):
                 ('5', "Torroidal", "Torus or donut shaped mapping")
             ),
             default='0')
-    image = StringProperty(maxlen=1024) # , subtype="FILE_PATH"
-    interpolate = EnumProperty(
+    image : StringProperty(maxlen=1024) # , subtype="FILE_PATH"
+    interpolate : EnumProperty(
             name="Interpolate",
             description="Adding the interpolate keyword can smooth the jagged look of a bitmap",
             items=(
@@ -572,7 +572,7 @@ class PovrayBumpMapNode(Node, ObjectNodeTree):
                 ('4', "Normalized", "Gives normalized distance"),
             ),
             default='2')
-    once = BoolProperty(description="Not to repeat", default=False)
+    once : BoolProperty(description="Not to repeat", default=False)
 
     def init(self, context):
 
@@ -703,7 +703,7 @@ class ShaderPatternNode(Node, ObjectNodeTree):
     bl_idname = 'ShaderPatternNode'
     bl_label = 'Other patterns'
 
-    pattern = EnumProperty(
+    pattern : EnumProperty(
             name="Pattern",
             description="Agate, Crackle, Gradient, Pavement, Spiral, Tiling",
             items=(('agate', "Agate", ""),('crackle', "Crackle", ""),('gradient', "Gradient", ""),
@@ -713,47 +713,47 @@ class ShaderPatternNode(Node, ObjectNodeTree):
                    ('tiling', "Tiling", "")),
             default='agate')
 
-    agate_turb = FloatProperty(
+    agate_turb : FloatProperty(
             name="Agate turb",
             description="Agate turbulence",
             min=0.0, max=100.0, default=0.5)
 
-    crackle_form_x = FloatProperty(
+    crackle_form_x : FloatProperty(
             name="X",
             description="Form vector X",
             min=-150.0, max=150.0, default=-1)
 
-    crackle_form_y = FloatProperty(
+    crackle_form_y : FloatProperty(
             name="Y",
             description="Form vector Y",
             min=-150.0, max=150.0, default=1)
 
-    crackle_form_z = FloatProperty(
+    crackle_form_z : FloatProperty(
             name="Z",
             description="Form vector Z",
             min=-150.0, max=150.0, default=0)
 
-    crackle_metric = FloatProperty(
+    crackle_metric : FloatProperty(
             name="Metric",
             description="Crackle metric",
             min=0.0, max=150.0, default=1)
 
-    crackle_solid = BoolProperty(
+    crackle_solid : BoolProperty(
             name="Solid",
             description="Crackle solid",
             default=False)
 
-    spiral_arms = FloatProperty(
+    spiral_arms : FloatProperty(
             name="Number",
             description="",
             min=0.0, max=256.0, default=2.0)
 
-    tiling_number = IntProperty(
+    tiling_number : IntProperty(
             name="Number",
             description="",
             min=1, max=27, default=1)
 
-    gradient_orient = EnumProperty(
+    gradient_orient : EnumProperty(
             name="Orient",
             description="",
             items=(('x', "X", ""),
@@ -856,22 +856,22 @@ class ShaderNormalMapNode(Node, ObjectNodeTree):
     bl_idname = 'ShaderNormalMapNode'
     bl_label = 'Normal map'
 
-    brick_size_x = FloatProperty(
+    brick_size_x : FloatProperty(
             name="X",
             description="",
             min=0.0000, max=1.0000, default=0.2500)
 
-    brick_size_y = FloatProperty(
+    brick_size_y : FloatProperty(
             name="Y",
             description="",
             min=0.0000, max=1.0000, default=0.0525)
 
-    brick_size_z = FloatProperty(
+    brick_size_z : FloatProperty(
             name="Z",
             description="",
             min=0.0000, max=1.0000, default=0.1250)
 
-    brick_mortar = FloatProperty(
+    brick_mortar : FloatProperty(
             name="Mortar",
             description="Mortar",
             min=0.000, max=1.500, default=0.01)
@@ -922,7 +922,7 @@ class IsoPropsNode(Node, CompositorNodeTree):
     '''ISO Props'''
     bl_idname = 'IsoPropsNode'
     bl_label = 'Iso'
-    node_label = StringProperty(maxlen=1024)
+    node_label : StringProperty(maxlen=1024)
     def init(self, context):
         ob = bpy.context.object
         self.node_label = ob.name
diff --git a/render_povray/render.py b/render_povray/render.py
index 126e6d27..90429bbf 100644
--- a/render_povray/render.py
+++ b/render_povray/render.py
@@ -444,9 +444,9 @@ def write_pov(filename, scene=None, info_callback=None):
         #if material and material.transparency_method == 'RAYTRACE':
         if material:
             # But there can be only one!
-            if material.subsurface_scattering.use:  # SSS IOR get highest priority
+            if material.pov_subsurface_scattering.use:  # SSS IOR get highest priority
                 tabWrite("interior {\n")
-                tabWrite("ior %.6f\n" % material.subsurface_scattering.ior)
+                tabWrite("ior %.6f\n" % material.pov_subsurface_scattering.ior)
             # Then the raytrace IOR taken from raytrace transparency properties and used for
             # reflections if IOR Mirror option is checked.
             elif material.pov.mirror_use_IOR:
@@ -2678,7 +2678,7 @@ def write_pov(filename, scene=None, info_callback=None):
                         tabWrite("#declare %s =sphere {<0, 0, 0>,0 pigment{rgbt 1} no_image no_reflection no_radiosity photons{pass_through collect off} hollow}\n" % povdataname)
 
                     try:
-                        me = ob.to_mesh(scene, True, 'RENDER')
+                        me = ob.to_mesh(bpy.context.depsgraph, True, 'RENDER')
 
                     #XXX Here? identify the specific exception for mesh object with no data
                     #XXX So that we can write something for the dataname !
@@ -2832,8 +2832,8 @@ def write_pov(filename, scene=None, info_callback=None):
                             else:
                                 if material:
                                     # Multiply diffuse with SSS Color
-                                    if material.subsurface_scattering.use:
-                                        diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
+                                    if material.pov_subsurface_scattering.use:
+                                        diffuse_color = [i * j for i, j in zip(material.pov_subsurface_scattering.color[:], material.diffuse_color[:])]
                                         key = diffuse_color[0], diffuse_color[1], diffuse_color[2], \
                                               material_index
                                         vertCols[key] = [-1]
@@ -2878,8 +2878,8 @@ def write_pov(filename, scene=None, info_callback=None):
                                     ci3 = vertCols[col3[0], col3[1], col3[2], material_index][0]
                                 else:
                                     # Color per material - flat material color
-                                    if material.subsurface_scattering.use:
-                                        diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
+                                    if material.pov_subsurface_scattering.use:
+                                        diffuse_color = [i * j for i, j in zip(material.pov_subsurface_scattering.color[:], material.diffuse_color[:])]
                                     else:
                                         diffuse_color = material.diffuse_color[:]
                                     ci1 = ci2 = ci3 = vertCols[diffuse_color[0], diffuse_color[1], \
@@ -2992,8 +2992,8 @@ def write_pov(filename, scene=None, info_callback=None):
 
                             if material and material.pov.material_use_nodes == False:  # WARNING!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
                                 # Multiply diffuse with SSS Color
-                                if material.subsurface_scattering.use:
-                                    diffuse_color = [i * j for i, j in zip(material.subsurface_scattering.color[:], material.diffuse_color[:])]
+                                if material.pov_subsurface_scattering.use:
+                                    diffuse_color = [i * j for i, j in zip(material.pov_subsurface_scattering.color[:], material.diffuse_color[:])]
                                     key = diffuse_color[0], diffuse_color[1], diffuse_color[2], i  # i == f.mat
                                     vertCols[key] = [-1]
                                 else:
@@ -3104,9 +3104,9 @@ def write_pov(filename, scene=None, info_callback=None):
                                     ci1 = ci2 = ci3 = 0
                                 else:
                                     # Color per material - flat material color
-                                    if material.subsurface_scattering.use:
+                                    if material.pov_subsurface_scattering.use:
                                         diffuse_color = [i * j for i, j in
-                                            zip(material.subsurface_scattering.color[:],
+                                            zip(material.pov_subsurface_scattering.color[:],
                                                 material.diffuse_color[:])]
                                     else:
                                         diffuse_color = material.diffuse_color[:]
@@ -3480,17 +3480,17 @@ def write_pov(filename, scene=None, info_callback=None):
         onceAmbient = 1
         oncePhotons = 1
         for material in bpy.data.materials:
-            if material.subsurface_scattering.use and onceSss:
+            if material.pov_subsurface_scattering.use and onceSss:
                 # In pov, the scale has reversed influence compared to blender. these number
                 # should correct that
                 tabWrite("mm_per_unit %.6f\n" % \
-                         (material.subsurface_scattering.scale * 1000.0))
+                         (material.pov_subsurface_scattering.scale * 1000.0))
                          # 1000 rather than scale * (-100.0) + 15.0))
 
                 # In POV-Ray, the scale factor for all subsurface shaders needs to be the same
 
                 # formerly sslt_samples were multiplied by 100 instead of 10
-                sslt_samples = (11 - material.subsurface_scattering.error_threshold) * 10
+                sslt_samples = (11 - material.pov_subsurface_scattering.error_threshold) * 10
 
                 tabWrite("subsurface { samples %d, %d }\n" % (sslt_samples, sslt_samples / 10))
                 onceSss = 0
@@ -3670,6 +3670,7 @@ def write_pov_ini(scene, filename_ini, filename_log, filename_pov, filename_imag
     feature_set = bpy.context.preferences.addons[__package__].preferences.branch_feature_set_povray
     using_uberpov = (feature_set=='uberpov')
     #scene = bpy.data.scenes[0]
+    scene = bpy.context.scene
     render = scene.render
 
     x = int(render.resolution_x * render.resolution_percentage * 0.01)
@@ -3795,9 +3796,10 @@ class PovrayRender(bpy.types.RenderEngine):
                 return pov_binary
         return ""
 
-    def _export(self, scene, povPath, renderImagePath):
+    def _export(self, depsgraph, povPath, renderImagePath):
         import tempfile
-
+        scene = bpy.context.scene
+        
         if scene.pov.tempfiles_enable:
             self._temp_file_in = tempfile.NamedTemporaryFile(suffix=".pov", delete=False).name
             # PNG with POV 3.7, can show the background color with alpha. In the long run using the
@@ -3833,7 +3835,7 @@ class PovrayRender(bpy.types.RenderEngine):
             write_pov(self._temp_file_in, scene, info_callback)
         else:
             pass
-    def _render(self, scene):
+    def _render(self, depsgraph):
         try:
             os.remove(self._temp_file_out)  # so as not to load the old file
         except OSError:
@@ -3901,8 +3903,9 @@ class PovrayRender(bpy.types.RenderEngine):
                     # Wait a bit before retrying file might be still in use by Blender,
                     # and Windows does not know how to delete a file in use!
                     time.sleep(self.DELAY)
-    def render(self, scene):
+    def render(self, depsgraph):
         import tempfile
+        scene = bpy.context.scene
         r = scene.render
         x = int(r.resolution_x * r.resolution_percentage * 0.01)
         y = int(r.resolution_y * r.resolution_percentage * 0.01)
@@ -3933,7 +3936,7 @@ class PovrayRender(bpy.types.RenderEngine):
 
             return True
 
-        if scene.pov.text_block !="":
+        if bpy.context.scene.pov.text_block !="":
             if scene.pov.tempfiles_enable:
                 self._temp_file_in = tempfile.NamedTemporaryFile(suffix=".pov", delete=False).name
                 self._temp_file_out = tempfile.NamedTemporaryFile(suffix=".png", delete=False).name
@@ -4147,10 +4150,10 @@ class PovrayRender(bpy.types.RenderEngine):
 
             # start export
             self.update_stats("", "POV-Ray 3.7: Exporting data from Blender")
-            self._export(scene, povPath, renderImagePath)
+            self._export(depsgraph, povPath, renderImagePath)
             self.update_stats("", "POV-Ray 3.7: Parsing File")
 
-            if not self._render(scene):
+            if not self._render(depsgraph):
                 self.update_stats("", "POV-Ray 3.7: Not found")
                 #return
 
diff --git a/render_povray/ui.py b/render_povray/ui.py
index 12db23f6..949b9463 100644
--- a/render_povray/ui.py
+++ b/render_povray/ui.py
@@ -664,7 +664,7 @@ class WORLD_PT_POV_world(WorldButtonsPanel, bpy.types.Panel):
     def draw(self, context):
         layout = self.layout
 
-        world = context.world
+        world = context.world.pov
 
         row = layout.row(align=True)
         row.menu(POV_WORLD_MT_presets.__name__, text=POV_WORLD_MT_presets.bl_label)
@@ -684,7 +684,7 @@ class WORLD_PT_POV_world(WorldButtonsPanel, bpy.types.Panel):
         row.column().prop(world, "ambient_color")
 
         #row = layout.row()
-        #row.prop(world, "exposure")
+        #row.prop(world, "exposure") #Re-implement later as a light multiplier
         #row.prop(world, "color_range")
 
 class RENDER_PT_povray_export_settings(RenderButtonsPanel, bpy.types.Panel):
@@ -1075,7 +1075,57 @@ class MODIFIERS_PT_povray_modifiers(ModifierButtonsPanel, bpy.types.Panel):
                         # Inside Vector for CSG
                         col.prop(ob.pov, "inside_vector")
 
+class MATERIAL_PT_POV_sss(MaterialButtonsPanel, bpy.types.Panel):
+    bl_label = "Subsurface Scattering"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'POVRAY_RENDER'}
+
+    @classmethod
+    def poll(cls, context):
+        mat = context.material
+        engine = context.scene.render.engine
+        return check_material(mat) and (mat.pov.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        mat = context.material #FORMERLY : #active_node_mat(context.material)
+        sss = mat.pov_subsurface_scattering
+
+        self.layout.active = (not mat.pov.use_shadeless)
+        self.layout.prop(sss, "use", text="")
+
+    def draw(self, context):
+        layout = self.layout
 
+        mat = active_node_mat(context.material)
+        sss = mat.pov_subsurface_scattering
+
+        layout.active = (sss.use) and (not mat.pov.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='ADD')
+        sub.operator("material.sss_preset_add", text="", icon='REMOVE').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_povray_activate_node(MaterialButtonsPanel, bpy.types.Panel):
     bl_label = "Activate Node Settings"
     bl_context = "material"
@@ -1147,8 +1197,64 @@ class MATERIAL_PT_povray_active_node(MaterialButtonsPanel, bpy.types.Panel):
                                 socket.draw(context, row, node, socket.name)
                 else:
                     layout.label("No active nodes!")
+                    
+class MATERIAL_PT_POV_mirror(MaterialButtonsPanel, bpy.types.Panel):
+    bl_label = "Mirror"
+    bl_options = {'DEFAULT_CLOSED'}
+    COMPAT_ENGINES = {'POVRAY_RENDER'}
 
+    @classmethod
+    def poll(cls, context):
+        mat = context.material
+        engine = context.scene.render.engine
+        return check_material(mat) and (mat.pov.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
+
+    def draw_header(self, context):
+        mat = context.material
+        raym = mat.pov_raytrace_mirror
+
+        self.layout.prop(raym, "use", text="")
+
+    def draw(self, context):
+        layout = self.layout
+
+        mat = context.material #Formerly : #mat = active_node_mat(context.material)
+        raym = mat.pov_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_povray_reflection(MaterialButtonsPanel, bpy.types.Panel):
     bl_label = "POV-Ray Reflection"
     COMPAT_ENGINES = {'POVRAY_RENDER'}
@@ -1158,7 +1264,7 @@ class MATERIAL_PT_povray_reflection(MaterialButtonsPanel, bpy.types.Panel):
         engine = context.scene.render.engine
         mat=context.material
         ob = context.object
-        return mat and mat.type == "SURFACE" and (engine in cls.COMPAT_ENGINES) and not (mat.pov.material_use_nodes or mat.use_nodes)
+        return mat and mat.pov.type == "SURFACE" and (engine in cls.COMPAT_ENGINES) and not (mat.pov.material_use_nodes or mat.use_nodes)
 
     def draw(self, context):
         layout = self.layout
@@ -1173,9 +1279,9 @@ class MATERIAL_PT_povray_reflection(MaterialButtonsPanel, bpy.types.Panel):
         col.prop(mat.pov, "conserve_energy")
         col2=col.split().column()
 
-        if not mat.raytrace_mirror.use:
+        if not mat.pov_raytrace_mirror.use:
             col2.label(text="Please Check Mirror settings :")
-        col2.active = mat.raytrace_mirror.use
+        col2.active = mat.pov_raytrace_mirror.use
         col2.prop(mat.pov, "mirror_use_IOR")
         if mat.pov.mirror_use_IOR:
             col2.alignment = 'CENTER'
@@ -2109,7 +2215,7 @@ class TEXT_OT_povray_insert(bpy.types.Operator):
     bl_idname = "text.povray_insert"
     bl_label = "Insert"
 
-    filepath = bpy.props.StringProperty(name="Filepath", subtype='FILE_PATH')
+    filepath : bpy.props.StringProperty(name="Filepath", subtype='FILE_PATH')
 
     @classmethod
     def poll(cls, context):
@@ -2216,8 +2322,9 @@ def menu_func_templates(self, context):
 
 
 classes = (
-    #POV_WORLD_MT_presets,
-    #AddPresetWorld,
+    WORLD_PT_POV_world,
+    POV_WORLD_MT_presets,
+    AddPresetWorld,
     #RenderButtonsPanel,
     #ModifierButtonsPanel,
     #MaterialButtonsPanel,
@@ -2249,8 +2356,10 @@ classes = (
     AddPresetRadiosity,
     RENDER_PT_povray_media,
     MODIFIERS_PT_povray_modifiers,
+    MATERIAL_PT_POV_sss,
     MATERIAL_PT_povray_activate_node,
     MATERIAL_PT_povray_active_node,
+    MATERIAL_PT_POV_mirror,
     MATERIAL_PT_povray_reflection,
     MATERIAL_PT_povray_fade_color,
     MATERIAL_PT_povray_caustics,