__init__.py

    def node_enum_callback(self, context):
        items = []
        mat=context.material
        nodes=mat.node_tree.nodes
        for node in nodes:
            items.append(("%s"%node.name,"%s"%node.name,""))
        return items

    def pigment_normal_callback(self, context):
        render = context.scene.pov.render
        items = [("pigment", "Pigment", ""),("normal", "Normal", "")]
        if render == 'hgpovray':
            items = [("pigment", "Pigment", ""),("normal", "Normal", ""),("modulation", "Modulation", "")]
        return items

    def glow_callback(self, context):
        scene = context.scene
        ob = context.object
        ob.pov.mesh_write_as_old = ob.pov.mesh_write_as
        if scene.pov.render == 'uberpov' and ob.pov.glow:
            ob.pov.mesh_write_as = 'NONE'
        else:
            ob.pov.mesh_write_as = ob.pov.mesh_write_as_old

    material_use_nodes: BoolProperty(
        name="Use nodes",
        description="",
        update=use_material_nodes_callback,
        default=False,
    )

    material_active_node: EnumProperty(
        name="Active node",
        description="",
        items=node_enum_callback,
        update=node_active_callback
    )

    preview_settings: BoolProperty(
        name="Preview Settings",
        description="",
        default=False,
    )

    object_preview_transform: BoolProperty(
        name="Transform object",
        description="",
        default=False,
    )

    object_preview_scale: FloatProperty(
        name="XYZ",
        min=0.5,
        max=2.0,
        default=1.0,
    )

    object_preview_rotate: FloatVectorProperty(
        name="Rotate",
        description="",
        min=-180.0,
        max=180.0,
        default=(0.0,0.0,0.0),
        subtype='XYZ',
    )

    object_preview_bgcontrast: FloatProperty(
        name="Contrast",
        min=0.0,
        max=1.0,
        default=0.5,
    )


class MaterialRaytraceTransparency(PropertyGroup):
    """Declare transparency panel properties controllable in UI and translated to POV."""

    depth: IntProperty(
        name="Depth",
        description="Maximum allowed number of light inter-refractions",
        min=0, max=32767, default=2
    )

    depth_max: FloatProperty(
        name="Depth",
        description="Maximum depth for light to travel through the "
        "transparent material before becoming fully filtered (0.0 is disabled)",
        min=0, max=100, default=0.0,
    )

    falloff: FloatProperty(
        name="Falloff",
        description="Falloff power for transmissivity filter effect (1.0 is linear)",
        min=0.1, max=10.0, default=1.0, precision=3
    )

    filter: FloatProperty(
        name="Filter",
        description="Amount to blend in the material’s diffuse color in raytraced "
        "transparency (simulating absorption)",
        min=0.0, max=1.0, default=0.0, precision=3
    )

    fresnel: FloatProperty(
        name="Fresnel",
        description="Power of Fresnel for transparency (Ray or ZTransp)",
        min=0.0, max=5.0, soft_min=0.0, soft_max=5.0, default=0.0, precision=3
    )

    fresnel_factor: FloatProperty(
        name="Blend",
        description="Blending factor for Fresnel",
        min=0.0, max=5.0, soft_min=0.0, soft_max=5.0, default=1.250, precision=3
    )

    gloss_factor: FloatProperty(
        name="Amount",
        description="The clarity of the refraction. "
        "(values < 1.0 give diffuse, blurry refractions)",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=1.0, precision=3
    )

    gloss_samples: IntProperty(
        name="Samples",
        description="Number of cone samples averaged for blurry refractions",
        min=0, max=1024, default=18
    )

    gloss_threshold: FloatProperty(
        name="Threshold",
        description="Threshold for adaptive sampling (if a sample "
        "contributes less than this amount [as a percentage], "
        "sampling is stopped)",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=0.005, precision=3
    )

    ior: FloatProperty(
        name="IOR",
        description="Sets angular index of refraction for raytraced refraction",
        min=-0.0, max=10.0, soft_min=0.25, soft_max=4.0, default=1.3
    )

