Skip to content
Snippets Groups Projects
__init__.py 145 KiB
Newer Older
# ##### BEGIN GPL LICENSE BLOCK #####
Luca Bonavita's avatar
Luca Bonavita committed
#
#  This program is free software; you can redistribute it and/or
#  modify it under the terms of the GNU General Public License
#  as published by the Free Software Foundation; either version 2
#  of the License, or (at your option) any later version.
#
#  This program is distributed in the hope that it will be useful,
#  but WITHOUT ANY WARRANTY; without even the implied warranty of
#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#  GNU General Public License for more details.
#
#  You should have received a copy of the GNU General Public License
#  along with this program; if not, write to the Free Software Foundation,
#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
#
# ##### END GPL LICENSE BLOCK #####

    "name": "POV-3.7",
    "author": "Campbell Barton, Silvio Falcinelli, Maurice Raybaud, "
              "Constantin Rahn, Bastien Montagne, Leonid Desyatkov",
    "version": (0, 1, 0),
    "blender": (2, 80, 0),
    "location": "Render > Engine > POV-Ray 3.7",
    "description": "Basic POV-Ray 3.7 integration for blender",
    "wiki_url": "http://wiki.blender.org/index.php/Extensions:2.6/Py/"
                "Scripts/Render/POV-Ray",
Luca Bonavita's avatar
Luca Bonavita committed

if "bpy" in locals():
    import importlib
    importlib.reload(ui)
    importlib.reload(render)
    importlib.reload(shading)
    importlib.reload(update_files)

else:
    import bpy
    from bpy.utils import register_class, unregister_class
    #import addon_utils # To use some other addons
    import nodeitems_utils #for Nodes
    from nodeitems_utils import NodeCategory, NodeItem #for Nodes
    from bl_operators.presets import AddPresetBase
    from bpy.types import (
            AddonPreferences,
            PropertyGroup,
            )
    from bpy.props import (
            StringProperty,
            BoolProperty,
            IntProperty,
            FloatProperty,
            FloatVectorProperty,
            EnumProperty,
            PointerProperty,
            )
    from . import (
            ui,
            render,
            update_files,
            )
def string_strip_hyphen(name):
    return name.replace("-", "")
Luca Bonavita's avatar
Luca Bonavita committed

