def272d504501b424b3df377fecac98cf04ea2fd
[blender-staging.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             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         layout.active = mat.use_transparency
882
883         if simple_material(base_mat):
884             row = layout.row()
885             row.prop(mat, "transparency_method", expand=True)
886
887         layout.prop(mat, "alpha")
888         layout.prop(mat, "specular_alpha", text="Specular")
889
890
891 class VolumeButtonsPanel:
892     bl_space_type = 'PROPERTIES'
893     bl_region_type = 'WINDOW'
894     bl_context = "material"
895     COMPAT_ENGINES = {'BLENDER_RENDER'}
896
897     @classmethod
898     def poll(cls, context):
899         mat = context.material
900         engine = context.scene.render.engine
901         return mat and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
902
903
904 class MATERIAL_PT_volume_density(VolumeButtonsPanel, Panel):
905     bl_label = "Density"
906     COMPAT_ENGINES = {'BLENDER_RENDER'}
907
908     def draw(self, context):
909         layout = self.layout
910
911         vol = context.material.volume  # don't use node material
912
913         row = layout.row()
914         row.prop(vol, "density")
915         row.prop(vol, "density_scale")
916
917
918 class MATERIAL_PT_volume_shading(VolumeButtonsPanel, Panel):
919     bl_label = "Shading"
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, "scattering")
931         col.prop(vol, "asymmetry")
932         col.prop(vol, "transmission_color")
933
934         col = split.column()
935         sub = col.column(align=True)
936         sub.prop(vol, "emission")
937         sub.prop(vol, "emission_color", text="")
938         sub = col.column(align=True)
939         sub.prop(vol, "reflection")
940         sub.prop(vol, "reflection_color", text="")
941
942
943 class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, Panel):
944     bl_label = "Lighting"
945     COMPAT_ENGINES = {'BLENDER_RENDER'}
946
947     def draw(self, context):
948         layout = self.layout
949
950         vol = context.material.volume  # don't use node material
951
952         split = layout.split()
953
954         col = split.column()
955         col.prop(vol, "light_method", text="")
956
957         col = split.column()
958
959         if vol.light_method == 'SHADED':
960             col.prop(vol, "use_external_shadows")
961             col.prop(vol, "use_light_cache")
962             sub = col.column()
963             sub.active = vol.use_light_cache
964             sub.prop(vol, "cache_resolution")
965         elif vol.light_method in {'MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'}:
966             sub = col.column()
967             sub.enabled = True
968             sub.active = False
969             sub.label("Light Cache Enabled")
970             col.prop(vol, "cache_resolution")
971
972             sub = col.column(align=True)
973             sub.prop(vol, "ms_diffusion")
974             sub.prop(vol, "ms_spread")
975             sub.prop(vol, "ms_intensity")
976
977
978 class MATERIAL_PT_volume_transp(VolumeButtonsPanel, Panel):
979     bl_label = "Transparency"
980     COMPAT_ENGINES = {'BLENDER_RENDER'}
981
982     @classmethod
983     def poll(cls, context):
984         mat = context.material
985         engine = context.scene.render.engine
986         return mat and simple_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
987
988     def draw(self, context):
989         layout = self.layout
990
991         mat = context.material  # don't use node material
992
993         layout.prop(mat, "transparency_method", expand=True)
994
995
996 class MATERIAL_PT_volume_integration(VolumeButtonsPanel, Panel):
997     bl_label = "Integration"
998     COMPAT_ENGINES = {'BLENDER_RENDER'}
999
1000     def draw(self, context):
1001         layout = self.layout
1002
1003         vol = context.material.volume  # don't use node material
1004
1005         split = layout.split()
1006
1007         col = split.column()
1008         col.label(text="Step Calculation:")
1009         col.prop(vol, "step_method", text="")
1010         col = col.column(align=True)
1011         col.prop(vol, "step_size")
1012
1013         col = split.column()
1014         col.label()
1015         col.prop(vol, "depth_threshold")
1016
1017
1018 class MATERIAL_PT_volume_options(VolumeButtonsPanel, Panel):
1019     bl_label = "Options"
1020     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1021     bl_options = {'DEFAULT_CLOSED'}
1022
1023     @classmethod
1024     def poll(cls, context):
1025         mat = context.material
1026         engine = context.scene.render.engine
1027         return check_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
1028
1029     def draw(self, context):
1030         layout = self.layout
1031
1032         mat = active_node_mat(context.material)
1033
1034         split = layout.split()
1035
1036         col = split.column()
1037         if simple_material(context.material):
1038             col.prop(mat, "use_raytrace")
1039             col.prop(mat, "use_full_oversampling")
1040         col.prop(mat, "use_mist")
1041
1042         col = split.column()
1043         col.label(text="Light Group:")
1044         col.prop(mat, "light_group", text="")
1045         row = col.row()
1046         row.active = bool(mat.light_group)
1047         row.prop(mat, "use_light_group_exclusive", text="Exclusive")
1048
1049
1050 class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, Panel):
1051     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1052     _context_path = "material"
1053     _property_type = bpy.types.Material
1054
1055
1056 classes = (
1057     MATERIAL_MT_specials,
1058     MATERIAL_MT_sss_presets,
1059     MATERIAL_PT_context_material,
1060     MATERIAL_PT_custom_props,
1061     MATERIAL_PT_diffuse,
1062     MATERIAL_PT_flare,
1063     MATERIAL_PT_game_settings,
1064     MATERIAL_PT_halo,
1065     MATERIAL_PT_mirror,
1066     MATERIAL_PT_options,
1067     MATERIAL_PT_physics,
1068     MATERIAL_PT_pipeline,
1069     MATERIAL_PT_preview,
1070     MATERIAL_PT_shading,
1071     MATERIAL_PT_shadow,
1072     MATERIAL_PT_specular,
1073     MATERIAL_PT_sss,
1074     MATERIAL_PT_strand,
1075     MATERIAL_PT_transp,
1076     MATERIAL_PT_transp_game,
1077     MATERIAL_PT_volume_density,
1078     MATERIAL_PT_volume_integration,
1079     MATERIAL_PT_volume_lighting,
1080     MATERIAL_PT_volume_options,
1081     MATERIAL_PT_volume_shading,
1082     MATERIAL_PT_volume_transp,
1083     MATERIAL_UL_matslots,
1084 )
1085
1086 if __name__ == "__main__":  # only for live edit.
1087     from bpy.utils import register_class
1088     for cls in classes:
1089         register_class(cls)