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