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