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