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