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

1 files changed, 1334 insertions, 25 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)