class MaterialRaytraceMirror(PropertyGroup):
    """Declare reflection panel properties controllable in UI and translated to POV."""

    bl_description = "Raytraced reflection settings for the Material",

    use: BoolProperty(
        name="Mirror",
        description="Enable raytraced reflections",
        default=False,
    )


    depth: IntProperty(
        name="Depth",
        description="Maximum allowed number of light inter-reflections",
        min=0, max=32767, default=2
    )

    distance: FloatProperty(
        name="Max Dist",
        description="Maximum distance of reflected rays "
        "(reflections further than this range "
        "fade to sky color or material color)",
        min=0.0, max=100000.0, soft_min=0.0, soft_max=10000.0, default=0.0, precision=3
    )

    fade_to: EnumProperty(
        items=[
               ("FADE_TO_SKY", "Fade to sky", ""),
               ("FADE_TO_MATERIAL", "Fade to material color", "")],
        name="Fade-out Color",
        description="The color that rays with no intersection within the "
        "Max Distance take (material color can be best for "
        "indoor scenes, sky color for outdoor)",
        default="FADE_TO_SKY",
    )

    fresnel: FloatProperty(
        name="Fresnel",
        description="Power of Fresnel for mirror reflection",
        min=0.0, max=5.0, soft_min=0.0, soft_max=5.0, default=0.0, precision=3,
    )

    fresnel_factor: FloatProperty(
        name="Blend",
        description="Blending factor for Fresnel",
        min=0.0, max=5.0, soft_min=0.0, soft_max=5.0, default=1.250, precision=3
    )

    gloss_anisotropic: FloatProperty(
        name="Anisotropic",
        description="The shape of the reflection, from 0.0 (circular) "
        "to 1.0 (fully stretched along the tangent",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=1.0, precision=3
    )

    gloss_factor: FloatProperty(
        name="Amount",
        description="The shininess of the reflection  "
        "(values < 1.0 give diffuse, blurry reflections)",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=1.0, precision=3
    )

    gloss_samples: IntProperty(
        name="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
    )

    mirror_color: FloatVectorProperty(
        name="Mirror color",
        description=("Mirror color of the material"),
        precision=4, step=0.01,
        default=(1.0,1.0,1.0), options={'ANIMATABLE'}, subtype='COLOR'
    )

    reflect_factor: FloatProperty(
        name="Reflectivity",
        description="Amount of mirror reflection for raytrace",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=1.0, precision=3
    )


class MaterialSubsurfaceScattering(PropertyGroup):
    r"""Declare SSS/SSTL properties controllable in UI and translated to POV."""

    bl_description = "Subsurface scattering settings for the material",

    use: BoolProperty(
        name="Subsurface Scattering",
        description="Enable diffuse subsurface scatting "
        "effects in a material",
        default=False,
    )

    back: FloatProperty(
        name="Back",
        description="Back scattering weight",
        min=0.0, max=10.0, soft_min=0.0, soft_max=10.0, default=1.0, precision=3
    )

    color: FloatVectorProperty(
        name="Scattering color",
        description=("Scattering color"),
        precision=4, step=0.01,
        default=(0.604,0.604,0.604), options={'ANIMATABLE'}, subtype='COLOR'
    )

    color_factor: FloatProperty(
        name="Color",
        description="Blend factor for SSS colors",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=1.0, precision=3
    )

    error_threshold: FloatProperty(
        name="Error",
        description="Error tolerance (low values are slower and higher quality)",
        default=0.050, precision=3
    )

    front: FloatProperty(
        name="Front",
        description="Front scattering weight",
        min=0.0, max=2.0, soft_min=0.0, soft_max=2.0, default=1.0, precision=3
    )

    ior: FloatProperty(
        name="IOR",
        description="Index of refraction (higher values are denser)",
        min=-0.0, max=10.0, soft_min=0.1, soft_max=2.0, default=1.3
    )

    radius: FloatVectorProperty(
        name="RGB Radius",
        description=("Mean red/green/blue scattering path length"),
        precision=4, step=0.01, min=0.001,
        default=(1.0,1.0,1.0), options={'ANIMATABLE'}
    )

    scale: FloatProperty(
        name="Scale",
        description="Object scale factor",
        default=0.100, precision=3
    )

    texture_factor: FloatProperty(
        name="Texture",
        description="Texture scattering blend factor",
        min=0.0, max=1.0, soft_min=0.0, soft_max=1.0, default=0.0, precision=3
    )


