diff options
Diffstat (limited to 'release/scripts/ui/buttons_material.py')
| -rw-r--r-- | release/scripts/ui/buttons_material.py | 727 |
1 files changed, 727 insertions, 0 deletions
diff --git a/release/scripts/ui/buttons_material.py b/release/scripts/ui/buttons_material.py new file mode 100644 index 00000000000..ee7193da301 --- /dev/null +++ b/release/scripts/ui/buttons_material.py @@ -0,0 +1,727 @@ + +import bpy + +class MaterialButtonsPanel(bpy.types.Panel): + __space_type__ = 'PROPERTIES' + __region_type__ = 'WINDOW' + __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_data.engine + return mat and (engine in self.COMPAT_ENGINES) + +class MATERIAL_PT_preview(MaterialButtonsPanel): + __label__ = "Preview" + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def draw(self, context): + self.layout.template_preview(context.material) + +class MATERIAL_PT_context_material(MaterialButtonsPanel): + __show_header__ = False + COMPAT_ENGINES = set(['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_data.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 + + if ob: + row = layout.row() + + row.template_list(ob, "materials", ob, "active_material_index", rows=2) + + col = row.column(align=True) + col.itemO("object.material_slot_add", icon='ICON_ZOOMIN', text="") + col.itemO("object.material_slot_remove", icon='ICON_ZOOMOUT', text="") + + if ob.mode == 'EDIT': + row = layout.row(align=True) + row.itemO("object.material_slot_assign", text="Assign") + row.itemO("object.material_slot_select", text="Select") + row.itemO("object.material_slot_deselect", text="Deselect") + + split = layout.split(percentage=0.65) + + if ob: + split.template_ID(ob, "active_material", new="material.new") + row = split.row() + if slot: + row.itemR(slot, "link", text="") + else: + row.itemL() + elif mat: + split.template_ID(space, "pin_id") + split.itemS() + + if mat: + layout.itemR(mat, "type", expand=True) + +class MATERIAL_PT_shading(MaterialButtonsPanel): + __label__ = "Shading" + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + + if mat.type in ('SURFACE', 'WIRE'): + split = layout.split() + + col = split.column() + sub = col.column() + sub.active = not mat.shadeless + sub.itemR(mat, "emit") + sub.itemR(mat, "ambient") + sub = col.column() + sub.itemR(mat, "translucency") + + col = split.column() + col.itemR(mat, "shadeless") + sub = col.column() + sub.active = not mat.shadeless + sub.itemR(mat, "tangent_shading") + sub.itemR(mat, "cubic") + + elif mat.type == 'HALO': + layout.itemR(mat, "alpha") + +class MATERIAL_PT_strand(MaterialButtonsPanel): + __label__ = "Strand" + __default_closed__ = True + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + tan = mat.strand + + split = layout.split() + + col = split.column(align=True) + col.itemL(text="Size:") + col.itemR(tan, "root_size", text="Root") + col.itemR(tan, "tip_size", text="Tip") + col.itemR(tan, "min_size", text="Minimum") + col.itemR(tan, "blender_units") + sub = col.column() + sub.active = (not mat.shadeless) + sub.itemR(tan, "tangent_shading") + col.itemR(tan, "shape") + + col = split.column() + col.itemL(text="Shading:") + col.itemR(tan, "width_fade") + col.itemR(tan, "uv_layer") + col.itemS() + sub = col.column() + sub.active = (not mat.shadeless) + sub.itemR(tan, "surface_diffuse") + sub = col.column() + sub.active = tan.surface_diffuse + sub.itemR(tan, "blend_distance", text="Distance") + +class MATERIAL_PT_physics(MaterialButtonsPanel): + __label__ = "Physics" + COMPAT_ENGINES = set(['BLENDER_GAME']) + + def draw(self, context): + layout = self.layout + + phys = context.material.physics + + split = layout.split() + + col = split.column() + col.itemR(phys, "distance") + col.itemR(phys, "friction") + col.itemR(phys, "align_to_normal") + + col = split.column() + col.itemR(phys, "force", slider=True) + col.itemR(phys, "elasticity", slider=True) + col.itemR(phys, "damp", slider=True) + +class MATERIAL_PT_options(MaterialButtonsPanel): + __label__ = "Options" + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + + split = layout.split() + + col = split.column() + col.itemR(mat, "traceable") + col.itemR(mat, "full_oversampling") + col.itemR(mat, "sky") + col.itemR(mat, "exclude_mist") + col.itemR(mat, "invert_z") + sub = col.column(align=True) + sub.itemL(text="Light Group:") + sub.itemR(mat, "light_group", text="") + row = sub.row() + row.active = mat.light_group + row.itemR(mat, "light_group_exclusive", text="Exclusive") + + col = split.column() + col.itemR(mat, "face_texture") + sub = col.column() + sub.active = mat.face_texture + sub.itemR(mat, "face_texture_alpha") + col.itemS() + col.itemR(mat, "vertex_color_paint") + col.itemR(mat, "vertex_color_light") + col.itemR(mat, "object_color") + +class MATERIAL_PT_shadow(MaterialButtonsPanel): + __label__ = "Shadow" + __default_closed__ = True + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + + split = layout.split() + + col = split.column() + col.itemR(mat, "shadows", text="Receive") + col.itemR(mat, "receive_transparent_shadows", text="Receive Transparent") + col.itemR(mat, "only_shadow", text="Shadows Only") + col.itemR(mat, "cast_shadows_only", text="Cast Only") + col.itemR(mat, "shadow_casting_alpha", text="Casting Alpha") + + col = split.column() + col.itemR(mat, "cast_buffer_shadows") + sub = col.column() + sub.active = mat.cast_buffer_shadows + sub.itemR(mat, "shadow_buffer_bias", text="Buffer Bias") + col.itemR(mat, "ray_shadow_bias", text="Auto Ray Bias") + sub = col.column() + sub.active = (not mat.ray_shadow_bias) + sub.itemR(mat, "shadow_ray_bias", text="Ray Bias") + +class MATERIAL_PT_diffuse(MaterialButtonsPanel): + __label__ = "Diffuse" + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + + split = layout.split() + + col = split.column() + col.itemR(mat, "diffuse_color", text="") + sub = col.column() + sub.active = (not mat.shadeless) + sub.itemR(mat, "diffuse_intensity", text="Intensity") + + col = split.column() + col.active = (not mat.shadeless) + col.itemR(mat, "diffuse_shader", text="") + col.itemR(mat, "use_diffuse_ramp", text="Ramp") + + col = layout.column() + col.active = (not mat.shadeless) + if mat.diffuse_shader == 'OREN_NAYAR': + col.itemR(mat, "roughness") + elif mat.diffuse_shader == 'MINNAERT': + col.itemR(mat, "darkness") + elif mat.diffuse_shader == 'TOON': + row = col.row() + row.itemR(mat, "diffuse_toon_size", text="Size") + row.itemR(mat, "diffuse_toon_smooth", text="Smooth") + elif mat.diffuse_shader == 'FRESNEL': + row = col.row() + row.itemR(mat, "diffuse_fresnel", text="Fresnel") + row.itemR(mat, "diffuse_fresnel_factor", text="Factor") + + if mat.use_diffuse_ramp: + layout.itemS() + layout.template_color_ramp(mat, "diffuse_ramp", expand=True) + layout.itemS() + row = layout.row() + split = row.split(percentage=0.3) + split.itemL(text="Input:") + split.itemR(mat, "diffuse_ramp_input", text="") + split = row.split(percentage=0.3) + split.itemL(text="Blend:") + split.itemR(mat, "diffuse_ramp_blend", text="") + +class MATERIAL_PT_specular(MaterialButtonsPanel): + __label__ = "Specular" + COMPAT_ENGINES = set(['BLENDER_RENDER', 'BLENDER_GAME']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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 + + layout.active = (not mat.shadeless) + + split = layout.split() + + col = split.column() + col.itemR(mat, "specular_color", text="") + col.itemR(mat, "specular_intensity", text="Intensity") + + col = split.column() + col.itemR(mat, "specular_shader", text="") + col.itemR(mat, "use_specular_ramp", text="Ramp") + + col = layout.column() + if mat.specular_shader in ('COOKTORR', 'PHONG'): + col.itemR(mat, "specular_hardness", text="Hardness") + elif mat.specular_shader == 'BLINN': + row = col.row() + row.itemR(mat, "specular_hardness", text="Hardness") + row.itemR(mat, "specular_ior", text="IOR") + elif mat.specular_shader == 'WARDISO': + col.itemR(mat, "specular_slope", text="Slope") + elif mat.specular_shader == 'TOON': + row = col.row() + row.itemR(mat, "specular_toon_size", text="Size") + row.itemR(mat, "specular_toon_smooth", text="Smooth") + + if mat.use_specular_ramp: + layout.itemS() + layout.template_color_ramp(mat, "specular_ramp", expand=True) + layout.itemS() + row = layout.row() + split = row.split(percentage=0.3) + split.itemL(text="Input:") + split.itemR(mat, "specular_ramp_input", text="") + split = row.split(percentage=0.3) + split.itemL(text="Blend:") + split.itemR(mat, "specular_ramp_blend", text="") + +class MATERIAL_PT_sss(MaterialButtonsPanel): + __label__ = "Subsurface Scattering" + __default_closed__ = True + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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.itemR(sss, "enabled", text="") + + def draw(self, context): + layout = self.layout + + mat = context.material + sss = mat.subsurface_scattering + + layout.active = sss.enabled + + split = layout.split() + split.active = (not mat.shadeless) + + col = split.column() + col.itemR(sss, "ior") + col.itemR(sss, "scale") + col.itemR(sss, "color", text="") + col.itemR(sss, "radius", text="RGB Radius") + + col = split.column() + sub = col.column(align=True) + sub.itemL(text="Blend:") + sub.itemR(sss, "color_factor", text="Color") + sub.itemR(sss, "texture_factor", text="Texture") + sub.itemL(text="Scattering Weight:") + sub.itemR(sss, "front") + sub.itemR(sss, "back") + col.itemS() + col.itemR(sss, "error_tolerance", text="Error") + +class MATERIAL_PT_mirror(MaterialButtonsPanel): + __label__ = "Mirror" + __default_closed__ = True + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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.itemR(raym, "enabled", text="") + + def draw(self, context): + layout = self.layout + + mat = context.material + raym = mat.raytrace_mirror + + layout.active = raym.enabled + + split = layout.split() + + col = split.column() + col.itemR(raym, "reflect_factor") + col.itemR(mat, "mirror_color", text="") + + col = split.column() + col.itemR(raym, "fresnel") + sub = col.column() + sub.active = raym.fresnel > 0 + sub.itemR(raym, "fresnel_factor", text="Blend") + + split = layout.split() + + col = split.column() + col.itemS() + col.itemR(raym, "distance", text="Max Dist") + col.itemR(raym, "depth") + col.itemS() + sub = col.split(percentage=0.4) + sub.itemL(text="Fade To:") + sub.itemR(raym, "fade_to", text="") + + col = split.column() + col.itemL(text="Gloss:") + col.itemR(raym, "gloss_factor", text="Amount") + sub = col.column() + sub.active = raym.gloss_factor < 1.0 + sub.itemR(raym, "gloss_threshold", text="Threshold") + sub.itemR(raym, "gloss_samples", text="Samples") + sub.itemR(raym, "gloss_anisotropic", text="Anisotropic") + +class MATERIAL_PT_transp(MaterialButtonsPanel): + __label__= "Transparency" + __default_closed__ = True + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.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.itemR(mat, "transparency", text="") + + def draw(self, context): + layout = self.layout + + mat = context.material + rayt = mat.raytrace_transparency + + row = layout.row() + row.active = mat.transparency and (not mat.shadeless) + row.itemR(mat, "transparency_method", expand=True) + + split = layout.split() + + col = split.column() + col.itemR(mat, "alpha") + row = col.row() + row.active = mat.transparency and (not mat.shadeless) + row.itemR(mat, "specular_alpha", text="Specular") + + col = split.column() + col.active = (not mat.shadeless) + col.itemR(rayt, "fresnel") + sub = col.column() + sub.active = rayt.fresnel > 0 + sub.itemR(rayt, "fresnel_factor", text="Blend") + + if mat.transparency_method == 'RAYTRACE': + layout.itemS() + split = layout.split() + split.active = mat.transparency + + col = split.column() + col.itemR(rayt, "ior") + col.itemR(rayt, "filter") + col.itemR(rayt, "falloff") + col.itemR(rayt, "limit") + col.itemR(rayt, "depth") + + col = split.column() + col.itemL(text="Gloss:") + col.itemR(rayt, "gloss_factor", text="Amount") + sub = col.column() + sub.active = rayt.gloss_factor < 1.0 + sub.itemR(rayt, "gloss_threshold", text="Threshold") + sub.itemR(rayt, "gloss_samples", text="Samples") + +class MATERIAL_PT_halo(MaterialButtonsPanel): + __label__= "Halo" + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.engine + return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES) + + def draw(self, context): + layout = self.layout + + mat = context.material + halo = mat.halo + + split = layout.split() + + col = split.column() + col.itemR(mat, "diffuse_color", text="") + col.itemR(halo, "size") + col.itemR(halo, "hardness") + col.itemR(halo, "add") + col.itemL(text="Options:") + col.itemR(halo, "texture") + col.itemR(halo, "vertex_normal") + col.itemR(halo, "xalpha") + col.itemR(halo, "shaded") + col.itemR(halo, "soft") + + col = split.column() + col.itemR(halo, "ring") + sub = col.column() + sub.active = halo.ring + sub.itemR(halo, "rings") + sub.itemR(mat, "mirror_color", text="") + col.itemS() + col.itemR(halo, "lines") + sub = col.column() + sub.active = halo.lines + sub.itemR(halo, "line_number", text="Lines") + sub.itemR(mat, "specular_color", text="") + col.itemS() + col.itemR(halo, "star") + sub = col.column() + sub.active = halo.star + sub.itemR(halo, "star_tips") + +class MATERIAL_PT_flare(MaterialButtonsPanel): + __label__= "Flare" + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.engine + return mat and (mat.type == 'HALO') and (engine in self.COMPAT_ENGINES) + + def draw_header(self, context): + halo = context.material.halo + + self.layout.itemR(halo, "flare_mode", text="") + + def draw(self, context): + layout = self.layout + + mat = context.material + halo = mat.halo + + layout.active = halo.flare_mode + + split = layout.split() + + col = split.column() + col.itemR(halo, "flare_size", text="Size") + col.itemR(halo, "flare_boost", text="Boost") + col.itemR(halo, "flare_seed", text="Seed") + col = split.column() + col.itemR(halo, "flares_sub", text="Subflares") + col.itemR(halo, "flare_subsize", text="Subsize") + +bpy.types.register(MATERIAL_PT_context_material) +bpy.types.register(MATERIAL_PT_preview) +bpy.types.register(MATERIAL_PT_diffuse) +bpy.types.register(MATERIAL_PT_specular) +bpy.types.register(MATERIAL_PT_shading) +bpy.types.register(MATERIAL_PT_transp) +bpy.types.register(MATERIAL_PT_mirror) +bpy.types.register(MATERIAL_PT_sss) +bpy.types.register(MATERIAL_PT_halo) +bpy.types.register(MATERIAL_PT_flare) +bpy.types.register(MATERIAL_PT_physics) +bpy.types.register(MATERIAL_PT_strand) +bpy.types.register(MATERIAL_PT_options) +bpy.types.register(MATERIAL_PT_shadow) + +# Volumetrics +class VolumeButtonsPanel(bpy.types.Panel): + __space_type__ = 'PROPERTIES' + __region_type__ = 'WINDOW' + __context__ = "material" + + def poll(self, context): + mat = context.material + engine = context.scene.render_data.engine + return mat and (mat.type == 'VOLUME') and (engine in self.COMPAT_ENGINES) + +class MATERIAL_PT_volume_density(VolumeButtonsPanel): + __label__ = "Density" + __default_closed__ = False + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def draw(self, context): + layout = self.layout + + mat = context.material + vol = context.material.volume + + split = layout.split() + row = split.row() + row.itemR(vol, "density") + row.itemR(vol, "density_scale") + + +class MATERIAL_PT_volume_shading(VolumeButtonsPanel): + __label__ = "Shading" + __default_closed__ = False + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def draw(self, context): + layout = self.layout + + vol = context.material.volume + + split = layout.split() + + col = split.column() + col.itemR(vol, "scattering") + col.itemR(vol, "asymmetry") + col.itemR(vol, "transmission_color") + + col = split.column() + sub = col.column(align=True) + sub.itemR(vol, "emission") + sub.itemR(vol, "emission_color", text="") + sub = col.column(align=True) + sub.itemR(vol, "reflection") + sub.itemR(vol, "reflection_color", text="") + +class MATERIAL_PT_volume_lighting(VolumeButtonsPanel): + __label__ = "Lighting" + __default_closed__ = False + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def draw(self, context): + layout = self.layout + + vol = context.material.volume + + split = layout.split() + + col = split.column() + col.itemR(vol, "scattering_mode", text="") + + col = split.column() + + if vol.scattering_mode == 'SINGLE_SCATTERING': + col.itemR(vol, "light_cache") + sub = col.column() + sub.active = vol.light_cache + sub.itemR(vol, "cache_resolution") + elif vol.scattering_mode in ('MULTIPLE_SCATTERING', 'SINGLE_PLUS_MULTIPLE_SCATTERING'): + sub = col.column() + sub.enabled = True + sub.active = False + sub.itemR(vol, "light_cache") + col.itemR(vol, "cache_resolution") + + sub = col.column(align=True) + sub.itemR(vol, "ms_diffusion") + sub.itemR(vol, "ms_spread") + sub.itemR(vol, "ms_intensity") + + +class MATERIAL_PT_volume_transp(VolumeButtonsPanel): + __label__= "Transparency" + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def draw(self, context): + layout = self.layout + + mat = context.material + + layout.itemR(mat, "transparency_method", expand=True) + +class MATERIAL_PT_volume_integration(VolumeButtonsPanel): + __label__ = "Integration" + __default_closed__ = False + COMPAT_ENGINES = set(['BLENDER_RENDER']) + + def draw(self, context): + layout = self.layout + + vol = context.material.volume + + split = layout.split() + + col = split.column() + col.itemL(text="Step Calculation:") + col.itemR(vol, "step_calculation", text="") + col = col.column(align=True) + col.itemR(vol, "step_size") + + col = split.column() + col.itemL() + col.itemR(vol, "depth_cutoff") + +bpy.types.register(MATERIAL_PT_volume_density) +bpy.types.register(MATERIAL_PT_volume_shading) +bpy.types.register(MATERIAL_PT_volume_lighting) +bpy.types.register(MATERIAL_PT_volume_transp) +bpy.types.register(MATERIAL_PT_volume_integration) |