###############################################################################
# Scene POV properties.
###############################################################################
class RenderPovSettingsScene(PropertyGroup):
    #Linux SDL-window enable
    sdl_window_enable: BoolProperty(
            name="Enable SDL window",
            description="Enable the SDL window in Linux OS",
            default=True)
    # File Options
    text_block: StringProperty(
            name="Text Scene Name",
            description="Name of POV-Ray scene to use. "
                        "Set when clicking Run to render current text only",
            maxlen=1024)
    tempfiles_enable: BoolProperty(
            name="Enable Tempfiles",
            description="Enable the OS-Tempfiles. Otherwise set the path where"
                        " to save the files",
            default=True)
    pov_editor: BoolProperty(
            name="POV-Ray editor",
            description="Don't Close POV-Ray editor after rendering (Overridden"
                        " by /EXIT command)",
    deletefiles_enable: BoolProperty(
            name="Delete files",
            description="Delete files after rendering. "
                        "Doesn't work with the image",
            default=True)
    scene_name: StringProperty(
            name="Scene Name",
            description="Name of POV-Ray scene to create. Empty name will use "
                        "the name of the blend file",
    scene_path: StringProperty(
            name="Export scene path",
            # Bug in POV-Ray RC3
            # description="Path to directory where the exported scene "
                        # "(POV and INI) is created",
            description="Path to directory where the files are created",
            maxlen=1024, subtype="DIR_PATH")
    renderimage_path: StringProperty(
            name="Rendered image path",
            description="Full path to directory where the rendered image is "
                        "saved",
            maxlen=1024, subtype="DIR_PATH")
    list_lf_enable: BoolProperty(
            name="LF in lists",
            description="Enable line breaks in lists (vectors and indices). "
                        "Disabled: lists are exported in one line",
            default=True)
    # Not a real pov option, just to know if we should write
    radio_enable: BoolProperty(
            name="Enable Radiosity",
            description="Enable POV-Rays radiosity calculation",
    radio_display_advanced: BoolProperty(
            name="Advanced Options",
            description="Show advanced options",
            default=False)
    media_enable: BoolProperty(
            name="Enable Media",
            description="Enable POV-Rays atmospheric media",
            default=False)
    media_samples: IntProperty(
            description="Number of samples taken from camera to first object "
                        "encountered along ray path for media calculation",
            min=1, max=100, default=35)
    media_scattering_type: EnumProperty(
            name="Scattering Type",
            description="Scattering model",
            items=(('1', "1 Isotropic", "The simplest form of scattering because"
                                      " it is independent of direction."),
                   ('2', "2 Mie haze ", "For relatively small particles such as "
                                      "minuscule water droplets of fog, cloud "
                                      "particles, and particles responsible "
                                      "for the polluted sky. In this model the"
                                      " scattering is extremely directional in"
                                      " the forward direction i.e. the amount "
                                      "of scattered light is largest when the "
                                      "incident light is anti-parallel to the "
                                      "viewing direction (the light goes "
                                      "directly to the viewer). It is smallest"
                                      " when the incident light is parallel to"
                                      " the viewing direction. "),
                   ('3', "3 Mie murky", "Like haze but much more directional"),
                   ('4', "4 Rayleigh", "For extremely small particles such as "
                                     "molecules of the air. The amount of "
                                     "scattered light depends on the incident"
                                     " light angle. It is largest when the "
                                     "incident light is parallel or "
                                     "anti-parallel to the viewing direction "
                                     "and smallest when the incident light is "
                                     "perpendicular to viewing direction."),
                   ('5', "5 Henyey-Greenstein", "The default eccentricity value "
                                              "of zero defines isotropic "
                                              "scattering while positive "
                                              "values lead to scattering in "
                                              "the direction of the light and "
                                              "negative values lead to "
                                              "scattering in the opposite "
                                              "direction of the light. Larger "
                                              "values of e (or smaller values "
                                              "in the negative case) increase "
                                              "the directional property of the"
                                              " scattering.")),
    media_diffusion_scale: FloatProperty(
            name="Scale", description="Scale factor of Media Diffusion Color",
            precision=12, step=0.00000001, min=0.000000001, max=1.0,
            default=(1.0))
    media_diffusion_color: FloatVectorProperty(
            name="Media Diffusion Color", description="The atmospheric media color",
            precision=4, step=0.01, min=0, soft_max=1,
            default=(0.001, 0.001, 0.001),
            options={'ANIMATABLE'},
    media_absorption_scale: FloatProperty(
            name="Scale", description="Scale factor of Media Absorption Color. "
                                      "use 1/depth of media volume in meters",
            precision=12, step=0.000001, min=0.000000001, max=1.0,
            default=(0.00002))
    media_absorption_color: FloatVectorProperty(
            name="Media Absorption Color", description="The atmospheric media absorption color",
            precision=4, step=0.01, min=0, soft_max=1,
            default=(0.0, 0.0, 0.0),
            options={'ANIMATABLE'},
Campbell Barton's avatar
Campbell Barton committed
            subtype='COLOR')
    media_eccentricity: FloatProperty(
            name="Media Eccenticity Factor", description="Positive values lead"
                 " to scattering in the direction of the light and negative "
                 "values lead to scattering in the opposite direction of the "
                 "light. Larger values of e (or smaller values in the negative"
                 " case) increase the directional property of the scattering.",
            precision=2, step=0.01, min=-1.0, max=1.0,
            default=(0.0),
            options={'ANIMATABLE'})
    baking_enable: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Enable Baking",
            description="Enable POV-Rays texture baking",
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=False)
    indentation_character: EnumProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Indentation",
            description="Select the indentation type",
            items=(('NONE', "None", "No indentation"),
                   ('TAB', "Tabs", "Indentation with tabs"),
                   ('SPACE', "Spaces", "Indentation with spaces")),
            default='SPACE')
    indentation_spaces: IntProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Quantity of spaces",
            description="The number of spaces for indentation",
            min=1, max=10, default=4)
    comments_enable: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Enable Comments",
            description="Add comments to pov file",
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=True)

    # Real pov options
    command_line_switches: StringProperty(
            description="Command line switches consist of a + (plus) or - "
                        "(minus) sign, followed by one or more alphabetic "
                        "characters and possibly a numeric value",
    antialias_enable: BoolProperty(
            name="Anti-Alias", description="Enable Anti-Aliasing",
            default=True)
    antialias_method: EnumProperty(
            name="Method",
            description="AA-sampling method. Type 1 is an adaptive, "
                        "non-recursive, super-sampling method. Type 2 is an "
                        "adaptive and recursive super-sampling method. Type 3 "
                        "is a stochastic halton based super-sampling method",
            items=(("0", "non-recursive AA", "Type 1 Sampling in POV-Ray"),
                   ("1", "recursive AA", "Type 2 Sampling in POV-Ray"),
                   ("2", "stochastic AA", "Type 3 Sampling in UberPOV")),
            default="1")
    antialias_confidence: FloatProperty(
            name="Antialias Confidence",
            description="how surely the computed color "
                        "of a given pixel is indeed"
                        "within the threshold error margin",
            min=0.0001, max=1.0000, default=0.9900, precision=4)
    antialias_depth: IntProperty(
            name="Antialias Depth", description="Depth of pixel for sampling",
            min=1, max=9, default=3)
    antialias_threshold: FloatProperty(
            name="Antialias Threshold", description="Tolerance for sub-pixels",
            min=0.0, max=1.0, soft_min=0.05, soft_max=0.5, default=0.03)
    jitter_enable: BoolProperty(
            description="Enable Jittering. Adds noise into the sampling "
                        "process (it should be avoided to use jitter in "
                        "animation)",
    jitter_amount: FloatProperty(
            name="Jitter Amount", description="Amount of jittering",
            min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=1.0)
    antialias_gamma: FloatProperty(
            description="POV-Ray compares gamma-adjusted values for super "
                        "sampling. Antialias Gamma sets the Gamma before "
                        "comparison",
            min=0.0, max=5.0, soft_min=0.01, soft_max=2.5, default=2.5)
    max_trace_level: IntProperty(
            description="Number of reflections/refractions allowed on ray "
                        "path",
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=1, max=256, default=5)
Campbell Barton's avatar
Campbell Barton committed

#######NEW from Lanuhum
    adc_bailout_enable: BoolProperty(
    adc_bailout: FloatProperty(
            name="ADC Bailout",
            description="",
            min=0.0, max=1000.0,default=0.00392156862745, precision=3)

    ambient_light_enable: BoolProperty(
    ambient_light: FloatVectorProperty(
            name="Ambient Light",
            description="Ambient light is used to simulate the effect of inter-diffuse reflection",
            precision=4, step=0.01, min=0, soft_max=1,
            default=(1, 1, 1), options={'ANIMATABLE'}, subtype='COLOR',
    )
    global_settings_advanced: BoolProperty(
    irid_wavelength_enable: BoolProperty(
    irid_wavelength: FloatVectorProperty(
            name="Irid Wavelength",
            description=(
                "Iridescence calculations depend upon the dominant "
                "wavelengths of the primary colors of red, green and blue light"
            ),
            precision=4, step=0.01, min=0, soft_max=1,
            default=(0.25,0.18,0.14), options={'ANIMATABLE'}, subtype='COLOR')

    charset: EnumProperty(
            description="This allows you to specify the assumed character set of all text strings",
            items=(("ascii", "ASCII", ""),
                   ("utf8", "UTF-8", ""),
                   ("sys", "SYS", "")),
            default="utf8")

    max_intersections_enable: BoolProperty(
    max_intersections: IntProperty(
            description="POV-Ray uses a set of internal stacks to collect ray/object intersection points",
    number_of_waves_enable: BoolProperty(
    number_of_waves: IntProperty(
            description=(
                "The waves and ripples patterns are generated by summing a series of waves, "
                "each with a slightly different center and size"
            ),
    noise_generator_enable: BoolProperty(
    noise_generator: IntProperty(
            description="There are three noise generators implemented",
    ########################### PHOTONS #######################################
    photon_enable: BoolProperty(
            name="Photons",
            description="Enable global photons",
            default=False)

    photon_enable_count: BoolProperty(
            name="Spacing / Count",
            description="Enable count photons",
            default=False)

    photon_count: IntProperty(
            name="Count",
            description="Photons count",
            min=1, max=100000000, default=20000)
    photon_spacing: FloatProperty(
            description="Average distance between photons on surfaces. half "
                        "this get four times as many surface photons",
            min=0.001, max=1.000, default=0.005,
            soft_min=0.001, soft_max=1.000, precision=3)
    photon_max_trace_level: IntProperty(
            description="Number of reflections/refractions allowed on ray "
                        "path",
            min=1, max=256, default=5)

    photon_adc_bailout: FloatProperty(
            description="The adc_bailout for photons. Use adc_bailout = "
                        "0.01 / brightest_ambient_object for good results",
            min=0.0, max=1000.0, default=0.1,
            soft_min=0.0, soft_max=1.0, precision=3)
    photon_gather_min: IntProperty(
            name="Gather Min", description="Minimum number of photons gathered"
                                           "for each point",
            min=1, max=256, default=20)

    photon_gather_max: IntProperty(
            name="Gather Max", description="Maximum number of photons gathered for each point",
            min=1, max=256, default=100)
    photon_map_file_save_load: EnumProperty(
            name="Operation",
            description="Load or Save photon map file",
            items=(("NONE", "None", ""),
                   ("save", "Save", ""),
                   ("load", "Load", "")),
            default="NONE")

    photon_map_filename: StringProperty(
            name="Filename",
            description="",
            maxlen=1024)

    photon_map_dir: StringProperty(
            name="Directory",
            description="",
            maxlen=1024, subtype="DIR_PATH")

    photon_map_file: StringProperty(
            name="File",
            description="",
            maxlen=1024, subtype="FILE_PATH")
    #########RADIOSITY########
    radio_adc_bailout: FloatProperty(
            description="The adc_bailout for radiosity rays. Use "
                        "adc_bailout = 0.01 / brightest_ambient_object for good results",
            min=0.0, max=1000.0, soft_min=0.0, soft_max=1.0, default=0.0039, precision=4)
    radio_always_sample: BoolProperty(
            description="Only use the data from the pretrace step and not gather "
                        "any new samples during the final radiosity pass",
    radio_brightness: FloatProperty(
            description="Amount objects are brightened before being returned "
            min=0.0, max=1000.0, soft_min=0.0, soft_max=10.0, default=1.0)

    radio_count: IntProperty(
            description="Number of rays for each new radiosity value to be calculated "
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=1, max=10000, soft_max=1600, default=35)
    radio_error_bound: FloatProperty(
            description="One of the two main speed/quality tuning values, "
            min=0.0, max=1000.0, soft_min=0.1, soft_max=10.0, default=1.8)

    radio_gray_threshold: FloatProperty(
            description="One of the two main speed/quality tuning values, "
            min=0.0, max=1.0, soft_min=0, soft_max=1, default=0.0)

    radio_low_error_factor: FloatProperty(
            description="Just enough samples is slightly blotchy. Low error changes error "
                        "tolerance for less critical last refining pass",
            min=0.000001, max=1.0, soft_min=0.000001, soft_max=1.0, default=0.5)
    radio_media: BoolProperty(
            name="Media", description="Radiosity estimation can be affected by media",
    radio_subsurface: BoolProperty(
            name="Subsurface", description="Radiosity estimation can be affected by Subsurface Light Transport",
            default=False)

    radio_minimum_reuse: FloatProperty(
            description="Fraction of the screen width which sets the minimum radius of reuse "
                        "for each sample point (At values higher than 2% expect errors)",
            min=0.0, max=1.0, soft_min=0.1, soft_max=0.1, default=0.015, precision=3)
    radio_maximum_reuse: FloatProperty(
            name="Maximum Reuse",
            description="The maximum reuse parameter works in conjunction with, and is similar to that of minimum reuse, "
                        "the only difference being that it is an upper bound rather than a lower one",
    radio_nearest_count: IntProperty(
            description="Number of old ambient values blended together to "
            min=1, max=20, default=5)

    radio_normal: BoolProperty(
            name="Normals", description="Radiosity estimation can be affected by normals",
            default=False)

    radio_recursion_limit: IntProperty(
            description="how many recursion levels are used to calculate "
            min=1, max=20, default=1)
Luca Bonavita's avatar
Luca Bonavita committed

    radio_pretrace_start: FloatProperty(
            description="Fraction of the screen width which sets the size of the "
                        "blocks in the mosaic preview first pass",
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=0.01, max=1.00, soft_min=0.02, soft_max=1.0, default=0.08)

    radio_pretrace_end: FloatProperty(
            description="Fraction of the screen width which sets the size of the blocks "
            min=0.000925, max=1.00, soft_min=0.01, soft_max=1.00, default=0.04, precision=3)
Maurice Raybaud's avatar
Maurice Raybaud committed

###############################################################################
# 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(
            description="Newton's thin film interference (like an oil slick on a puddle of "
                        "water or the rainbow hues of a soap bubble.)",
    mirror_use_IOR: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Correct Reflection",
            description="Use same IOR as raytrace transparency to calculate mirror reflections. "
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=False)

    mirror_metallic: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Metallic Reflection",
            description="mirror reflections get colored as diffuse (for metallic materials)",
            default=False)

    conserve_energy: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Conserve Energy",
            description="Light transmitted is more correctly reduced by mirror reflections, "
                        "also the sum of diffuse and translucency gets reduced below one ",
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=True)

    irid_amount: FloatProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="amount",
            description="Contribution of the iridescence effect to the overall surface color. "
                        "As a rule of thumb keep to around 0.25 (25% contribution) or less, "
                        "but experiment. If the surface is coming out too white, try lowering "
                        "the diffuse and possibly the ambient values of the surface",
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=0.0, max=1.0, soft_min=0.01, soft_max=1.0, default=0.25)

    irid_thickness: FloatProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="thickness",
            description="A very thin film will have a high frequency of color changes while a "
                        "thick film will have large areas of color",
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=0.0, max=1000.0, soft_min=0.1, soft_max=10.0, default=1)

    irid_turbulence: FloatProperty(
            name="turbulence", description="This parameter varies the thickness",
Maurice Raybaud's avatar
Maurice Raybaud committed
            min=0.0, max=10.0, soft_min=0.000, soft_max=1.0, default=0)

    interior_fade_color: FloatVectorProperty(
            name="Interior Fade Color", description="Color of filtered attenuation for transparent "
            precision=4, step=0.01, min=0.0, soft_max=1.0,
            default=(0, 0, 0), options={'ANIMATABLE'}, subtype='COLOR')

    caustics_enable: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Caustics",
            description="use only fake refractive caustics (default) or photon based "
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=True)

    fake_caustics: BoolProperty(
            name="Fake Caustics", description="use only (Fast) fake refractive caustics",
Maurice Raybaud's avatar
Maurice Raybaud committed
            default=True)

    fake_caustics_power: FloatProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Fake caustics power",
            description="Values typically range from 0.0 to 1.0 or higher. Zero is no caustics. "
                        "Low, non-zero values give broad hot-spots while higher values give "
                        "tighter, smaller simulated focal points",
            min=0.00, max=10.0, soft_min=0.00, soft_max=5.0, default=0.07)
    refraction_caustics: BoolProperty(
            name="Refractive Caustics", description="hotspots of light focused when going through the material",
            default=True)
    photons_dispersion: FloatProperty(
            description="Light passing through will be separated according to wavelength. "
                        "This ratio of refractive indices for violet to red controls how much "
                        "the colors are spread out 1 = no dispersion, good values are 1.01 to 1.1",
            min=1.0000, max=10.000, soft_min=1.0000, soft_max=1.1000, precision=4, default=1.0000)
    photons_dispersion_samples: IntProperty(
            name="Dispersion Samples", description="Number of color-steps for dispersion",
            min=2, max=128, default=7)

    photons_reflection: BoolProperty(
Maurice Raybaud's avatar
Maurice Raybaud committed
            name="Reflective Photon Caustics",
            description="Use this to make your Sauron's ring ;-P",
            default=False)

    refraction_type: EnumProperty(
                   ("1", "Fake Caustics", "use fake caustics"),
                   ("2", "Photons Caustics", "use photons for refractive caustics")],
Maurice Raybaud's avatar
Maurice Raybaud committed
            description="use fake caustics (fast) or true photons for refractive Caustics",
    ##################################CustomPOV Code############################
    replacement_text: StringProperty(
            description="Type the declared name in custom POV code or an external "
    def use_material_nodes_callback(self, context):
        if hasattr(context.space_data, "tree_type"):
            context.space_data.tree_type = 'ObjectNodeTree'
        mat=context.object.active_material
        if mat.pov.material_use_nodes:
            mat.use_nodes=True
            tree = mat.node_tree
            tree.name=mat.name
            links = tree.links
            default = True
            if len(tree.nodes) == 2:
                o = 0
                m = 0
                for node in tree.nodes:
                    if node.type in {"OUTPUT","MATERIAL"}:
                        tree.nodes.remove(node)
                        default = True
                for node in tree.nodes:
                    if node.bl_idname == 'PovrayOutputNode':
                        o+=1
                    if node.bl_idname == 'PovrayTextureNode':
                        m+=1
                if o == 1 and m == 1:
                    default = False
            elif len(tree.nodes) == 0:
                default = True
            else:
                default = False
            if default:
                output = tree.nodes.new('PovrayOutputNode')
                output.location = 200,200
                tmap = tree.nodes.new('PovrayTextureNode')
                tmap.location = 0,200
                links.new(tmap.outputs[0],output.inputs[0])
                tmap.select = True
Campbell Barton's avatar
Campbell Barton committed
                tree.nodes.active = tmap
        else:
            mat.use_nodes=False


    def use_texture_nodes_callback(self, context):
        tex=context.object.active_material.active_texture
        if tex.pov.texture_use_nodes:
            tex.use_nodes=True
            if len(tex.node_tree.nodes)==2:
                for node in tex.node_tree.nodes:
                    if node.type in {"OUTPUT","CHECKER"}:
                        tex.node_tree.nodes.remove(node)
        else:
            tex.use_nodes=False

    def node_active_callback(self, context):
        items = []
        mat=context.material
        mat.node_tree.nodes
        for node in mat.node_tree.nodes:
            node.select=False
        for node in mat.node_tree.nodes:
            if node.name==mat.pov.material_active_node:
                node.select=True
                mat.node_tree.nodes.active=node

                return node

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

    def pigment_normal_callback(self, context):
        render = context.scene.pov.render
        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)
1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
    
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
1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
            # 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##########################
Campbell Barton's avatar
Campbell Barton committed
###############################################################################
# Povray Nodes
###############################################################################
class PovraySocketUniversal(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketUniversal'
    bl_label = 'Povray Socket'
    value_unlimited: bpy.props.FloatProperty(default=0.0)
    value_0_1: bpy.props.FloatProperty(min=0.0,max=1.0,default=0.0)
    value_0_10: bpy.props.FloatProperty(min=0.0,max=10.0,default=0.0)
    value_000001_10: bpy.props.FloatProperty(min=0.000001,max=10.0,default=0.0)
    value_1_9: bpy.props.IntProperty(min=1,max=9,default=1)
    value_0_255: bpy.props.IntProperty(min=0,max=255,default=0)
    percent: bpy.props.FloatProperty(min=0.0,max=100.0,default=0.0)
    def draw(self, context, layout, node, text):
        space = context.space_data
        tree = space.edit_tree
        links=tree.links
        if self.is_linked:
            value=[]
            for link in links:
                if link.from_node==node:
                    inps=link.to_node.inputs
Campbell Barton's avatar
Campbell Barton committed
                    for inp in inps:
                        if inp.bl_idname=="PovraySocketFloat_0_1" and inp.is_linked:
                            prop="value_0_1"
                            if prop not in value:
                                value.append(prop)
                        if inp.bl_idname=="PovraySocketFloat_000001_10" and inp.is_linked:
                            prop="value_000001_10"
                            if prop not in value:
                                value.append(prop)
                        if inp.bl_idname=="PovraySocketFloat_0_10" and inp.is_linked:
                            prop="value_0_10"
                            if prop not in value:
                                value.append(prop)
                        if inp.bl_idname=="PovraySocketInt_1_9" and inp.is_linked:
                            prop="value_1_9"
                            if prop not in value:
                                value.append(prop)
                        if inp.bl_idname=="PovraySocketInt_0_255" and inp.is_linked:
                            prop="value_0_255"
                            if prop not in value:
                                value.append(prop)
                        if inp.bl_idname=="PovraySocketFloatUnlimited" and inp.is_linked:
                            prop="value_unlimited"
                            if prop not in value:
                                value.append(prop)
            if len(value)==1:
                layout.prop(self, "%s"%value[0], text=text)
            else:
                layout.prop(self, "percent", text="Percent")
        else:
            layout.prop(self, "percent", text=text)
    def draw_color(self, context, node):
        return (1, 0, 0, 1)

class PovraySocketFloat_0_1(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketFloat_0_1'
    bl_label = 'Povray Socket'
    default_value: bpy.props.FloatProperty(description="Input node Value_0_1",min=0,max=1,default=0)
    def draw(self, context, layout, node, text):
        if self.is_linked:
            layout.label(text)
        else:
            layout.prop(self, "default_value", text=text, slider=True)

    def draw_color(self, context, node):
        return (0.5, 0.7, 0.7, 1)

class PovraySocketFloat_0_10(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketFloat_0_10'
    bl_label = 'Povray Socket'
    default_value: bpy.props.FloatProperty(description="Input node Value_0_10",min=0,max=10,default=0)
    def draw(self, context, layout, node, text):
        if node.bl_idname == 'ShaderNormalMapNode' and node.inputs[2].is_linked:
            layout.label(text='')
            self.hide_value=True
        if self.is_linked:
            layout.label(text)
        else:
            layout.prop(self, "default_value", text=text, slider=True)
    def draw_color(self, context, node):
        return (0.65, 0.65, 0.65, 1)

class PovraySocketFloat_10(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketFloat_10'
    bl_label = 'Povray Socket'
    default_value: bpy.props.FloatProperty(description="Input node Value_10",min=-10,max=10,default=0)
    def draw(self, context, layout, node, text):
        if node.bl_idname == 'ShaderNormalMapNode' and node.inputs[2].is_linked:
            layout.label(text='')
            self.hide_value=True
        if self.is_linked:
            layout.label(text)
        else:
            layout.prop(self, "default_value", text=text, slider=True)
    def draw_color(self, context, node):
        return (0.65, 0.65, 0.65, 1)

class PovraySocketFloatPositive(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketFloatPositive'
    bl_label = 'Povray Socket'
    default_value: bpy.props.FloatProperty(description="Input Node Value Positive", min=0.0, default=0)
    def draw(self, context, layout, node, text):
        if self.is_linked:
            layout.label(text)
        else:
            layout.prop(self, "default_value", text=text, slider=True)
    def draw_color(self, context, node):
        return (0.045, 0.005, 0.136, 1)

class PovraySocketFloat_000001_10(bpy.types.NodeSocket):
    bl_idname = 'PovraySocketFloat_000001_10'
    bl_label = 'Povray Socket'
    default_value: bpy.props.FloatProperty(min=0.000001,max=10,default=0.000001)
    def draw(self, context, layout, node, text):
        if self.is_output or self.is_linked:
            layout.label(text)
        else:
            layout.prop(self, "default_value", text=text, slider=True)
    def draw_color(self, context, node):
Loading
Loading full blame...