release/scripts/startup/bl_ui/properties_material.py

   1 # ##### BEGIN GPL LICENSE BLOCK #####
   2 #
   3 #  This program is free software; you can redistribute it and/or
   4 #  modify it under the terms of the GNU General Public License
   5 #  as published by the Free Software Foundation; either version 2
   6 #  of the License, or (at your option) any later version.
   7 #
   8 #  This program is distributed in the hope that it will be useful,
   9 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11 #  GNU General Public License for more details.
  12 #
  13 #  You should have received a copy of the GNU General Public License
  14 #  along with this program; if not, write to the Free Software Foundation,
  15 #  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16 #
  17 # ##### END GPL LICENSE BLOCK #####
  18
  19 # <pep8 compliant>
  20 import bpy
  21 from bpy.types import Menu, Panel, UIList
  22 from rna_prop_ui import PropertyPanel
  23 from bpy.app.translations import pgettext_iface as iface_
  24
  25
  26 def active_node_mat(mat):
  27     # TODO, 2.4x has a pipeline section, for 2.5 we need to communicate
  28     # which settings from node-materials are used
  29     if mat is not None:
  30         mat_node = mat.active_node_material
  31         if mat_node:
  32             return mat_node
  33         else:
  34             return mat
  35
  36     return None
  37
  38
  39 def check_material(mat):
  40     if mat is not None:
  41         if mat.use_nodes:
  42             if mat.active_node_material is not None:
  43                 return True
  44             return False
  45         return True
  46     return False
  47
  48
  49 def simple_material(mat):
  50     if (mat is not None) and (not mat.use_nodes):
  51         return True
  52     return False
  53
  54
  55 class MATERIAL_MT_sss_presets(Menu):
  56     bl_label = "SSS Presets"
  57     preset_subdir = "sss"
  58     preset_operator = "script.execute_preset"
  59     draw = Menu.draw_preset
  60
  61
  62 class MATERIAL_MT_specials(Menu):
  63     bl_label = "Material Specials"
  64
  65     def draw(self, context):
  66         layout = self.layout
  67
  68         layout.operator("object.material_slot_copy", icon='COPY_ID')
  69         layout.operator("material.copy", icon='COPYDOWN')
  70         layout.operator("material.paste", icon='PASTEDOWN')
  71
  72
  73 class MATERIAL_UL_matslots(UIList):
  74     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
  75         # assert(isinstance(item, bpy.types.MaterialSlot)
  76         # ob = data
  77         slot = item
  78         ma = slot.material
  79         if self.layout_type in {'DEFAULT', 'COMPACT'}:
  80             if ma:
  81                 layout.prop(ma, "name", text="", emboss=False, icon_value=icon)
  82             else:
  83                 layout.label(text="", icon_value=icon)
  84             if ma and not context.scene.render.use_shading_nodes:
  85                 manode = ma.active_node_material
  86                 if manode:
  87                     layout.label(text=iface_("Node %s") % manode.name, translate=False, icon_value=layout.icon(manode))
  88                 elif ma.use_nodes:
  89                     layout.label(text="Node <none>")
  90         elif self.layout_type == 'GRID':
  91             layout.alignment = 'CENTER'
  92             layout.label(text="", icon_value=icon)
  93
  94
  95 class MaterialButtonsPanel:
  96     bl_space_type = 'PROPERTIES'
  97     bl_region_type = 'WINDOW'
  98     bl_context = "material"
  99     # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
 100
 101     @classmethod
 102     def poll(cls, context):
 103         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
 104
 105
 106 class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
 107     bl_label = ""
 108     bl_options = {'HIDE_HEADER'}
 109     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 110
 111     @classmethod
 112     def poll(cls, context):
 113         # An exception, don't call the parent poll func because
 114         # this manages materials for all engine types
 115
 116         engine = context.scene.render.engine
 117         return (context.material or context.object) and (engine in cls.COMPAT_ENGINES)
 118
 119     def draw(self, context):
 120         layout = self.layout
 121
 122         mat = context.material
 123         ob = context.object
 124         slot = context.material_slot
 125         space = context.space_data
 126         is_sortable = (len(ob.material_slots) > 1)
 127
 128         if ob:
 129             rows = 1
 130             if is_sortable:
 131                 rows = 4
 132
 133             row = layout.row()
 134
 135             row.template_list("MATERIAL_UL_matslots", "", ob, "material_slots", ob, "active_material_index", rows=rows)
 136
 137             col = row.column(align=True)
 138             col.operator("object.material_slot_add", icon='ZOOMIN', text="")
 139             col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
 140
 141             col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
 142
 143             if is_sortable:
 144                 col.separator()
 145
 146                 col.operator("object.material_slot_move", icon='TRIA_UP', text="").direction = 'UP'
 147                 col.operator("object.material_slot_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
 148
 149             if ob.mode == 'EDIT':
 150                 row = layout.row(align=True)
 151                 row.operator("object.material_slot_assign", text="Assign")
 152                 row.operator("object.material_slot_select", text="Select")
 153                 row.operator("object.material_slot_deselect", text="Deselect")
 154
 155         split = layout.split(percentage=0.65)
 156
 157         if ob:
 158             split.template_ID(ob, "active_material", new="material.new")
 159             row = split.row()
 160             if mat:
 161                 row.prop(mat, "use_nodes", icon='NODETREE', text="")
 162
 163             if slot:
 164                 row.prop(slot, "link", text="")
 165             else:
 166                 row.label()
 167         elif mat:
 168             split.template_ID(space, "pin_id")
 169             split.separator()
 170
 171         if mat:
 172             layout.prop(mat, "type", expand=True)
 173             if mat.use_nodes:
 174                 row = layout.row()
 175                 row.label(text="", icon='NODETREE')
 176                 if mat.active_node_material:
 177                     row.prop(mat.active_node_material, "name", text="")
 178                 else:
 179                     row.label(text="No material node selected")
 180
 181
 182 class MATERIAL_PT_preview(MaterialButtonsPanel, Panel):
 183     bl_label = "Preview"
 184     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 185
 186     def draw(self, context):
 187         self.layout.template_preview(context.material)
 188
 189
 190 class MATERIAL_PT_pipeline(MaterialButtonsPanel, Panel):
 191     bl_label = "Render Pipeline Options"
 192     bl_options = {'DEFAULT_CLOSED'}
 193     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 194
 195     @classmethod
 196     def poll(cls, context):
 197         mat = context.material
 198         engine = context.scene.render.engine
 199         return mat and (not simple_material(mat)) and (mat.type in {'SURFACE', 'WIRE', 'VOLUME'}) and (engine in cls.COMPAT_ENGINES)
 200
 201     def draw(self, context):
 202         layout = self. layout
 203
 204         mat = context.material
 205         mat_type = mat.type in {'SURFACE', 'WIRE'}
 206
 207         row = layout.row()
 208         row.active = mat_type
 209         row.prop(mat, "use_transparency")
 210         sub = row.column()
 211         sub.prop(mat, "offset_z")
 212
 213         sub.active = mat_type and mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
 214
 215         row = layout.row()
 216         row.active = mat.use_transparency or not mat_type
 217         row.prop(mat, "transparency_method", expand=True)
 218
 219         layout.separator()
 220
 221         split = layout.split()
 222         col = split.column()
 223
 224         col.prop(mat, "use_raytrace")
 225         col.prop(mat, "use_full_oversampling")
 226         sub = col.column()
 227         sub.active = mat_type
 228         sub.prop(mat, "use_sky")
 229         sub.prop(mat, "invert_z")
 230         col.prop(mat, "pass_index")
 231
 232         col = split.column()
 233         col.active = mat_type
 234
 235         col.prop(mat, "use_cast_shadows", text="Cast")
 236         col.prop(mat, "use_cast_shadows_only", text="Cast Only")
 237         col.prop(mat, "use_cast_buffer_shadows")
 238         sub = col.column()
 239         sub.active = mat.use_cast_buffer_shadows
 240         sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
 241         col.prop(mat, "use_cast_approximate")
 242
 243
 244 class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
 245     bl_label = "Diffuse"
 246     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 247
 248     @classmethod
 249     def poll(cls, context):
 250         mat = context.material
 251         engine = context.scene.render.engine
 252         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 253
 254     def draw(self, context):
 255         layout = self.layout
 256
 257         mat = active_node_mat(context.material)
 258
 259         split = layout.split()
 260
 261         col = split.column()
 262         col.prop(mat, "diffuse_color", text="")
 263         sub = col.column()
 264         sub.active = (not mat.use_shadeless)
 265         sub.prop(mat, "diffuse_intensity", text="Intensity")
 266
 267         col = split.column()
 268         col.active = (not mat.use_shadeless)
 269         col.prop(mat, "diffuse_shader", text="")
 270         col.prop(mat, "use_diffuse_ramp", text="Ramp")
 271
 272         col = layout.column()
 273         col.active = (not mat.use_shadeless)
 274         if mat.diffuse_shader == 'OREN_NAYAR':
 275             col.prop(mat, "roughness")
 276         elif mat.diffuse_shader == 'MINNAERT':
 277             col.prop(mat, "darkness")
 278         elif mat.diffuse_shader == 'TOON':
 279             row = col.row()
 280             row.prop(mat, "diffuse_toon_size", text="Size")
 281             row.prop(mat, "diffuse_toon_smooth", text="Smooth")
 282         elif mat.diffuse_shader == 'FRESNEL':
 283             row = col.row()
 284             row.prop(mat, "diffuse_fresnel", text="Fresnel")
 285             row.prop(mat, "diffuse_fresnel_factor", text="Factor")
 286
 287         if mat.use_diffuse_ramp:
 288             col = layout.column()
 289             col.active = (not mat.use_shadeless)
 290             col.separator()
 291             col.template_color_ramp(mat, "diffuse_ramp", expand=True)
 292             col.separator()
 293
 294             row = col.row()
 295             row.prop(mat, "diffuse_ramp_input", text="Input")
 296             row.prop(mat, "diffuse_ramp_blend", text="Blend")
 297
 298             col.prop(mat, "diffuse_ramp_factor", text="Factor")
 299
 300
 301 class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
 302     bl_label = "Specular"
 303     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 304
 305     @classmethod
 306     def poll(cls, context):
 307         mat = context.material
 308         engine = context.scene.render.engine
 309         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 310
 311     def draw(self, context):
 312         layout = self.layout
 313
 314         mat = active_node_mat(context.material)
 315
 316         layout.active = (not mat.use_shadeless)
 317
 318         split = layout.split()
 319
 320         col = split.column()
 321         col.prop(mat, "specular_color", text="")
 322         col.prop(mat, "specular_intensity", text="Intensity")
 323
 324         col = split.column()
 325         col.prop(mat, "specular_shader", text="")
 326         col.prop(mat, "use_specular_ramp", text="Ramp")
 327
 328         col = layout.column()
 329         if mat.specular_shader in {'COOKTORR', 'PHONG'}:
 330             col.prop(mat, "specular_hardness", text="Hardness")
 331         elif mat.specular_shader == 'BLINN':
 332             row = col.row()
 333             row.prop(mat, "specular_hardness", text="Hardness")
 334             row.prop(mat, "specular_ior", text="IOR")
 335         elif mat.specular_shader == 'WARDISO':
 336             col.prop(mat, "specular_slope", text="Slope")
 337         elif mat.specular_shader == 'TOON':
 338             row = col.row()
 339             row.prop(mat, "specular_toon_size", text="Size")
 340             row.prop(mat, "specular_toon_smooth", text="Smooth")
 341
 342         if mat.use_specular_ramp:
 343             layout.separator()
 344             layout.template_color_ramp(mat, "specular_ramp", expand=True)
 345             layout.separator()
 346
 347             row = layout.row()
 348             row.prop(mat, "specular_ramp_input", text="Input")
 349             row.prop(mat, "specular_ramp_blend", text="Blend")
 350
 351             layout.prop(mat, "specular_ramp_factor", text="Factor")
 352
 353
 354 class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
 355     bl_label = "Shading"
 356     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 357
 358     @classmethod
 359     def poll(cls, context):
 360         mat = context.material
 361         engine = context.scene.render.engine
 362         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 363
 364     def draw(self, context):
 365         layout = self.layout
 366
 367         mat = active_node_mat(context.material)
 368
 369         if mat.type in {'SURFACE', 'WIRE'}:
 370             split = layout.split()
 371
 372             col = split.column()
 373             sub = col.column()
 374             sub.active = not mat.use_shadeless
 375             sub.prop(mat, "emit")
 376             sub.prop(mat, "ambient")
 377             sub = col.column()
 378             sub.prop(mat, "translucency")
 379
 380             col = split.column()
 381             col.prop(mat, "use_shadeless")
 382             sub = col.column()
 383             sub.active = not mat.use_shadeless
 384             sub.prop(mat, "use_tangent_shading")
 385             sub.prop(mat, "use_cubic")
 386
 387
 388 class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
 389     bl_label = "Transparency"
 390     COMPAT_ENGINES = {'BLENDER_RENDER'}
 391
 392     @classmethod
 393     def poll(cls, context):
 394         mat = context.material
 395         engine = context.scene.render.engine
 396         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 397
 398     def draw_header(self, context):
 399         mat = context.material
 400
 401         if simple_material(mat):
 402             self.layout.prop(mat, "use_transparency", text="")
 403
 404     def draw(self, context):
 405         layout = self.layout
 406
 407         base_mat = context.material
 408         mat = active_node_mat(context.material)
 409         rayt = mat.raytrace_transparency
 410
 411         if simple_material(base_mat):
 412             row = layout.row()
 413             row.active = mat.use_transparency
 414             row.prop(mat, "transparency_method", expand=True)
 415
 416         split = layout.split()
 417         split.active = base_mat.use_transparency
 418
 419         col = split.column()
 420         col.prop(mat, "alpha")
 421         row = col.row()
 422         row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
 423         row.prop(mat, "specular_alpha", text="Specular")
 424
 425         col = split.column()
 426         col.active = (not mat.use_shadeless)
 427         col.prop(rayt, "fresnel")
 428         sub = col.column()
 429         sub.active = (rayt.fresnel > 0.0)
 430         sub.prop(rayt, "fresnel_factor", text="Blend")
 431
 432         if base_mat.transparency_method == 'RAYTRACE':
 433             layout.separator()
 434             split = layout.split()
 435             split.active = base_mat.use_transparency
 436
 437             col = split.column()
 438             col.prop(rayt, "ior")
 439             col.prop(rayt, "filter")
 440             col.prop(rayt, "falloff")
 441             col.prop(rayt, "depth_max")
 442             col.prop(rayt, "depth")
 443
 444             col = split.column()
 445             col.label(text="Gloss:")
 446             col.prop(rayt, "gloss_factor", text="Amount")
 447             sub = col.column()
 448             sub.active = rayt.gloss_factor < 1.0
 449             sub.prop(rayt, "gloss_threshold", text="Threshold")
 450             sub.prop(rayt, "gloss_samples", text="Samples")
 451
 452
 453 class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
 454     bl_label = "Mirror"
 455     bl_options = {'DEFAULT_CLOSED'}
 456     COMPAT_ENGINES = {'BLENDER_RENDER'}
 457
 458     @classmethod
 459     def poll(cls, context):
 460         mat = context.material
 461         engine = context.scene.render.engine
 462         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 463
 464     def draw_header(self, context):
 465         raym = active_node_mat(context.material).raytrace_mirror
 466
 467         self.layout.prop(raym, "use", text="")
 468
 469     def draw(self, context):
 470         layout = self.layout
 471
 472         mat = active_node_mat(context.material)
 473         raym = mat.raytrace_mirror
 474
 475         layout.active = raym.use
 476
 477         split = layout.split()
 478
 479         col = split.column()
 480         col.prop(raym, "reflect_factor")
 481         col.prop(mat, "mirror_color", text="")
 482
 483         col = split.column()
 484         col.prop(raym, "fresnel")
 485         sub = col.column()
 486         sub.active = (raym.fresnel > 0.0)
 487         sub.prop(raym, "fresnel_factor", text="Blend")
 488
 489         split = layout.split()
 490
 491         col = split.column()
 492         col.separator()
 493         col.prop(raym, "depth")
 494         col.prop(raym, "distance", text="Max Dist")
 495         col.separator()
 496         sub = col.split(percentage=0.4)
 497         sub.active = (raym.distance > 0.0)
 498         sub.label(text="Fade To:")
 499         sub.prop(raym, "fade_to", text="")
 500
 501         col = split.column()
 502         col.label(text="Gloss:")
 503         col.prop(raym, "gloss_factor", text="Amount")
 504         sub = col.column()
 505         sub.active = (raym.gloss_factor < 1.0)
 506         sub.prop(raym, "gloss_threshold", text="Threshold")
 507         sub.prop(raym, "gloss_samples", text="Samples")
 508         sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
 509
 510
 511 class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
 512     bl_label = "Subsurface Scattering"
 513     bl_options = {'DEFAULT_CLOSED'}
 514     COMPAT_ENGINES = {'BLENDER_RENDER'}
 515
 516     @classmethod
 517     def poll(cls, context):
 518         mat = context.material
 519         engine = context.scene.render.engine
 520         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 521
 522     def draw_header(self, context):
 523         mat = active_node_mat(context.material)
 524         sss = mat.subsurface_scattering
 525
 526         self.layout.active = (not mat.use_shadeless)
 527         self.layout.prop(sss, "use", text="")
 528
 529     def draw(self, context):
 530         layout = self.layout
 531
 532         mat = active_node_mat(context.material)
 533         sss = mat.subsurface_scattering
 534
 535         layout.active = (sss.use) and (not mat.use_shadeless)
 536
 537         row = layout.row().split()
 538         sub = row.row(align=True).split(align=True, percentage=0.75)
 539         sub.menu("MATERIAL_MT_sss_presets", text=bpy.types.MATERIAL_MT_sss_presets.bl_label)
 540         sub.operator("material.sss_preset_add", text="", icon='ZOOMIN')
 541         sub.operator("material.sss_preset_add", text="", icon='ZOOMOUT').remove_active = True
 542
 543         split = layout.split()
 544
 545         col = split.column()
 546         col.prop(sss, "ior")
 547         col.prop(sss, "scale")
 548         col.prop(sss, "color", text="")
 549         col.prop(sss, "radius", text="RGB Radius", expand=True)
 550
 551         col = split.column()
 552         sub = col.column(align=True)
 553         sub.label(text="Blend:")
 554         sub.prop(sss, "color_factor", text="Color")
 555         sub.prop(sss, "texture_factor", text="Texture")
 556         sub.label(text="Scattering Weight:")
 557         sub.prop(sss, "front")
 558         sub.prop(sss, "back")
 559         col.separator()
 560         col.prop(sss, "error_threshold", text="Error")
 561
 562
 563 class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
 564     bl_label = "Halo"
 565     COMPAT_ENGINES = {'BLENDER_RENDER'}
 566
 567     @classmethod
 568     def poll(cls, context):
 569         mat = context.material
 570         engine = context.scene.render.engine
 571         return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES)
 572
 573     def draw(self, context):
 574         layout = self.layout
 575
 576         mat = context.material  # don't use node material
 577         halo = mat.halo
 578
 579         def number_but(layout, toggle, number, name, color):
 580             row = layout.row(align=True)
 581             row.prop(halo, toggle, text="")
 582             sub = row.column(align=True)
 583             sub.active = getattr(halo, toggle)
 584             sub.prop(halo, number, text=name, translate=False)
 585             if not color == "":
 586                 sub.prop(mat, color, text="")
 587
 588         split = layout.split()
 589
 590         col = split.column()
 591         col.prop(mat, "alpha")
 592         col.prop(mat, "diffuse_color", text="")
 593         col.prop(halo, "seed")
 594
 595         col = split.column()
 596         col.prop(halo, "size")
 597         col.prop(halo, "hardness")
 598         col.prop(halo, "add")
 599
 600         layout.label(text="Options:")
 601
 602         split = layout.split()
 603         col = split.column()
 604         col.prop(halo, "use_texture")
 605         col.prop(halo, "use_vertex_normal")
 606         col.prop(halo, "use_extreme_alpha")
 607         col.prop(halo, "use_shaded")
 608         col.prop(halo, "use_soft")
 609
 610         col = split.column()
 611         number_but(col, "use_ring", "ring_count", iface_("Rings"), "mirror_color")
 612         number_but(col, "use_lines", "line_count", iface_("Lines"), "specular_color")
 613         number_but(col, "use_star", "star_tip_count", iface_("Star Tips"), "")
 614
 615
 616 class MATERIAL_PT_flare(MaterialButtonsPanel, Panel):
 617     bl_label = "Flare"
 618     COMPAT_ENGINES = {'BLENDER_RENDER'}
 619
 620     @classmethod
 621     def poll(cls, context):
 622         mat = context.material
 623         engine = context.scene.render.engine
 624         return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES)
 625
 626     def draw_header(self, context):
 627         halo = context.material.halo
 628
 629         self.layout.prop(halo, "use_flare_mode", text="")
 630
 631     def draw(self, context):
 632         layout = self.layout
 633
 634         mat = context.material  # don't use node material
 635         halo = mat.halo
 636
 637         layout.active = halo.use_flare_mode
 638
 639         split = layout.split()
 640
 641         col = split.column()
 642         col.prop(halo, "flare_size", text="Size")
 643         col.prop(halo, "flare_boost", text="Boost")
 644         col.prop(halo, "flare_seed", text="Seed")
 645
 646         col = split.column()
 647         col.prop(halo, "flare_subflare_count", text="Subflares")
 648         col.prop(halo, "flare_subflare_size", text="Subsize")
 649
 650
 651 class MATERIAL_PT_game_settings(MaterialButtonsPanel, Panel):
 652     bl_label = "Game Settings"
 653     COMPAT_ENGINES = {'BLENDER_GAME'}
 654
 655     @classmethod
 656     def poll(cls, context):
 657         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
 658
 659     def draw(self, context):
 660         layout = self.layout
 661         game = context.material.game_settings  # don't use node material
 662
 663         row = layout.row()
 664         row.prop(game, "use_backface_culling")
 665         row.prop(game, "invisible")
 666         row.prop(game, "text")
 667
 668         row = layout.row()
 669         row.label(text="Alpha Blend:")
 670         row.label(text="Face Orientation:")
 671         row = layout.row()
 672         row.prop(game, "alpha_blend", text="")
 673         row.prop(game, "face_orientation", text="")
 674
 675
 676 class MATERIAL_PT_physics(MaterialButtonsPanel, Panel):
 677     bl_label = "Physics"
 678     COMPAT_ENGINES = {'BLENDER_GAME'}
 679
 680     def draw_header(self, context):
 681         game = context.material.game_settings
 682         self.layout.prop(game, "physics", text="")
 683
 684     @classmethod
 685     def poll(cls, context):
 686         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
 687
 688     def draw(self, context):
 689         layout = self.layout
 690         layout.active = context.material.game_settings.physics
 691
 692         phys = context.material.physics  # don't use node material
 693
 694         split = layout.split()
 695         row = split.row()
 696         row.prop(phys, "friction")
 697         row.prop(phys, "elasticity", slider=True)
 698
 699         row = layout.row()
 700         row.label(text="Force Field:")
 701
 702         row = layout.row()
 703         row.prop(phys, "fh_force")
 704         row.prop(phys, "fh_damping", slider=True)
 705
 706         row = layout.row()
 707         row.prop(phys, "fh_distance")
 708         row.prop(phys, "use_fh_normal")
 709
 710
 711 class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
 712     bl_label = "Strand"
 713     bl_options = {'DEFAULT_CLOSED'}
 714     COMPAT_ENGINES = {'BLENDER_RENDER'}
 715
 716     @classmethod
 717     def poll(cls, context):
 718         mat = context.material
 719         engine = context.scene.render.engine
 720         return mat and (mat.type in {'SURFACE', 'WIRE', 'HALO'}) and (engine in cls.COMPAT_ENGINES)
 721
 722     def draw(self, context):
 723         layout = self.layout
 724
 725         mat = context.material  # don't use node material
 726         tan = mat.strand
 727
 728         split = layout.split()
 729
 730         col = split.column()
 731         sub = col.column(align=True)
 732         sub.label(text="Size:")
 733         sub.prop(tan, "root_size", text="Root")
 734         sub.prop(tan, "tip_size", text="Tip")
 735         sub.prop(tan, "size_min", text="Minimum")
 736         sub.prop(tan, "use_blender_units")
 737         sub = col.column()
 738         sub.active = (not mat.use_shadeless)
 739         sub.prop(tan, "use_tangent_shading")
 740         col.prop(tan, "shape")
 741
 742         col = split.column()
 743         col.label(text="Shading:")
 744         col.prop(tan, "width_fade")
 745         ob = context.object
 746         if ob and ob.type == 'MESH':
 747             col.prop_search(tan, "uv_layer", ob.data, "uv_textures", text="")
 748         else:
 749             col.prop(tan, "uv_layer", text="")
 750         col.separator()
 751         sub = col.column()
 752         sub.active = (not mat.use_shadeless)
 753         sub.label("Surface diffuse:")
 754         sub = col.column()
 755         sub.prop(tan, "blend_distance", text="Distance")
 756
 757
 758 class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
 759     bl_label = "Options"
 760     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 761
 762     @classmethod
 763     def poll(cls, context):
 764         mat = context.material
 765         engine = context.scene.render.engine
 766         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 767
 768     def draw(self, context):
 769         layout = self.layout
 770
 771         base_mat = context.material
 772         mat = active_node_mat(base_mat)
 773
 774         split = layout.split()
 775
 776         col = split.column()
 777         if simple_material(base_mat):
 778             col.prop(mat, "use_raytrace")
 779             col.prop(mat, "use_full_oversampling")
 780             col.prop(mat, "use_sky")
 781         col.prop(mat, "use_mist")
 782         if simple_material(base_mat):
 783             col.prop(mat, "invert_z")
 784             sub = col.row()
 785             sub.prop(mat, "offset_z")
 786             sub.active = mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
 787         sub = col.column(align=True)
 788         sub.label(text="Light Group:")
 789         sub.prop(mat, "light_group", text="")
 790         row = sub.row(align=True)
 791         row.active = bool(mat.light_group)
 792         row.prop(mat, "use_light_group_exclusive", text="Exclusive")
 793         row.prop(mat, "use_light_group_local", text="Local")
 794
 795         col = split.column()
 796         col.prop(mat, "use_face_texture")
 797         sub = col.column()
 798         sub.active = mat.use_face_texture
 799         sub.prop(mat, "use_face_texture_alpha")
 800         col.separator()
 801         col.prop(mat, "use_vertex_color_paint")
 802         col.prop(mat, "use_vertex_color_light")
 803         col.prop(mat, "use_object_color")
 804         col.prop(mat, "use_uv_project")
 805         if simple_material(base_mat):
 806             col.prop(mat, "pass_index")
 807
 808
 809 class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
 810     bl_label = "Shadow"
 811     bl_options = {'DEFAULT_CLOSED'}
 812     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
 813
 814     @classmethod
 815     def poll(cls, context):
 816         mat = context.material
 817         engine = context.scene.render.engine
 818         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
 819
 820     def draw(self, context):
 821         layout = self.layout
 822
 823         base_mat = context.material
 824         mat = active_node_mat(base_mat)
 825
 826         split = layout.split()
 827
 828         col = split.column()
 829         col.prop(mat, "use_shadows", text="Receive")
 830         col.prop(mat, "use_transparent_shadows", text="Receive Transparent")
 831         col.prop(mat, "use_only_shadow", text="Shadows Only")
 832         sub = col.column()
 833         sub.active = mat.use_only_shadow
 834         sub.prop(mat, "shadow_only_type", text="")
 835
 836         if not simple_material(base_mat):
 837             col = split.column()
 838
 839         col.prop(mat, "use_ray_shadow_bias", text="Auto Ray Bias")
 840         sub = col.column()
 841         sub.active = (not mat.use_ray_shadow_bias)
 842         sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
 843
 844         if simple_material(base_mat):
 845             col = split.column()
 846
 847             col.prop(mat, "use_cast_shadows", text="Cast")
 848             col.prop(mat, "use_cast_shadows_only", text="Cast Only")
 849             col.prop(mat, "use_cast_buffer_shadows")
 850         sub = col.column()
 851         sub.active = mat.use_cast_buffer_shadows
 852         if simple_material(base_mat):
 853             sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
 854         sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
 855         if simple_material(base_mat):
 856             col.prop(mat, "use_cast_approximate")
 857
 858
 859 class MATERIAL_PT_transp_game(MaterialButtonsPanel, Panel):
 860     bl_label = "Transparency"
 861     bl_options = {'DEFAULT_CLOSED'}
 862     COMPAT_ENGINES = {'BLENDER_GAME'}
 863
 864     @classmethod
 865     def poll(cls, context):
 866         mat = context.material
 867         engine = context.scene.render.engine
 868         return check_material(mat) and (engine in cls.COMPAT_ENGINES)
 869
 870     def draw_header(self, context):
 871         mat = context.material
 872
 873         if simple_material(mat):
 874             self.layout.prop(mat, "use_transparency", text="")
 875
 876     def draw(self, context):
 877         layout = self.layout
 878         base_mat = context.material
 879         mat = active_node_mat(base_mat)
 880
 881         if simple_material(base_mat):
 882             row = layout.row()
 883             row.active = mat.use_transparency
 884             row.prop(mat, "transparency_method", expand=True)
 885
 886         layout.prop(mat, "alpha")
 887
 888
 889 class VolumeButtonsPanel:
 890     bl_space_type = 'PROPERTIES'
 891     bl_region_type = 'WINDOW'
 892     bl_context = "material"
 893     COMPAT_ENGINES = {'BLENDER_RENDER'}
 894
 895     @classmethod
 896     def poll(cls, context):
 897         mat = context.material
 898         engine = context.scene.render.engine
 899         return mat and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
 900
 901
 902 class MATERIAL_PT_volume_density(VolumeButtonsPanel, Panel):
 903     bl_label = "Density"
 904     COMPAT_ENGINES = {'BLENDER_RENDER'}
 905
 906     def draw(self, context):
 907         layout = self.layout
 908
 909         vol = context.material.volume  # don't use node material
 910
 911         row = layout.row()
 912         row.prop(vol, "density")
 913         row.prop(vol, "density_scale")
 914
 915
 916 class MATERIAL_PT_volume_shading(VolumeButtonsPanel, Panel):
 917     bl_label = "Shading"
 918     COMPAT_ENGINES = {'BLENDER_RENDER'}
 919
 920     def draw(self, context):
 921         layout = self.layout
 922
 923         vol = context.material.volume  # don't use node material
 924
 925         split = layout.split()
 926
 927         col = split.column()
 928         col.prop(vol, "scattering")
 929         col.prop(vol, "asymmetry")
 930         col.prop(vol, "transmission_color")
 931
 932         col = split.column()
 933         sub = col.column(align=True)
 934         sub.prop(vol, "emission")
 935         sub.prop(vol, "emission_color", text="")
 936         sub = col.column(align=True)
 937         sub.prop(vol, "reflection")
 938         sub.prop(vol, "reflection_color", text="")
 939
 940
 941 class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, Panel):
 942     bl_label = "Lighting"
 943     COMPAT_ENGINES = {'BLENDER_RENDER'}
 944
 945     def draw(self, context):
 946         layout = self.layout
 947
 948         vol = context.material.volume  # don't use node material
 949
 950         split = layout.split()
 951
 952         col = split.column()
 953         col.prop(vol, "light_method", text="")
 954
 955         col = split.column()
 956
 957         if vol.light_method == 'SHADED':
 958             col.prop(vol, "use_external_shadows")
 959             col.prop(vol, "use_light_cache")
 960             sub = col.column()
 961             sub.active = vol.use_light_cache
 962             sub.prop(vol, "cache_resolution")
 963         elif vol.light_method in {'MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'}:
 964             sub = col.column()
 965             sub.enabled = True
 966             sub.active = False
 967             sub.label("Light Cache Enabled")
 968             col.prop(vol, "cache_resolution")
 969
 970             sub = col.column(align=True)
 971             sub.prop(vol, "ms_diffusion")
 972             sub.prop(vol, "ms_spread")
 973             sub.prop(vol, "ms_intensity")
 974
 975
 976 class MATERIAL_PT_volume_transp(VolumeButtonsPanel, Panel):
 977     bl_label = "Transparency"
 978     COMPAT_ENGINES = {'BLENDER_RENDER'}
 979
 980     @classmethod
 981     def poll(cls, context):
 982         mat = context.material
 983         engine = context.scene.render.engine
 984         return mat and simple_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
 985
 986     def draw(self, context):
 987         layout = self.layout
 988
 989         mat = context.material  # don't use node material
 990
 991         layout.prop(mat, "transparency_method", expand=True)
 992
 993
 994 class MATERIAL_PT_volume_integration(VolumeButtonsPanel, Panel):
 995     bl_label = "Integration"
 996     COMPAT_ENGINES = {'BLENDER_RENDER'}
 997
 998     def draw(self, context):
 999         layout = self.layout
