forked from bartvdbraak/blender
045d33dae0
Also removed some python code to check for node materials within the material and texture properties. It seems to go fine without it, and this should be handled by context instead.
947 lines
28 KiB
Python
947 lines
28 KiB
Python
# ##### BEGIN GPL LICENSE BLOCK #####
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License
|
|
# as published by the Free Software Foundation; either version 2
|
|
# of the License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software Foundation,
|
|
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
#
|
|
# ##### END GPL LICENSE BLOCK #####
|
|
|
|
# <pep8 compliant>
|
|
import bpy
|
|
from rna_prop_ui import PropertyPanel
|
|
|
|
narrowui = 180
|
|
|
|
|
|
|
|
class MATERIAL_MT_sss_presets(bpy.types.Menu):
|
|
bl_label = "SSS Presets"
|
|
preset_subdir = "sss"
|
|
preset_operator = "script.python_file_run"
|
|
draw = bpy.types.Menu.draw_preset
|
|
|
|
|
|
class MATERIAL_MT_specials(bpy.types.Menu):
|
|
bl_label = "Material Specials"
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
layout.operator("object.material_slot_copy", icon='COPY_ID')
|
|
layout.operator("material.copy", icon='COPYDOWN')
|
|
layout.operator("material.paste", icon='PASTEDOWN')
|
|
|
|
|
|
class MaterialButtonsPanel(bpy.types.Panel):
|
|
bl_space_type = 'PROPERTIES'
|
|
bl_region_type = 'WINDOW'
|
|
bl_context = "material"
|
|
# COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (engine in self.COMPAT_ENGINES)
|
|
|
|
|
|
class MATERIAL_PT_preview(MaterialButtonsPanel):
|
|
bl_label = "Preview"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def draw(self, context):
|
|
self.layout.template_preview(context.material)
|
|
|
|
|
|
class MATERIAL_PT_context_material(MaterialButtonsPanel):
|
|
bl_label = ""
|
|
bl_show_header = False
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
# An exception, dont call the parent poll func because
|
|
# this manages materials for all engine types
|
|
|
|
engine = context.scene.render.engine
|
|
return (context.material or context.object) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
ob = context.object
|
|
slot = context.material_slot
|
|
space = context.space_data
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
if ob:
|
|
row = layout.row()
|
|
|
|
row.template_list(ob, "material_slots", ob, "active_material_index", rows=2)
|
|
|
|
col = row.column(align=True)
|
|
col.operator("object.material_slot_add", icon='ZOOMIN', text="")
|
|
col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
|
|
|
|
col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
|
|
|
|
if ob.mode == 'EDIT':
|
|
row = layout.row(align=True)
|
|
row.operator("object.material_slot_assign", text="Assign")
|
|
row.operator("object.material_slot_select", text="Select")
|
|
row.operator("object.material_slot_deselect", text="Deselect")
|
|
|
|
if wide_ui:
|
|
split = layout.split(percentage=0.65)
|
|
|
|
if ob:
|
|
split.template_ID(ob, "active_material", new="material.new")
|
|
row = split.row()
|
|
if slot:
|
|
row.prop(slot, "link", text="")
|
|
else:
|
|
row.label()
|
|
elif mat:
|
|
split.template_ID(space, "pin_id")
|
|
split.separator()
|
|
else:
|
|
if ob:
|
|
layout.template_ID(ob, "active_material", new="material.new")
|
|
elif mat:
|
|
layout.template_ID(space, "pin_id")
|
|
|
|
if mat:
|
|
if wide_ui:
|
|
layout.prop(mat, "type", expand=True)
|
|
else:
|
|
layout.prop(mat, "type", text="")
|
|
|
|
|
|
class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel):
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
_context_path = "material"
|
|
|
|
|
|
class MATERIAL_PT_shading(MaterialButtonsPanel):
|
|
bl_label = "Shading"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
if mat.type in ('SURFACE', 'WIRE'):
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
sub = col.column()
|
|
sub.active = not mat.shadeless
|
|
sub.prop(mat, "emit")
|
|
sub.prop(mat, "ambient")
|
|
sub = col.column()
|
|
sub.prop(mat, "translucency")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "shadeless")
|
|
sub = col.column()
|
|
sub.active = not mat.shadeless
|
|
sub.prop(mat, "tangent_shading")
|
|
sub.prop(mat, "cubic")
|
|
|
|
elif mat.type == 'HALO':
|
|
layout.prop(mat, "alpha")
|
|
|
|
|
|
class MATERIAL_PT_strand(MaterialButtonsPanel):
|
|
bl_label = "Strand"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material # dont use node material
|
|
tan = mat.strand
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
sub = col.column(align=True)
|
|
sub.label(text="Size:")
|
|
sub.prop(tan, "root_size", text="Root")
|
|
sub.prop(tan, "tip_size", text="Tip")
|
|
sub.prop(tan, "min_size", text="Minimum")
|
|
sub.prop(tan, "blender_units")
|
|
sub = col.column()
|
|
sub.active = (not mat.shadeless)
|
|
sub.prop(tan, "tangent_shading")
|
|
col.prop(tan, "shape")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.label(text="Shading:")
|
|
col.prop(tan, "width_fade")
|
|
ob = context.object
|
|
if ob and ob.type == 'MESH':
|
|
col.prop_object(tan, "uv_layer", ob.data, "uv_textures", text="")
|
|
else:
|
|
col.prop(tan, "uv_layer", text="")
|
|
col.separator()
|
|
sub = col.column()
|
|
sub.active = (not mat.shadeless)
|
|
sub.prop(tan, "surface_diffuse")
|
|
sub = col.column()
|
|
sub.active = tan.surface_diffuse
|
|
sub.prop(tan, "blend_distance", text="Distance")
|
|
|
|
|
|
class MATERIAL_PT_physics(MaterialButtonsPanel):
|
|
bl_label = "Physics"
|
|
COMPAT_ENGINES = {'BLENDER_GAME'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
phys = context.material.physics # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(phys, "distance")
|
|
col.prop(phys, "friction")
|
|
col.prop(phys, "align_to_normal")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(phys, "force", slider=True)
|
|
col.prop(phys, "elasticity", slider=True)
|
|
col.prop(phys, "damp", slider=True)
|
|
|
|
|
|
class MATERIAL_PT_options(MaterialButtonsPanel):
|
|
bl_label = "Options"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE', 'HALO')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "traceable")
|
|
col.prop(mat, "full_oversampling")
|
|
col.prop(mat, "use_sky")
|
|
col.prop(mat, "exclude_mist")
|
|
col.prop(mat, "invert_z")
|
|
sub = col.row()
|
|
sub.prop(mat, "z_offset")
|
|
sub.active = mat.transparency and mat.transparency_method == 'Z_TRANSPARENCY'
|
|
sub = col.column(align=True)
|
|
sub.label(text="Light Group:")
|
|
sub.prop(mat, "light_group", text="")
|
|
row = sub.row()
|
|
row.active = bool(mat.light_group)
|
|
row.prop(mat, "light_group_exclusive", text="Exclusive")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "face_texture")
|
|
sub = col.column()
|
|
sub.active = mat.face_texture
|
|
sub.prop(mat, "face_texture_alpha")
|
|
col.separator()
|
|
col.prop(mat, "vertex_color_paint")
|
|
col.prop(mat, "vertex_color_light")
|
|
col.prop(mat, "object_color")
|
|
|
|
|
|
class MATERIAL_PT_shadow(MaterialButtonsPanel):
|
|
bl_label = "Shadow"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "shadows", text="Receive")
|
|
col.prop(mat, "receive_transparent_shadows", text="Receive Transparent")
|
|
col.prop(mat, "only_shadow", text="Shadows Only")
|
|
col.prop(mat, "cast_shadows_only", text="Cast Only")
|
|
col.prop(mat, "shadow_casting_alpha", text="Casting Alpha")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "cast_buffer_shadows")
|
|
sub = col.column()
|
|
sub.active = mat.cast_buffer_shadows
|
|
sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
|
|
col.prop(mat, "ray_shadow_bias", text="Auto Ray Bias")
|
|
sub = col.column()
|
|
sub.active = (not mat.ray_shadow_bias)
|
|
sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
|
|
col.prop(mat, "cast_approximate")
|
|
|
|
|
|
class MATERIAL_PT_diffuse(MaterialButtonsPanel):
|
|
bl_label = "Diffuse"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_color", text="")
|
|
sub = col.column()
|
|
sub.active = (not mat.shadeless)
|
|
sub.prop(mat, "diffuse_intensity", text="Intensity")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.active = (not mat.shadeless)
|
|
col.prop(mat, "diffuse_shader", text="")
|
|
col.prop(mat, "use_diffuse_ramp", text="Ramp")
|
|
|
|
col = layout.column()
|
|
col.active = (not mat.shadeless)
|
|
if mat.diffuse_shader == 'OREN_NAYAR':
|
|
col.prop(mat, "roughness")
|
|
elif mat.diffuse_shader == 'MINNAERT':
|
|
col.prop(mat, "darkness")
|
|
elif mat.diffuse_shader == 'TOON':
|
|
split = col.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_toon_size", text="Size")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_toon_smooth", text="Smooth")
|
|
elif mat.diffuse_shader == 'FRESNEL':
|
|
split = col.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_fresnel", text="Fresnel")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_fresnel_factor", text="Factor")
|
|
|
|
if mat.use_diffuse_ramp:
|
|
layout.separator()
|
|
layout.template_color_ramp(mat, "diffuse_ramp", expand=True)
|
|
layout.separator()
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_ramp_input", text="Input")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_ramp_blend", text="Blend")
|
|
row = layout.row()
|
|
row.prop(mat, "diffuse_ramp_factor", text="Factor")
|
|
|
|
|
|
class MATERIAL_PT_specular(MaterialButtonsPanel):
|
|
bl_label = "Specular"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
layout.active = (not mat.shadeless)
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "specular_color", text="")
|
|
col.prop(mat, "specular_intensity", text="Intensity")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "specular_shader", text="")
|
|
col.prop(mat, "use_specular_ramp", text="Ramp")
|
|
|
|
col = layout.column()
|
|
if mat.specular_shader in ('COOKTORR', 'PHONG'):
|
|
col.prop(mat, "specular_hardness", text="Hardness")
|
|
elif mat.specular_shader == 'BLINN':
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "specular_hardness", text="Hardness")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "specular_ior", text="IOR")
|
|
elif mat.specular_shader == 'WARDISO':
|
|
col.prop(mat, "specular_slope", text="Slope")
|
|
elif mat.specular_shader == 'TOON':
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "specular_toon_size", text="Size")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.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()
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "specular_ramp_input", text="Input")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(mat, "specular_ramp_blend", text="Blend")
|
|
|
|
row = layout.row()
|
|
row.prop(mat, "specular_ramp_factor", text="Factor")
|
|
|
|
|
|
class MATERIAL_PT_sss(MaterialButtonsPanel):
|
|
bl_label = "Subsurface Scattering"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw_header(self, context):
|
|
mat = context.material
|
|
sss = mat.subsurface_scattering
|
|
|
|
self.layout.active = (not mat.shadeless)
|
|
self.layout.prop(sss, "enabled", text="")
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
sss = mat.subsurface_scattering
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
layout.active = (sss.enabled) and (not mat.shadeless)
|
|
|
|
row = layout.row().split()
|
|
sub = row.row(align=True).split(percentage=0.75)
|
|
sub.menu("MATERIAL_MT_sss_presets", text="Presets")
|
|
sub.operator("material.sss_preset_add", text="Add")
|
|
|
|
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)
|
|
|
|
if wide_ui:
|
|
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_tolerance", text="Error")
|
|
|
|
|
|
class MATERIAL_PT_mirror(MaterialButtonsPanel):
|
|
bl_label = "Mirror"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw_header(self, context):
|
|
raym = context.material.raytrace_mirror
|
|
|
|
self.layout.prop(raym, "enabled", text="")
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
raym = mat.raytrace_mirror
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
layout.active = raym.enabled
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(raym, "reflect_factor")
|
|
col.prop(mat, "mirror_color", text="")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(raym, "fresnel")
|
|
sub = col.column()
|
|
sub.active = raym.fresnel > 0
|
|
sub.prop(raym, "fresnel_factor", text="Blend")
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.separator()
|
|
col.prop(raym, "distance", text="Max Dist")
|
|
col.prop(raym, "depth")
|
|
col.separator()
|
|
sub = col.split(percentage=0.4)
|
|
sub.label(text="Fade To:")
|
|
sub.prop(raym, "fade_to", text="")
|
|
|
|
if wide_ui:
|
|
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_transp(MaterialButtonsPanel):
|
|
bl_label = "Transparency"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type in ('SURFACE', 'WIRE')) and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw_header(self, context):
|
|
mat = context.material
|
|
|
|
self.layout.prop(mat, "transparency", text="")
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
rayt = mat.raytrace_transparency
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
row = layout.row()
|
|
row.active = mat.transparency and (not mat.shadeless)
|
|
if wide_ui:
|
|
row.prop(mat, "transparency_method", expand=True)
|
|
else:
|
|
row.prop(mat, "transparency_method", text="")
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "alpha")
|
|
row = col.row()
|
|
row.active = mat.transparency and (not mat.shadeless)
|
|
row.prop(mat, "specular_alpha", text="Specular")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.active = (not mat.shadeless)
|
|
col.prop(rayt, "fresnel")
|
|
sub = col.column()
|
|
sub.active = rayt.fresnel > 0
|
|
sub.prop(rayt, "fresnel_factor", text="Blend")
|
|
|
|
if mat.transparency_method == 'RAYTRACE':
|
|
layout.separator()
|
|
split = layout.split()
|
|
split.active = mat.transparency
|
|
|
|
col = split.column()
|
|
col.prop(rayt, "ior")
|
|
col.prop(rayt, "filter")
|
|
col.prop(rayt, "falloff")
|
|
col.prop(rayt, "limit")
|
|
col.prop(rayt, "depth")
|
|
|
|
if wide_ui:
|
|
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_transp_game(MaterialButtonsPanel):
|
|
bl_label = "Transparency"
|
|
bl_default_closed = True
|
|
COMPAT_ENGINES = {'BLENDER_GAME'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw_header(self, context):
|
|
mat = context.material
|
|
|
|
self.layout.prop(mat, "transparency", text="")
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material
|
|
rayt = mat.raytrace_transparency
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
row = layout.row()
|
|
row.active = mat.transparency and (not mat.shadeless)
|
|
if wide_ui:
|
|
row.prop(mat, "transparency_method", expand=True)
|
|
else:
|
|
row.prop(mat, "transparency_method", text="")
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "alpha")
|
|
|
|
|
|
class MATERIAL_PT_halo(MaterialButtonsPanel):
|
|
bl_label = "Halo"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material # dont use node material
|
|
halo = mat.halo
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(mat, "diffuse_color", text="")
|
|
col.prop(halo, "size")
|
|
col.prop(halo, "hardness")
|
|
col.prop(halo, "add")
|
|
col.label(text="Options:")
|
|
col.prop(halo, "texture")
|
|
col.prop(halo, "vertex_normal")
|
|
col.prop(halo, "xalpha")
|
|
col.prop(halo, "shaded")
|
|
col.prop(halo, "soft")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(halo, "ring")
|
|
sub = col.column()
|
|
sub.active = halo.ring
|
|
sub.prop(halo, "rings")
|
|
sub.prop(mat, "mirror_color", text="")
|
|
col.separator()
|
|
col.prop(halo, "lines")
|
|
sub = col.column()
|
|
sub.active = halo.lines
|
|
sub.prop(halo, "line_number", text="Lines")
|
|
sub.prop(mat, "specular_color", text="")
|
|
col.separator()
|
|
col.prop(halo, "star")
|
|
sub = col.column()
|
|
sub.active = halo.star
|
|
sub.prop(halo, "star_tips")
|
|
|
|
|
|
class MATERIAL_PT_flare(MaterialButtonsPanel):
|
|
bl_label = "Flare"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES)
|
|
|
|
def draw_header(self, context):
|
|
halo = context.material.halo
|
|
|
|
self.layout.prop(halo, "flare_mode", text="")
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material # dont use node material
|
|
halo = mat.halo
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
layout.active = halo.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")
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(halo, "flares_sub", text="Subflares")
|
|
col.prop(halo, "flare_subsize", text="Subsize")
|
|
|
|
|
|
class VolumeButtonsPanel(bpy.types.Panel):
|
|
bl_space_type = 'PROPERTIES'
|
|
bl_region_type = 'WINDOW'
|
|
bl_context = "material"
|
|
|
|
def poll(self, context):
|
|
mat = context.material
|
|
engine = context.scene.render.engine
|
|
return mat and (mat.type == 'VOLUME') and (engine in self.COMPAT_ENGINES)
|
|
|
|
|
|
class MATERIAL_PT_volume_density(VolumeButtonsPanel):
|
|
bl_label = "Density"
|
|
bl_default_closed = False
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
vol = context.material.volume # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
col = split.column()
|
|
col.prop(vol, "density")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.prop(vol, "density_scale")
|
|
|
|
|
|
class MATERIAL_PT_volume_shading(VolumeButtonsPanel):
|
|
bl_label = "Shading"
|
|
bl_default_closed = False
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
vol = context.material.volume # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(vol, "scattering")
|
|
col.prop(vol, "asymmetry")
|
|
col.prop(vol, "transmission_color")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
sub = col.column(align=True)
|
|
sub.prop(vol, "emission")
|
|
sub.prop(vol, "emission_color", text="")
|
|
sub = col.column(align=True)
|
|
sub.prop(vol, "reflection")
|
|
sub.prop(vol, "reflection_color", text="")
|
|
|
|
|
|
class MATERIAL_PT_volume_lighting(VolumeButtonsPanel):
|
|
bl_label = "Lighting"
|
|
bl_default_closed = False
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
vol = context.material.volume # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.prop(vol, "lighting_mode", text="")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
|
|
if vol.lighting_mode == 'SHADED':
|
|
col.prop(vol, "external_shadows")
|
|
col.prop(vol, "light_cache")
|
|
sub = col.column()
|
|
sub.active = vol.light_cache
|
|
sub.prop(vol, "cache_resolution")
|
|
elif vol.lighting_mode in ('MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'):
|
|
sub = col.column()
|
|
sub.enabled = True
|
|
sub.active = False
|
|
sub.prop(vol, "light_cache")
|
|
col.prop(vol, "cache_resolution")
|
|
|
|
sub = col.column(align=True)
|
|
sub.prop(vol, "ms_diffusion")
|
|
sub.prop(vol, "ms_spread")
|
|
sub.prop(vol, "ms_intensity")
|
|
|
|
|
|
class MATERIAL_PT_volume_transp(VolumeButtonsPanel):
|
|
bl_label = "Transparency"
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
mat = context.material # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
if wide_ui:
|
|
layout.prop(mat, "transparency_method", expand=True)
|
|
else:
|
|
layout.prop(mat, "transparency_method", text="")
|
|
|
|
|
|
class MATERIAL_PT_volume_integration(VolumeButtonsPanel):
|
|
bl_label = "Integration"
|
|
bl_default_closed = False
|
|
COMPAT_ENGINES = {'BLENDER_RENDER'}
|
|
|
|
def draw(self, context):
|
|
layout = self.layout
|
|
|
|
vol = context.material.volume # dont use node material
|
|
wide_ui = context.region.width > narrowui
|
|
|
|
split = layout.split()
|
|
|
|
col = split.column()
|
|
col.label(text="Step Calculation:")
|
|
col.prop(vol, "step_calculation", text="")
|
|
col = col.column(align=True)
|
|
col.prop(vol, "step_size")
|
|
|
|
if wide_ui:
|
|
col = split.column()
|
|
col.label()
|
|
col.prop(vol, "depth_cutoff")
|
|
|
|
|
|
classes = [
|
|
MATERIAL_PT_context_material,
|
|
MATERIAL_PT_preview,
|
|
MATERIAL_PT_diffuse,
|
|
MATERIAL_PT_specular,
|
|
MATERIAL_PT_shading,
|
|
MATERIAL_PT_transp,
|
|
MATERIAL_PT_mirror,
|
|
MATERIAL_PT_sss,
|
|
MATERIAL_PT_halo,
|
|
MATERIAL_PT_flare,
|
|
MATERIAL_PT_physics,
|
|
MATERIAL_PT_strand,
|
|
MATERIAL_PT_options,
|
|
MATERIAL_PT_shadow,
|
|
MATERIAL_PT_transp_game,
|
|
|
|
MATERIAL_MT_sss_presets,
|
|
MATERIAL_MT_specials,
|
|
|
|
MATERIAL_PT_volume_density,
|
|
MATERIAL_PT_volume_shading,
|
|
MATERIAL_PT_volume_lighting,
|
|
MATERIAL_PT_volume_transp,
|
|
|
|
MATERIAL_PT_volume_integration,
|
|
|
|
MATERIAL_PT_custom_props]
|
|
|
|
|
|
def register():
|
|
register = bpy.types.register
|
|
for cls in classes:
|
|
register(cls)
|
|
|
|
|
|
def unregister():
|
|
unregister = bpy.types.unregister
|
|
for cls in classes:
|
|
unregister(cls)
|
|
|
|
if __name__ == "__main__":
|
|
register()
|