class MaterialStrandSettings(PropertyGroup):
    """Declare strand properties controllable in UI and translated to POV."""

    bl_description = "Strand settings for the material",

    blend_distance: FloatProperty(
        name="Distance",
        description="Worldspace distance over which to blend in the surface normal",
        min=0.0, max=10.0, soft_min=0.0, soft_max=10.0, default=0.0, precision=3
    )

    root_size: FloatProperty(
        name="Root",
        description="Start size of strands in pixels or Blender units",
        min=0.25, default=1.0, precision=5
    )

    shape: FloatProperty(
        name="Shape",
        description="Positive values make strands rounder, negative ones make strands spiky",
        min=-0.9, max=0.9, default=0.0, precision=3
    )

    size_min: FloatProperty(
        name="Minimum",
        description="Minimum size of strands in pixels",
        min=0.001, max=10.0, default=1.0, precision=3
    )

    tip_size: FloatProperty(
        name="Tip",
        description="End size of strands in pixels or Blender units",
        min=0.0, default=1.0, precision=5
    )

    use_blender_units: BoolProperty(
        name="Blender Units",
        description="Use Blender units for widths instead of pixels",
        default=False,
    )

    use_surface_diffuse: BoolProperty(
        name="Surface diffuse",
        description="Make diffuse shading more similar to shading the surface",
        default=False,
    )

    use_tangent_shading: BoolProperty(
        name="Tangent Shading",
        description="Use direction of strands as normal for tangent-shading",
        default=True,
    )

    uv_layer: StringProperty(
        name="UV Layer",
        # icon="GROUP_UVS",
        description="Name of UV map to override",
        default="",
    )

    width_fade: FloatProperty(
        name="Width Fade",
        description="Transparency along the width of the strand",
        min=0.0, max=2.0, default=0.0, precision=3
    )

            # halo

                # Halo settings for the material
                # Type:	MaterialHalo, (readonly, never None)

            # ambient

                # Amount of global ambient color the material receives
                # Type:	float in [0, 1], default 0.0

            # darkness

                # Minnaert darkness
                # Type:	float in [0, 2], default 0.0

            # diffuse_color

                # Diffuse color of the material
                # Type:	float array of 3 items in [0, inf], default (0.0, 0.0, 0.0)

            # diffuse_fresnel

                # Power of Fresnel
                # Type:	float in [0, 5], default 0.0

            # diffuse_fresnel_factor

                # Blending factor of Fresnel
                # Type:	float in [0, 5], default 0.0

            # diffuse_intensity

                # Amount of diffuse reflection
                # Type:	float in [0, 1], default 0.0

            # diffuse_ramp

                # Color ramp used to affect diffuse shading
                # Type:	ColorRamp, (readonly)

            # diffuse_ramp_blend

                # Blending method of the ramp and the diffuse color
                # Type:	enum in [‘MIX’, ‘ADD’, ‘MULTIPLY’, ‘SUBTRACT’, ‘SCREEN’, ‘DIVIDE’, ‘DIFFERENCE’, ‘DARKEN’, ‘LIGHTEN’, ‘OVERLAY’, ‘DODGE’, ‘BURN’, ‘HUE’, ‘SATURATION’, ‘VALUE’, ‘COLOR’, ‘SOFT_LIGHT’, ‘LINEAR_LIGHT’], default ‘MIX’

            # diffuse_ramp_factor

                # Blending factor (also uses alpha in Colorband)
                # Type:	float in [0, 1], default 0.0

            # diffuse_ramp_input

                # How the ramp maps on the surface
                # Type:	enum in [‘SHADER’, ‘ENERGY’, ‘NORMAL’, ‘RESULT’], default ‘SHADER’

            # diffuse_shader

                    # LAMBERT Lambert, Use a Lambertian shader.
                    # OREN_NAYAR Oren-Nayar, Use an Oren-Nayar shader.
                    # TOON Toon, Use a toon shader.
                    # MINNAERT Minnaert, Use a Minnaert shader.
                    # FRESNEL Fresnel, Use a Fresnel shader.

                # Type:	enum in [‘LAMBERT’, ‘OREN_NAYAR’, ‘TOON’, ‘MINNAERT’, ‘FRESNEL’], default ‘LAMBERT’

            # diffuse_toon_size

                # Size of diffuse toon area
                # Type:	float in [0, 3.14], default 0.0

            # diffuse_toon_smooth

                # Smoothness of diffuse toon area
                # Type:	float in [0, 1], default 0.0

            # emit

                # Amount of light to emit
                # Type:	float in [0, inf], default 0.0

            # game_settings

                # Game material settings
                # Type:	MaterialGameSettings, (readonly, never None)

            # halo

                # Halo settings for the material
                # Type:	MaterialHalo, (readonly, never None)

            # invert_z

                # Render material’s faces with an inverted Z buffer (scanline only)
                # Type:	boolean, default False

            # light_group

                # Limit lighting to lamps in this Group
                # Type:	Group

            # line_color

                # Line color used for Freestyle line rendering
                # Type:	float array of 4 items in [0, inf], default (0.0, 0.0, 0.0, 0.0)

            # line_priority

                # The line color of a higher priority is used at material boundaries
                # Type:	int in [0, 32767], default 0

            # mirror_color

                # Mirror color of the material
                # Type:	float array of 3 items in [0, inf], default (0.0, 0.0, 0.0)

            # node_tree

                # Node tree for node based materials
                # Type:	NodeTree, (readonly)

            # offset_z

                # Give faces an artificial offset in the Z buffer for Z transparency
                # Type:	float in [-inf, inf], default 0.0

            # paint_active_slot

                # Index of active texture paint slot
                # Type:	int in [0, 32767], default 0

            # paint_clone_slot

                # Index of clone texture paint slot
                # Type:	int in [0, 32767], default 0

            # pass_index

                # Index number for the “Material Index” render pass
                # Type:	int in [0, 32767], default 0

            # physics

                # Game physics settings
                # Type:	MaterialPhysics, (readonly, never None)

            # preview_render_type

                # Type of preview render

                    # FLAT Flat, Flat XY plane.
                    # SPHERE Sphere, Sphere.
                    # CUBE Cube, Cube.
                    # MONKEY Monkey, Monkey.
                    # HAIR Hair, Hair strands.
                    # SPHERE_A World Sphere, Large sphere with sky.

                # Type:	enum in [‘FLAT’, ‘SPHERE’, ‘CUBE’, ‘MONKEY’, ‘HAIR’, ‘SPHERE_A’], default ‘FLAT’

            # raytrace_mirror

                # Raytraced reflection settings for the material
                # Type:	MaterialRaytraceMirror, (readonly, never None)

            # raytrace_transparency

                # Raytraced transparency settings for the material
                # Type:	MaterialRaytraceTransparency, (readonly, never None)

            # roughness

                # Oren-Nayar Roughness
                # Type:	float in [0, 3.14], default 0.0

            # shadow_buffer_bias

                # Factor to multiply shadow buffer bias with (0 is ignore)
                # Type:	float in [0, 10], default 0.0

            # shadow_cast_alpha

                # Shadow casting alpha, in use for Irregular and Deep shadow buffer
                # Type:	float in [0.001, 1], default 0.0

            # shadow_only_type

                # How to draw shadows

                    # SHADOW_ONLY_OLD Shadow and Distance, Old shadow only method.
                    # SHADOW_ONLY Shadow Only, Improved shadow only method.
                    # SHADOW_ONLY_SHADED Shadow and Shading, Improved shadow only method which also renders lightless areas as shadows.

                # Type:	enum in [‘SHADOW_ONLY_OLD’, ‘SHADOW_ONLY’, ‘SHADOW_ONLY_SHADED’], default ‘SHADOW_ONLY_OLD’

            # shadow_ray_bias

                # Shadow raytracing bias to prevent terminator problems on shadow boundary
                # Type:	float in [0, 0.25], default 0.0


            # specular_color

                # Specular color of the material
                # Type:	float array of 3 items in [0, inf], default (0.0, 0.0, 0.0)

            # specular_hardness

                # How hard (sharp) the specular reflection is
                # Type:	int in [1, 511], default 0

            # specular_intensity

                # How intense (bright) the specular reflection is
                # Type:	float in [0, 1], default 0.0

            # specular_ior

                # Specular index of refraction
                # Type:	float in [1, 10], default 0.0

            # specular_ramp

                # Color ramp used to affect specular shading
                # Type:	ColorRamp, (readonly)

            # specular_ramp_blend

                # Blending method of the ramp and the specular color
                # Type:	enum in [‘MIX’, ‘ADD’, ‘MULTIPLY’, ‘SUBTRACT’, ‘SCREEN’, ‘DIVIDE’, ‘DIFFERENCE’, ‘DARKEN’, ‘LIGHTEN’, ‘OVERLAY’, ‘DODGE’, ‘BURN’, ‘HUE’, ‘SATURATION’, ‘VALUE’, ‘COLOR’, ‘SOFT_LIGHT’, ‘LINEAR_LIGHT’], default ‘MIX’

            # specular_ramp_factor

                # Blending factor (also uses alpha in Colorband)
                # Type:	float in [0, 1], default 0.0

            # specular_ramp_input

                # How the ramp maps on the surface
                # Type:	enum in [‘SHADER’, ‘ENERGY’, ‘NORMAL’, ‘RESULT’], default ‘SHADER’
            # specular_shader

                    # COOKTORR CookTorr, Use a Cook-Torrance shader.
                    # PHONG Phong, Use a Phong shader.
                    # BLINN Blinn, Use a Blinn shader.
                    # TOON Toon, Use a toon shader.
                    # WARDISO WardIso, Use a Ward anisotropic shader.

                # Type:	enum in [‘COOKTORR’, ‘PHONG’, ‘BLINN’, ‘TOON’, ‘WARDISO’], default ‘COOKTORR’

            # specular_slope

                # The standard deviation of surface slope
                # Type:	float in [0, 0.4], default 0.0

            # specular_toon_size

                # Size of specular toon area
                # Type:	float in [0, 1.53], default 0.0

            # specular_toon_smooth

                # Smoothness of specular toon area
                # Type:	float in [0, 1], default 0.0

            # strand

                # Strand settings for the material
                # Type:	MaterialStrand, (readonly, never None)

            # subsurface_scattering

                # Subsurface scattering settings for the material
                # Type:	MaterialSubsurfaceScattering, (readonly, never None)

            # texture_paint_images

                # Texture images used for texture painting
                # Type:	bpy_prop_collection of Image, (readonly)

            # texture_paint_slots

                # Texture slots defining the mapping and influence of textures
                # Type:	bpy_prop_collection of TexPaintSlot, (readonly)

            # texture_slots

                # Texture slots defining the mapping and influence of textures
                # Type:	MaterialTextureSlots bpy_prop_collection of MaterialTextureSlot, (readonly)

            # translucency

                # Amount of diffuse shading on the back side
                # Type:	float in [0, 1], default 0.0

            # transparency_method

                # Method to use for rendering transparency

                    # MASK Mask, Mask the background.
                    # Z_TRANSPARENCY Z Transparency, Use alpha buffer for transparent faces.
                    # RAYTRACE Raytrace, Use raytracing for transparent refraction rendering.

                # Type:	enum in [‘MASK’, ‘Z_TRANSPARENCY’, ‘RAYTRACE’], default ‘MASK’

            # type

                # Material type defining how the object is rendered

                    # SURFACE Surface, Render object as a surface.
                    # WIRE Wire, Render the edges of faces as wires (not supported in raytracing).
                    # VOLUME Volume, Render object as a volume.
                    # HALO Halo, Render object as halo particles.

                # Type:	enum in [‘SURFACE’, ‘WIRE’, ‘VOLUME’, ‘HALO’], default ‘SURFACE’

            # use_cast_approximate

                # Allow this material to cast shadows when using approximate ambient occlusion
                # Type:	boolean, default False

            # use_cast_buffer_shadows

                # Allow this material to cast shadows from shadow buffer lamps
                # Type:	boolean, default False

            # use_cast_shadows

                # Allow this material to cast shadows
                # Type:	boolean, default False

            # use_cast_shadows_only

                # Make objects with this material appear invisible (not rendered), only casting shadows
                # Type:	boolean, default False

            # use_cubic

                # Use cubic interpolation for diffuse values, for smoother transitions
                # Type:	boolean, default False

            # use_diffuse_ramp

                # Toggle diffuse ramp operations
                # Type:	boolean, default False

            # use_face_texture

                # Replace the object’s base color with color from UV map image textures
                # Type:	boolean, default False

            # use_face_texture_alpha

                # Replace the object’s base alpha value with alpha from UV map image textures
                # Type:	boolean, default False

            # use_full_oversampling

                # Force this material to render full shading/textures for all anti-aliasing samples
                # Type:	boolean, default False

            # use_light_group_exclusive

                # Material uses the light group exclusively - these lamps are excluded from other scene lighting
                # Type:	boolean, default False

            # use_light_group_local

                # When linked in, material uses local light group with the same name
                # Type:	boolean, default False

            # use_mist

                # Use mist with this material (in world settings)
                # Type:	boolean, default False

            # use_nodes

                # Use shader nodes to render the material
                # Type:	boolean, default False

            # use_object_color

                # Modulate the result with a per-object color
                # Type:	boolean, default False

            # use_only_shadow

                # Render shadows as the material’s alpha value, making the material transparent except for shadowed areas
                # Type:	boolean, default False

            # use_ray_shadow_bias

                # Prevent raytraced shadow errors on surfaces with smooth shaded normals (terminator problem)
                # Type:	boolean, default False

            # use_raytrace

                # Include this material and geometry that uses it in raytracing calculations
                # Type:	boolean, default False

            # use_shadeless

                # Make this material insensitive to light or shadow
                # Type:	boolean, default False

            # use_shadows

                # Allow this material to receive shadows
                # Type:	boolean, default False

            # use_sky

                # Render this material with zero alpha, with sky background in place (scanline only)
                # Type:	boolean, default False

            # use_specular_ramp

                # Toggle specular ramp operations
                # Type:	boolean, default False

            # use_tangent_shading

                # Use the material’s tangent vector instead of the normal for shading - for anisotropic shading effects
                # Type:	boolean, default False

            # use_textures

                # Enable/Disable each texture
                # Type:	boolean array of 18 items, default (False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False, False)

            # use_transparency

                # Render material as transparent
                # Type:	boolean, default False

            # use_transparent_shadows

                # Allow this object to receive transparent shadows cast through other objects
                # Type:	boolean, default False

            # use_uv_project

                # Use to ensure UV interpolation is correct for camera projections (use with UV project modifier)
                # Type:	boolean, default False

            # use_vertex_color_light

                # Add vertex colors as additional lighting
                # Type:	boolean, default False

            # use_vertex_color_paint

                # Replace object base color with vertex colors (multiply with ‘texture face’ face assigned textures)
                # Type:	boolean, default False

            # volume

                # Volume settings for the material
                # Type:	MaterialVolume, (readonly, never None)
    '''
    (mat.type in {'SURFACE', 'WIRE', 'VOLUME'})
     "use_transparency")



    mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'




            col.prop(mat, "use_raytrace")
            col.prop(mat, "use_full_oversampling")

            sub.prop(mat, "use_sky")


            col.prop(mat, "use_cast_shadows", text="Cast")
            col.prop(mat, "use_cast_shadows_only", text="Cast Only")
            col.prop(mat, "use_cast_buffer_shadows")

            sub.active = mat.use_cast_buffer_shadows
            sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
            col.prop(mat, "use_cast_approximate")



            col.prop(mat, "diffuse_color", text="")

            sub.active = (not mat.use_shadeless)

            sub.prop(mat, "diffuse_intensity", text="Intensity")


            col.prop(mat, "diffuse_shader", text="")
            col.prop(mat, "use_diffuse_ramp", text="Ramp")


            if mat.diffuse_shader == 'OREN_NAYAR':
                col.prop(mat, "roughness")
            elif mat.diffuse_shader == 'MINNAERT':
                col.prop(mat, "darkness")
            elif mat.diffuse_shader == 'TOON':

                row.prop(mat, "diffuse_toon_size", text="Size")
                row.prop(mat, "diffuse_toon_smooth", text="Smooth")
            elif mat.diffuse_shader == 'FRESNEL':

                row.prop(mat, "diffuse_fresnel", text="Fresnel")
                row.prop(mat, "diffuse_fresnel_factor", text="Factor")

            if mat.use_diffuse_ramp:

                col.template_color_ramp(mat, "diffuse_ramp", expand=True)



                row.prop(mat, "diffuse_ramp_input", text="Input")
                row.prop(mat, "diffuse_ramp_blend", text="Blend")

                col.prop(mat, "diffuse_ramp_factor", text="Factor")




            col.prop(mat, "specular_color", text="")
            col.prop(mat, "specular_intensity", text="Intensity")

            col.prop(mat, "specular_shader", text="")
            col.prop(mat, "use_specular_ramp", text="Ramp")

            if mat.specular_shader in {'COOKTORR', 'PHONG'}:
                col.prop(mat, "specular_hardness", text="Hardness")
            elif mat.specular_shader == 'BLINN':

                row.prop(mat, "specular_hardness", text="Hardness")
                row.prop(mat, "specular_ior", text="IOR")
            elif mat.specular_shader == 'WARDISO':
                col.prop(mat, "specular_slope", text="Slope")
            elif mat.specular_shader == 'TOON':

                row.prop(mat, "specular_toon_size", text="Size")
                row.prop(mat, "specular_toon_smooth", text="Smooth")

            if mat.use_specular_ramp:
                layout.separator()
                layout.template_color_ramp(mat, "specular_ramp", expand=True)
                layout.separator()

                row = layout.row()
                row.prop(mat, "specular_ramp_input", text="Input")
                row.prop(mat, "specular_ramp_blend", text="Blend")

                layout.prop(mat, "specular_ramp_factor", text="Factor")


    class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
        bl_label = "Shading"
        COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}

        @classmethod
        def poll(cls, context):
            mat = context.material
            engine = context.scene.render.engine
            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)

        def draw(self, context):
            layout = self.layout

            mat = active_node_mat(context.material)

            if mat.type in {'SURFACE', 'WIRE'}:
                split = layout.split()

                col = split.column()
                sub = col.column()
                sub.active = not mat.use_shadeless
                sub.prop(mat, "emit")
                sub.prop(mat, "ambient")
                sub = col.column()
                sub.prop(mat, "translucency")

                col = split.column()
                col.prop(mat, "use_shadeless")
                sub = col.column()
                sub.active = not mat.use_shadeless
                sub.prop(mat, "use_tangent_shading")
                sub.prop(mat, "use_cubic")


    class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
        bl_label = "Transparency"
        COMPAT_ENGINES = {'BLENDER_RENDER'}

        @classmethod
        def poll(cls, context):
            mat = context.material
            engine = context.scene.render.engine
            return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)

        def draw_header(self, context):
            mat = context.material

            if simple_material(mat):
                self.layout.prop(mat, "use_transparency", text="")

        def draw(self, context):
            layout = self.layout

            base_mat = context.material
            mat = active_node_mat(context.material)
            rayt = mat.raytrace_transparency

            if simple_material(base_mat):
                row = layout.row()
                row.active = mat.use_transparency
                row.prop(mat, "transparency_method", expand=True)

            split = layout.split()
            split.active = base_mat.use_transparency

            col = split.column()
            col.prop(mat, "alpha")
            row = col.row()
            row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
            row.prop(mat, "specular_alpha", text="Specular")

            col = split.column()
            col.active = (not mat.use_shadeless)
            col.prop(rayt, "fresnel")
            sub = col.column()
            sub.active = (rayt.fresnel > 0.0)
            sub.prop(rayt, "fresnel_factor", text="Blend")