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