1000
1001         vol = context.material.volume  # don't use node material
1002
1003         split = layout.split()
1004
1005         col = split.column()
1006         col.label(text="Step Calculation:")
1007         col.prop(vol, "step_method", text="")
1008         col = col.column(align=True)
1009         col.prop(vol, "step_size")
1010
1011         col = split.column()
1012         col.label()
1013         col.prop(vol, "depth_threshold")
1014
1015
1016 class MATERIAL_PT_volume_options(VolumeButtonsPanel, Panel):
1017     bl_label = "Options"
1018     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1019     bl_options = {'DEFAULT_CLOSED'}
1020
1021     @classmethod
1022     def poll(cls, context):
1023         mat = context.material
1024         engine = context.scene.render.engine
1025         return check_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
1026
1027     def draw(self, context):
1028         layout = self.layout
1029
1030         mat = active_node_mat(context.material)
1031
1032         split = layout.split()
1033
1034         col = split.column()
1035         if simple_material(context.material):
1036             col.prop(mat, "use_raytrace")
1037             col.prop(mat, "use_full_oversampling")
1038         col.prop(mat, "use_mist")
1039
1040         col = split.column()
1041         col.label(text="Light Group:")
1042         col.prop(mat, "light_group", text="")
1043         row = col.row()
1044         row.active = bool(mat.light_group)
1045         row.prop(mat, "use_light_group_exclusive", text="Exclusive")
1046
1047
1048 class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, Panel):
1049     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1050     _context_path = "material"
1051     _property_type = bpy.types.Material
1052
1053 if __name__ == "__main__":  # only for live edit.
1054     bpy.utils.register_module(__name__)