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