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