Render: make Cycles and Evee support each other's output material nodes.
[blender.git] / release / scripts / startup / bl_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 bpy.types import Menu, Panel, UIList
22 from rna_prop_ui import PropertyPanel
23 from bpy.app.translations import pgettext_iface as iface_
24 from bpy_extras.node_utils import find_node_input, find_output_node
25
26 def active_node_mat(mat):
27     # TODO, 2.4x has a pipeline section, for 2.5 we need to communicate
28     # which settings from node-materials are used
29     if mat is not None:
30         mat_node = mat.active_node_material
31         if mat_node:
32             return mat_node
33         else:
34             return mat
35
36     return None
37
38
39 def check_material(mat):
40     if mat is not None:
41         if mat.use_nodes:
42             if mat.active_node_material is not None:
43                 return True
44             return False
45         return True
46     return False
47
48
49 def simple_material(mat):
50     if (mat is not None) and (not mat.use_nodes):
51         return True
52     return False
53
54
55 class MATERIAL_MT_sss_presets(Menu):
56     bl_label = "SSS Presets"
57     preset_subdir = "sss"
58     preset_operator = "script.execute_preset"
59     draw = Menu.draw_preset
60
61
62 class MATERIAL_MT_specials(Menu):
63     bl_label = "Material Specials"
64
65     def draw(self, context):
66         layout = self.layout
67
68         layout.operator("object.material_slot_copy", icon='COPY_ID')
69         layout.operator("material.copy", icon='COPYDOWN')
70         layout.operator("material.paste", icon='PASTEDOWN')
71
72
73 class MATERIAL_UL_matslots(UIList):
74
75     def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
76         # assert(isinstance(item, bpy.types.MaterialSlot)
77         # ob = data
78         slot = item
79         ma = slot.material
80         if self.layout_type in {'DEFAULT', 'COMPACT'}:
81             if ma:
82                 layout.prop(ma, "name", text="", emboss=False, icon_value=icon)
83             else:
84                 layout.label(text="", icon_value=icon)
85             if ma and not context.scene.render.use_shading_nodes:
86                 manode = ma.active_node_material
87                 if manode:
88                     layout.label(text=iface_("Node %s") % manode.name, translate=False, icon_value=layout.icon(manode))
89                 elif ma.use_nodes:
90                     layout.label(text="Node <none>")
91         elif self.layout_type == 'GRID':
92             layout.alignment = 'CENTER'
93             layout.label(text="", icon_value=icon)
94
95
96 class MaterialButtonsPanel:
97     bl_space_type = 'PROPERTIES'
98     bl_region_type = 'WINDOW'
99     bl_context = "material"
100     # COMPAT_ENGINES must be defined in each subclass, external engines can add themselves here
101
102     @classmethod
103     def poll(cls, context):
104         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
105
106
107 class MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
108     bl_label = ""
109     bl_options = {'HIDE_HEADER'}
110     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
111
112     @classmethod
113     def poll(cls, context):
114         # An exception, don't call the parent poll func because
115         # this manages materials for all engine types
116
117         engine = context.scene.render.engine
118         return (context.material or context.object) and (engine in cls.COMPAT_ENGINES)
119
120     def draw(self, context):
121         layout = self.layout
122
123         mat = context.material
124         ob = context.object
125         slot = context.material_slot
126         space = context.space_data
127
128         if ob:
129             is_sortable = (len(ob.material_slots) > 1)
130
131             rows = 1
132             if is_sortable:
133                 rows = 4
134
135             row = layout.row()
136
137             row.template_list("MATERIAL_UL_matslots", "", ob, "material_slots", ob, "active_material_index", rows=rows)
138
139             col = row.column(align=True)
140             col.operator("object.material_slot_add", icon='ZOOMIN', text="")
141             col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
142
143             col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
144
145             if is_sortable:
146                 col.separator()
147
148                 col.operator("object.material_slot_move", icon='TRIA_UP', text="").direction = 'UP'
149                 col.operator("object.material_slot_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
150
151             if ob.mode == 'EDIT':
152                 row = layout.row(align=True)
153                 row.operator("object.material_slot_assign", text="Assign")
154                 row.operator("object.material_slot_select", text="Select")
155                 row.operator("object.material_slot_deselect", text="Deselect")
156
157         split = layout.split(percentage=0.65)
158
159         if ob:
160             split.template_ID(ob, "active_material", new="material.new")
161             row = split.row()
162             if mat:
163                 row.prop(mat, "use_nodes", icon='NODETREE', text="")
164
165             if slot:
166                 row.prop(slot, "link", text="")
167             else:
168                 row.label()
169         elif mat:
170             split.template_ID(space, "pin_id")
171             split.separator()
172
173         if mat:
174             layout.row().prop(mat, "type", expand=True)
175             if mat.use_nodes:
176                 row = layout.row()
177                 row.label(text="", icon='NODETREE')
178                 if mat.active_node_material:
179                     row.prop(mat.active_node_material, "name", text="")
180                 else:
181                     row.label(text="No material node selected")
182
183
184 class MATERIAL_PT_preview(MaterialButtonsPanel, Panel):
185     bl_label = "Preview"
186     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
187
188     def draw(self, context):
189         self.layout.template_preview(context.material)
190
191
192 class MATERIAL_PT_pipeline(MaterialButtonsPanel, Panel):
193     bl_label = "Render Pipeline Options"
194     bl_options = {'DEFAULT_CLOSED'}
195     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
196
197     @classmethod
198     def poll(cls, context):
199         mat = context.material
200         engine = context.scene.render.engine
201         return mat and (not simple_material(mat)) and (mat.type in {'SURFACE', 'WIRE', 'VOLUME'}) and (engine in cls.COMPAT_ENGINES)
202
203     def draw(self, context):
204         layout = self. layout
205
206         mat = context.material
207         mat_type = mat.type in {'SURFACE', 'WIRE'}
208
209         row = layout.row()
210         row.active = mat_type
211         row.prop(mat, "use_transparency")
212         sub = row.column()
213         sub.prop(mat, "offset_z")
214
215         sub.active = mat_type and mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
216
217         row = layout.row()
218         row.active = mat.use_transparency or not mat_type
219         row.prop(mat, "transparency_method", expand=True)
220
221         layout.separator()
222
223         split = layout.split()
224         col = split.column()
225
226         col.prop(mat, "use_raytrace")
227         col.prop(mat, "use_full_oversampling")
228         sub = col.column()
229         sub.active = mat_type
230         sub.prop(mat, "use_sky")
231         sub.prop(mat, "invert_z")
232         col.prop(mat, "pass_index")
233
234         col = split.column()
235         col.active = mat_type
236
237         col.prop(mat, "use_cast_shadows", text="Cast")
238         col.prop(mat, "use_cast_shadows_only", text="Cast Only")
239         col.prop(mat, "use_cast_buffer_shadows")
240         sub = col.column()
241         sub.active = mat.use_cast_buffer_shadows
242         sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
243         col.prop(mat, "use_cast_approximate")
244
245
246 class MATERIAL_PT_diffuse(MaterialButtonsPanel, Panel):
247     bl_label = "Diffuse"
248     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
249
250     @classmethod
251     def poll(cls, context):
252         mat = context.material
253         engine = context.scene.render.engine
254         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
255
256     def draw(self, context):
257         layout = self.layout
258
259         mat = active_node_mat(context.material)
260
261         split = layout.split()
262
263         col = split.column()
264         col.prop(mat, "diffuse_color", text="")
265         sub = col.column()
266         sub.active = (not mat.use_shadeless)
267         sub.prop(mat, "diffuse_intensity", text="Intensity")
268
269         col = split.column()
270         col.active = (not mat.use_shadeless)
271         col.prop(mat, "diffuse_shader", text="")
272         col.prop(mat, "use_diffuse_ramp", text="Ramp")
273
274         col = layout.column()
275         col.active = (not mat.use_shadeless)
276         if mat.diffuse_shader == 'OREN_NAYAR':
277             col.prop(mat, "roughness")
278         elif mat.diffuse_shader == 'MINNAERT':
279             col.prop(mat, "darkness")
280         elif mat.diffuse_shader == 'TOON':
281             row = col.row()
282             row.prop(mat, "diffuse_toon_size", text="Size")
283             row.prop(mat, "diffuse_toon_smooth", text="Smooth")
284         elif mat.diffuse_shader == 'FRESNEL':
285             row = col.row()
286             row.prop(mat, "diffuse_fresnel", text="Fresnel")
287             row.prop(mat, "diffuse_fresnel_factor", text="Factor")
288
289         if mat.use_diffuse_ramp:
290             col = layout.column()
291             col.active = (not mat.use_shadeless)
292             col.separator()
293             col.template_color_ramp(mat, "diffuse_ramp", expand=True)
294             col.separator()
295
296             row = col.row()
297             row.prop(mat, "diffuse_ramp_input", text="Input")
298             row.prop(mat, "diffuse_ramp_blend", text="Blend")
299
300             col.prop(mat, "diffuse_ramp_factor", text="Factor")
301
302
303 class MATERIAL_PT_specular(MaterialButtonsPanel, Panel):
304     bl_label = "Specular"
305     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
306
307     @classmethod
308     def poll(cls, context):
309         mat = context.material
310         engine = context.scene.render.engine
311         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
312
313     def draw(self, context):
314         layout = self.layout
315
316         mat = active_node_mat(context.material)
317
318         layout.active = (not mat.use_shadeless)
319
320         split = layout.split()
321
322         col = split.column()
323         col.prop(mat, "specular_color", text="")
324         col.prop(mat, "specular_intensity", text="Intensity")
325
326         col = split.column()
327         col.prop(mat, "specular_shader", text="")
328         col.prop(mat, "use_specular_ramp", text="Ramp")
329
330         col = layout.column()
331         if mat.specular_shader in {'COOKTORR', 'PHONG'}:
332             col.prop(mat, "specular_hardness", text="Hardness")
333         elif mat.specular_shader == 'BLINN':
334             row = col.row()
335             row.prop(mat, "specular_hardness", text="Hardness")
336             row.prop(mat, "specular_ior", text="IOR")
337         elif mat.specular_shader == 'WARDISO':
338             col.prop(mat, "specular_slope", text="Slope")
339         elif mat.specular_shader == 'TOON':
340             row = col.row()
341             row.prop(mat, "specular_toon_size", text="Size")
342             row.prop(mat, "specular_toon_smooth", text="Smooth")
343
344         if mat.use_specular_ramp:
345             layout.separator()
346             layout.template_color_ramp(mat, "specular_ramp", expand=True)
347             layout.separator()
348
349             row = layout.row()
350             row.prop(mat, "specular_ramp_input", text="Input")
351             row.prop(mat, "specular_ramp_blend", text="Blend")
352
353             layout.prop(mat, "specular_ramp_factor", text="Factor")
354
355
356 class MATERIAL_PT_shading(MaterialButtonsPanel, Panel):
357     bl_label = "Shading"
358     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
359
360     @classmethod
361     def poll(cls, context):
362         mat = context.material
363         engine = context.scene.render.engine
364         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
365
366     def draw(self, context):
367         layout = self.layout
368
369         mat = active_node_mat(context.material)
370
371         if mat.type in {'SURFACE', 'WIRE'}:
372             split = layout.split()
373
374             col = split.column()
375             sub = col.column()
376             sub.active = not mat.use_shadeless
377             sub.prop(mat, "emit")
378             sub.prop(mat, "ambient")
379             sub = col.column()
380             sub.prop(mat, "translucency")
381
382             col = split.column()
383             col.prop(mat, "use_shadeless")
384             sub = col.column()
385             sub.active = not mat.use_shadeless
386             sub.prop(mat, "use_tangent_shading")
387             sub.prop(mat, "use_cubic")
388
389
390 class MATERIAL_PT_transp(MaterialButtonsPanel, Panel):
391     bl_label = "Transparency"
392     COMPAT_ENGINES = {'BLENDER_RENDER'}
393
394     @classmethod
395     def poll(cls, context):
396         mat = context.material
397         engine = context.scene.render.engine
398         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
399
400     def draw_header(self, context):
401         mat = context.material
402
403         if simple_material(mat):
404             self.layout.prop(mat, "use_transparency", text="")
405
406     def draw(self, context):
407         layout = self.layout
408
409         base_mat = context.material
410         mat = active_node_mat(context.material)
411         rayt = mat.raytrace_transparency
412
413         if simple_material(base_mat):
414             row = layout.row()
415             row.active = mat.use_transparency
416             row.prop(mat, "transparency_method", expand=True)
417
418         split = layout.split()
419         split.active = base_mat.use_transparency
420
421         col = split.column()
422         col.prop(mat, "alpha")
423         row = col.row()
424         row.active = (base_mat.transparency_method != 'MASK') and (not mat.use_shadeless)
425         row.prop(mat, "specular_alpha", text="Specular")
426
427         col = split.column()
428         col.active = (not mat.use_shadeless)
429         col.prop(rayt, "fresnel")
430         sub = col.column()
431         sub.active = (rayt.fresnel > 0.0)
432         sub.prop(rayt, "fresnel_factor", text="Blend")
433
434         if base_mat.transparency_method == 'RAYTRACE':
435             layout.separator()
436             split = layout.split()
437             split.active = base_mat.use_transparency
438
439             col = split.column()
440             col.prop(rayt, "ior")
441             col.prop(rayt, "filter")
442             col.prop(rayt, "falloff")
443             col.prop(rayt, "depth_max")
444             col.prop(rayt, "depth")
445
446             col = split.column()
447             col.label(text="Gloss:")
448             col.prop(rayt, "gloss_factor", text="Amount")
449             sub = col.column()
450             sub.active = rayt.gloss_factor < 1.0
451             sub.prop(rayt, "gloss_threshold", text="Threshold")
452             sub.prop(rayt, "gloss_samples", text="Samples")
453
454
455 class MATERIAL_PT_mirror(MaterialButtonsPanel, Panel):
456     bl_label = "Mirror"
457     bl_options = {'DEFAULT_CLOSED'}
458     COMPAT_ENGINES = {'BLENDER_RENDER'}
459
460     @classmethod
461     def poll(cls, context):
462         mat = context.material
463         engine = context.scene.render.engine
464         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
465
466     def draw_header(self, context):
467         raym = active_node_mat(context.material).raytrace_mirror
468
469         self.layout.prop(raym, "use", text="")
470
471     def draw(self, context):
472         layout = self.layout
473
474         mat = active_node_mat(context.material)
475         raym = mat.raytrace_mirror
476
477         layout.active = raym.use
478
479         split = layout.split()
480
481         col = split.column()
482         col.prop(raym, "reflect_factor")
483         col.prop(mat, "mirror_color", text="")
484
485         col = split.column()
486         col.prop(raym, "fresnel")
487         sub = col.column()
488         sub.active = (raym.fresnel > 0.0)
489         sub.prop(raym, "fresnel_factor", text="Blend")
490
491         split = layout.split()
492
493         col = split.column()
494         col.separator()
495         col.prop(raym, "depth")
496         col.prop(raym, "distance", text="Max Dist")
497         col.separator()
498         sub = col.split(percentage=0.4)
499         sub.active = (raym.distance > 0.0)
500         sub.label(text="Fade To:")
501         sub.prop(raym, "fade_to", text="")
502
503         col = split.column()
504         col.label(text="Gloss:")
505         col.prop(raym, "gloss_factor", text="Amount")
506         sub = col.column()
507         sub.active = (raym.gloss_factor < 1.0)
508         sub.prop(raym, "gloss_threshold", text="Threshold")
509         sub.prop(raym, "gloss_samples", text="Samples")
510         sub.prop(raym, "gloss_anisotropic", text="Anisotropic")
511
512
513 class MATERIAL_PT_sss(MaterialButtonsPanel, Panel):
514     bl_label = "Subsurface Scattering"
515     bl_options = {'DEFAULT_CLOSED'}
516     COMPAT_ENGINES = {'BLENDER_RENDER'}
517
518     @classmethod
519     def poll(cls, context):
520         mat = context.material
521         engine = context.scene.render.engine
522         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
523
524     def draw_header(self, context):
525         mat = active_node_mat(context.material)
526         sss = mat.subsurface_scattering
527
528         self.layout.active = (not mat.use_shadeless)
529         self.layout.prop(sss, "use", text="")
530
531     def draw(self, context):
532         layout = self.layout
533
534         mat = active_node_mat(context.material)
535         sss = mat.subsurface_scattering
536
537         layout.active = (sss.use) and (not mat.use_shadeless)
538
539         row = layout.row().split()
540         sub = row.row(align=True).split(align=True, percentage=0.75)
541         sub.menu("MATERIAL_MT_sss_presets", text=bpy.types.MATERIAL_MT_sss_presets.bl_label)
542         sub.operator("material.sss_preset_add", text="", icon='ZOOMIN')
543         sub.operator("material.sss_preset_add", text="", icon='ZOOMOUT').remove_active = True
544
545         split = layout.split()
546
547         col = split.column()
548         col.prop(sss, "ior")
549         col.prop(sss, "scale")
550         col.prop(sss, "color", text="")
551         col.prop(sss, "radius", text="RGB Radius", expand=True)
552
553         col = split.column()
554         sub = col.column(align=True)
555         sub.label(text="Blend:")
556         sub.prop(sss, "color_factor", text="Color")
557         sub.prop(sss, "texture_factor", text="Texture")
558         sub.label(text="Scattering Weight:")
559         sub.prop(sss, "front")
560         sub.prop(sss, "back")
561         col.separator()
562         col.prop(sss, "error_threshold", text="Error")
563
564
565 class MATERIAL_PT_halo(MaterialButtonsPanel, Panel):
566     bl_label = "Halo"
567     COMPAT_ENGINES = {'BLENDER_RENDER'}
568
569     @classmethod
570     def poll(cls, context):
571         mat = context.material
572         engine = context.scene.render.engine
573         return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES)
574
575     def draw(self, context):
576         layout = self.layout
577
578         mat = context.material  # don't use node material
579         halo = mat.halo
580
581         def number_but(layout, toggle, number, name, color):
582             row = layout.row(align=True)
583             row.prop(halo, toggle, text="")
584             sub = row.column(align=True)
585             sub.active = getattr(halo, toggle)
586             sub.prop(halo, number, text=name, translate=False)
587             if not color == "":
588                 sub.prop(mat, color, text="")
589
590         split = layout.split()
591
592         col = split.column()
593         col.prop(mat, "alpha")
594         col.prop(mat, "diffuse_color", text="")
595         col.prop(halo, "seed")
596
597         col = split.column()
598         col.prop(halo, "size")
599         col.prop(halo, "hardness")
600         col.prop(halo, "add")
601
602         layout.label(text="Options:")
603
604         split = layout.split()
605         col = split.column()
606         col.prop(halo, "use_texture")
607         col.prop(halo, "use_vertex_normal")
608         col.prop(halo, "use_extreme_alpha")
609         col.prop(halo, "use_shaded")
610         col.prop(halo, "use_soft")
611
612         col = split.column()
613         number_but(col, "use_ring", "ring_count", iface_("Rings"), "mirror_color")
614         number_but(col, "use_lines", "line_count", iface_("Lines"), "specular_color")
615         number_but(col, "use_star", "star_tip_count", iface_("Star Tips"), "")
616
617
618 class MATERIAL_PT_flare(MaterialButtonsPanel, Panel):
619     bl_label = "Flare"
620     COMPAT_ENGINES = {'BLENDER_RENDER'}
621
622     @classmethod
623     def poll(cls, context):
624         mat = context.material
625         engine = context.scene.render.engine
626         return mat and (mat.type == 'HALO') and (engine in cls.COMPAT_ENGINES)
627
628     def draw_header(self, context):
629         halo = context.material.halo
630
631         self.layout.prop(halo, "use_flare_mode", text="")
632
633     def draw(self, context):
634         layout = self.layout
635
636         mat = context.material  # don't use node material
637         halo = mat.halo
638
639         layout.active = halo.use_flare_mode
640
641         split = layout.split()
642
643         col = split.column()
644         col.prop(halo, "flare_size", text="Size")
645         col.prop(halo, "flare_boost", text="Boost")
646         col.prop(halo, "flare_seed", text="Seed")
647
648         col = split.column()
649         col.prop(halo, "flare_subflare_count", text="Subflares")
650         col.prop(halo, "flare_subflare_size", text="Subsize")
651
652
653 class MATERIAL_PT_game_settings(MaterialButtonsPanel, Panel):
654     bl_label = "Game Settings"
655     COMPAT_ENGINES = {'BLENDER_GAME'}
656
657     @classmethod
658     def poll(cls, context):
659         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
660
661     def draw(self, context):
662         layout = self.layout
663         game = context.material.game_settings  # don't use node material
664
665         row = layout.row()
666         row.prop(game, "use_backface_culling")
667         row.prop(game, "invisible")
668         row.prop(game, "text")
669
670         row = layout.row()
671         row.label(text="Alpha Blend:")
672         row.label(text="Face Orientation:")
673         row = layout.row()
674         row.prop(game, "alpha_blend", text="")
675         row.prop(game, "face_orientation", text="")
676
677
678 class MATERIAL_PT_physics(MaterialButtonsPanel, Panel):
679     bl_label = "Physics"
680     COMPAT_ENGINES = {'BLENDER_GAME'}
681
682     def draw_header(self, context):
683         game = context.material.game_settings
684         self.layout.prop(game, "physics", text="")
685
686     @classmethod
687     def poll(cls, context):
688         return context.material and (context.scene.render.engine in cls.COMPAT_ENGINES)
689
690     def draw(self, context):
691         layout = self.layout
692         layout.active = context.material.game_settings.physics
693
694         phys = context.material.physics  # don't use node material
695
696         split = layout.split()
697         row = split.row()
698         row.prop(phys, "friction")
699         row.prop(phys, "elasticity", slider=True)
700
701         row = layout.row()
702         row.label(text="Force Field:")
703
704         row = layout.row()
705         row.prop(phys, "fh_force")
706         row.prop(phys, "fh_damping", slider=True)
707
708         row = layout.row()
709         row.prop(phys, "fh_distance")
710         row.prop(phys, "use_fh_normal")
711
712
713 class MATERIAL_PT_strand(MaterialButtonsPanel, Panel):
714     bl_label = "Strand"
715     bl_options = {'DEFAULT_CLOSED'}
716     COMPAT_ENGINES = {'BLENDER_RENDER'}
717
718     @classmethod
719     def poll(cls, context):
720         mat = context.material
721         engine = context.scene.render.engine
722         return mat and (mat.type in {'SURFACE', 'WIRE', 'HALO'}) and (engine in cls.COMPAT_ENGINES)
723
724     def draw(self, context):
725         layout = self.layout
726
727         mat = context.material  # don't use node material
728         tan = mat.strand
729
730         split = layout.split()
731
732         col = split.column()
733         sub = col.column(align=True)
734         sub.label(text="Size:")
735         sub.prop(tan, "root_size", text="Root")
736         sub.prop(tan, "tip_size", text="Tip")
737         sub.prop(tan, "size_min", text="Minimum")
738         sub.prop(tan, "use_blender_units")
739         sub = col.column()
740         sub.active = (not mat.use_shadeless)
741         sub.prop(tan, "use_tangent_shading")
742         col.prop(tan, "shape")
743
744         col = split.column()
745         col.label(text="Shading:")
746         col.prop(tan, "width_fade")
747         ob = context.object
748         if ob and ob.type == 'MESH':
749             col.prop_search(tan, "uv_layer", ob.data, "uv_layers", text="")
750         else:
751             col.prop(tan, "uv_layer", text="")
752         col.separator()
753         sub = col.column()
754         sub.active = (not mat.use_shadeless)
755         sub.label("Surface diffuse:")
756         sub = col.column()
757         sub.prop(tan, "blend_distance", text="Distance")
758
759
760 class MATERIAL_PT_options(MaterialButtonsPanel, Panel):
761     bl_label = "Options"
762     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
763
764     @classmethod
765     def poll(cls, context):
766         mat = context.material
767         engine = context.scene.render.engine
768         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
769
770     def draw(self, context):
771         layout = self.layout
772
773         base_mat = context.material
774         mat = active_node_mat(base_mat)
775
776         split = layout.split()
777
778         col = split.column()
779         if simple_material(base_mat):
780             col.prop(mat, "use_raytrace")
781             col.prop(mat, "use_full_oversampling")
782             col.prop(mat, "use_sky")
783         col.prop(mat, "use_mist")
784         if simple_material(base_mat):
785             col.prop(mat, "invert_z")
786             sub = col.row()
787             sub.prop(mat, "offset_z")
788             sub.active = mat.use_transparency and mat.transparency_method == 'Z_TRANSPARENCY'
789         sub = col.column(align=True)
790         sub.label(text="Light Group:")
791         sub.prop(mat, "light_group", text="")
792         row = sub.row(align=True)
793         row.active = bool(mat.light_group)
794         row.prop(mat, "use_light_group_exclusive", text="Exclusive")
795         row.prop(mat, "use_light_group_local", text="Local")
796
797         col = split.column()
798         col.prop(mat, "use_vertex_color_paint")
799         col.prop(mat, "use_vertex_color_light")
800         col.prop(mat, "use_object_color")
801         col.prop(mat, "use_uv_project")
802         if simple_material(base_mat):
803             col.prop(mat, "pass_index")
804
805         col.label("Edit Image")
806         col.template_ID(mat, "edit_image")
807
808
809 class MATERIAL_PT_shadow(MaterialButtonsPanel, Panel):
810     bl_label = "Shadow"
811     bl_options = {'DEFAULT_CLOSED'}
812     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
813
814     @classmethod
815     def poll(cls, context):
816         mat = context.material
817         engine = context.scene.render.engine
818         return check_material(mat) and (mat.type in {'SURFACE', 'WIRE'}) and (engine in cls.COMPAT_ENGINES)
819
820     def draw(self, context):
821         layout = self.layout
822
823         base_mat = context.material
824         mat = active_node_mat(base_mat)
825
826         split = layout.split()
827
828         col = split.column()
829         col.prop(mat, "use_shadows", text="Receive")
830         col.prop(mat, "use_transparent_shadows", text="Receive Transparent")
831         col.prop(mat, "use_only_shadow", text="Shadows Only")
832         sub = col.column()
833         sub.active = mat.use_only_shadow
834         sub.prop(mat, "shadow_only_type", text="")
835
836         if not simple_material(base_mat):
837             col = split.column()
838
839         col.prop(mat, "use_ray_shadow_bias", text="Auto Ray Bias")
840         sub = col.column()
841         sub.active = (not mat.use_ray_shadow_bias)
842         sub.prop(mat, "shadow_ray_bias", text="Ray Bias")
843
844         if simple_material(base_mat):
845             col = split.column()
846
847             col.prop(mat, "use_cast_shadows", text="Cast")
848             col.prop(mat, "use_cast_shadows_only", text="Cast Only")
849             col.prop(mat, "use_cast_buffer_shadows")
850         sub = col.column()
851         sub.active = mat.use_cast_buffer_shadows
852         if simple_material(base_mat):
853             sub.prop(mat, "shadow_cast_alpha", text="Casting Alpha")
854         sub.prop(mat, "shadow_buffer_bias", text="Buffer Bias")
855         if simple_material(base_mat):
856             col.prop(mat, "use_cast_approximate")
857
858
859 class MATERIAL_PT_transp_game(MaterialButtonsPanel, Panel):
860     bl_label = "Transparency"
861     bl_options = {'DEFAULT_CLOSED'}
862     COMPAT_ENGINES = {'BLENDER_GAME'}
863
864     @classmethod
865     def poll(cls, context):
866         mat = context.material
867         engine = context.scene.render.engine
868         return check_material(mat) and (engine in cls.COMPAT_ENGINES)
869
870     def draw_header(self, context):
871         mat = context.material
872
873         if simple_material(mat):
874             self.layout.prop(mat, "use_transparency", text="")
875
876     def draw(self, context):
877         layout = self.layout
878         base_mat = context.material
879         mat = active_node_mat(base_mat)
880
881         layout.active = mat.use_transparency
882
883         if simple_material(base_mat):
884             row = layout.row()
885             row.prop(mat, "transparency_method", expand=True)
886
887         layout.prop(mat, "alpha")
888         layout.prop(mat, "specular_alpha", text="Specular")
889
890
891 class VolumeButtonsPanel:
892     bl_space_type = 'PROPERTIES'
893     bl_region_type = 'WINDOW'
894     bl_context = "material"
895     COMPAT_ENGINES = {'BLENDER_RENDER'}
896
897     @classmethod
898     def poll(cls, context):
899         mat = context.material
900         engine = context.scene.render.engine
901         return mat and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
902
903
904 class MATERIAL_PT_volume_density(VolumeButtonsPanel, Panel):
905     bl_label = "Density"
906     COMPAT_ENGINES = {'BLENDER_RENDER'}
907
908     def draw(self, context):
909         layout = self.layout
910
911         vol = context.material.volume  # don't use node material
912
913         row = layout.row()
914         row.prop(vol, "density")
915         row.prop(vol, "density_scale")
916
917
918 class MATERIAL_PT_volume_shading(VolumeButtonsPanel, Panel):
919     bl_label = "Shading"
920     COMPAT_ENGINES = {'BLENDER_RENDER'}
921
922     def draw(self, context):
923         layout = self.layout
924
925         vol = context.material.volume  # don't use node material
926
927         split = layout.split()
928
929         col = split.column()
930         col.prop(vol, "scattering")
931         col.prop(vol, "asymmetry")
932         col.prop(vol, "transmission_color")
933
934         col = split.column()
935         sub = col.column(align=True)
936         sub.prop(vol, "emission")
937         sub.prop(vol, "emission_color", text="")
938         sub = col.column(align=True)
939         sub.prop(vol, "reflection")
940         sub.prop(vol, "reflection_color", text="")
941
942
943 class MATERIAL_PT_volume_lighting(VolumeButtonsPanel, Panel):
944     bl_label = "Lighting"
945     COMPAT_ENGINES = {'BLENDER_RENDER'}
946
947     def draw(self, context):
948         layout = self.layout
949
950         vol = context.material.volume  # don't use node material
951
952         split = layout.split()
953
954         col = split.column()
955         col.prop(vol, "light_method", text="")
956
957         col = split.column()
958
959         if vol.light_method == 'SHADED':
960             col.prop(vol, "use_external_shadows")
961             col.prop(vol, "use_light_cache")
962             sub = col.column()
963             sub.active = vol.use_light_cache
964             sub.prop(vol, "cache_resolution")
965         elif vol.light_method in {'MULTIPLE_SCATTERING', 'SHADED_PLUS_MULTIPLE_SCATTERING'}:
966             sub = col.column()
967             sub.enabled = True
968             sub.active = False
969             sub.label("Light Cache Enabled")
970             col.prop(vol, "cache_resolution")
971
972             sub = col.column(align=True)
973             sub.prop(vol, "ms_diffusion")
974             sub.prop(vol, "ms_spread")
975             sub.prop(vol, "ms_intensity")
976
977
978 class MATERIAL_PT_volume_transp(VolumeButtonsPanel, Panel):
979     bl_label = "Transparency"
980     COMPAT_ENGINES = {'BLENDER_RENDER'}
981
982     @classmethod
983     def poll(cls, context):
984         mat = context.material
985         engine = context.scene.render.engine
986         return mat and simple_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
987
988     def draw(self, context):
989         layout = self.layout
990
991         mat = context.material  # don't use node material
992
993         layout.row().prop(mat, "transparency_method", expand=True)
994
995
996 class MATERIAL_PT_volume_integration(VolumeButtonsPanel, Panel):
997     bl_label = "Integration"
998     COMPAT_ENGINES = {'BLENDER_RENDER'}
999
1000     def draw(self, context):
1001         layout = self.layout
1002
1003         vol = context.material.volume  # don't use node material
1004
1005         split = layout.split()
1006
1007         col = split.column()
1008         col.label(text="Step Calculation:")
1009         col.prop(vol, "step_method", text="")
1010         col = col.column(align=True)
1011         col.prop(vol, "step_size")
1012
1013         col = split.column()
1014         col.label()
1015         col.prop(vol, "depth_threshold")
1016
1017
1018 class MATERIAL_PT_volume_options(VolumeButtonsPanel, Panel):
1019     bl_label = "Options"
1020     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1021     bl_options = {'DEFAULT_CLOSED'}
1022
1023     @classmethod
1024     def poll(cls, context):
1025         mat = context.material
1026         engine = context.scene.render.engine
1027         return check_material(mat) and (mat.type == 'VOLUME') and (engine in cls.COMPAT_ENGINES)
1028
1029     def draw(self, context):
1030         layout = self.layout
1031
1032         mat = active_node_mat(context.material)
1033
1034         split = layout.split()
1035
1036         col = split.column()
1037         if simple_material(context.material):
1038             col.prop(mat, "use_raytrace")
1039             col.prop(mat, "use_full_oversampling")
1040         col.prop(mat, "use_mist")
1041
1042         col = split.column()
1043         col.label(text="Light Group:")
1044         col.prop(mat, "light_group", text="")
1045         row = col.row()
1046         row.active = bool(mat.light_group)
1047         row.prop(mat, "use_light_group_exclusive", text="Exclusive")
1048
1049
1050 class MATERIAL_PT_custom_props(MaterialButtonsPanel, PropertyPanel, Panel):
1051     COMPAT_ENGINES = {'BLENDER_RENDER', 'BLENDER_GAME'}
1052     _context_path = "material"
1053     _property_type = bpy.types.Material
1054
1055
1056 class EEVEE_MATERIAL_PT_context_material(MaterialButtonsPanel, Panel):
1057     bl_label = ""
1058     bl_context = "material"
1059     bl_options = {'HIDE_HEADER'}
1060     COMPAT_ENGINES = {'BLENDER_EEVEE'}
1061
1062     @classmethod
1063     def poll(cls, context):
1064         engine = context.scene.render.engine
1065         return (context.material or context.object) and (engine in cls.COMPAT_ENGINES)
1066
1067     def draw(self, context):
1068         layout = self.layout
1069
1070         mat = context.material
1071         ob = context.object
1072         slot = context.material_slot
1073         space = context.space_data
1074
1075         if ob:
1076             is_sortable = len(ob.material_slots) > 1
1077             rows = 1
1078             if (is_sortable):
1079                 rows = 4
1080
1081             row = layout.row()
1082
1083             row.template_list("MATERIAL_UL_matslots", "", ob, "material_slots", ob, "active_material_index", rows=rows)
1084
1085             col = row.column(align=True)
1086             col.operator("object.material_slot_add", icon='ZOOMIN', text="")
1087             col.operator("object.material_slot_remove", icon='ZOOMOUT', text="")
1088
1089             col.menu("MATERIAL_MT_specials", icon='DOWNARROW_HLT', text="")
1090
1091             if is_sortable:
1092                 col.separator()
1093
1094                 col.operator("object.material_slot_move", icon='TRIA_UP', text="").direction = 'UP'
1095                 col.operator("object.material_slot_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
1096
1097             if ob.mode == 'EDIT':
1098                 row = layout.row(align=True)
1099                 row.operator("object.material_slot_assign", text="Assign")
1100                 row.operator("object.material_slot_select", text="Select")
1101                 row.operator("object.material_slot_deselect", text="Deselect")
1102
1103         split = layout.split(percentage=0.65)
1104
1105         if ob:
1106             split.template_ID(ob, "active_material", new="material.new")
1107             row = split.row()
1108
1109             if slot:
1110                 row.prop(slot, "link", text="")
1111             else:
1112                 row.label()
1113         elif mat:
1114             split.template_ID(space, "pin_id")
1115             split.separator()
1116
1117
1118 def panel_node_draw(layout, ntree, output_type):
1119     node = find_output_node(ntree, output_type)
1120
1121     if node:
1122         input = find_node_input(node, 'Surface')
1123         if input:
1124             layout.template_node_view(ntree, node, input)
1125         else:
1126             layout.label(text="Incompatible output node")
1127     else:
1128         layout.label(text="No output node")
1129
1130
1131 class EEVEE_MATERIAL_PT_surface(MaterialButtonsPanel, Panel):
1132     bl_label = "Surface"
1133     bl_context = "material"
1134     COMPAT_ENGINES = {'BLENDER_EEVEE'}
1135
1136     @classmethod
1137     def poll(cls, context):
1138         engine = context.scene.render.engine
1139         return context.material and (engine in cls.COMPAT_ENGINES)
1140
1141     def draw(self, context):
1142         layout = self.layout
1143
1144         mat = context.material
1145
1146         layout.prop(mat, "use_nodes", icon='NODETREE')
1147         layout.separator()
1148
1149         if mat.use_nodes:
1150             panel_node_draw(layout, mat.node_tree, ['OUTPUT_EEVEE_MATERIAL', 'OUTPUT_MATERIAL'])
1151         else:
1152             raym = mat.raytrace_mirror
1153             layout.prop(mat, "diffuse_color", text="Base Color")
1154             layout.prop(raym, "reflect_factor", text="Metallic")
1155             layout.prop(mat, "specular_intensity", text="Specular")
1156             layout.prop(raym, "gloss_factor", text="Roughness")
1157
1158
1159 class EEVEE_MATERIAL_PT_options(MaterialButtonsPanel, Panel):
1160     bl_label = "Options"
1161     bl_context = "material"
1162     COMPAT_ENGINES = {'BLENDER_EEVEE'}
1163
1164     @classmethod
1165     def poll(cls, context):
1166         engine = context.scene.render.engine
1167         return context.material and (engine in cls.COMPAT_ENGINES)
1168
1169     def draw(self, context):
1170         layout = self.layout
1171
1172         mat = context.material
1173
1174         layout.prop(mat, "blend_method")
1175
1176         if mat.blend_method != "OPAQUE":
1177             layout.prop(mat, "transparent_shadow_method")
1178
1179             row = layout.row()
1180             row.active = ((mat.blend_method == "CLIP") or (mat.transparent_shadow_method == "CLIP"))
1181             layout.prop(mat, "alpha_threshold")
1182
1183         if mat.blend_method not in {"OPAQUE", "CLIP", "HASHED"}:
1184             layout.prop(mat, "transparent_hide_backside")
1185
1186
1187
1188 classes = (
1189     MATERIAL_MT_sss_presets,
1190     MATERIAL_MT_specials,
1191     MATERIAL_UL_matslots,
1192     MATERIAL_PT_context_material,
1193     MATERIAL_PT_preview,
1194     MATERIAL_PT_pipeline,
1195     MATERIAL_PT_diffuse,
1196     MATERIAL_PT_specular,
1197     MATERIAL_PT_shading,
1198     MATERIAL_PT_transp,
1199     MATERIAL_PT_mirror,
1200     MATERIAL_PT_sss,
1201     MATERIAL_PT_halo,
1202     MATERIAL_PT_flare,
1203     MATERIAL_PT_game_settings,
1204     MATERIAL_PT_physics,
1205     MATERIAL_PT_strand,
1206     MATERIAL_PT_options,
1207     MATERIAL_PT_shadow,
1208     MATERIAL_PT_transp_game,
1209     MATERIAL_PT_volume_density,
1210     MATERIAL_PT_volume_shading,
1211     MATERIAL_PT_volume_lighting,
1212     MATERIAL_PT_volume_transp,
1213     MATERIAL_PT_volume_integration,
1214     MATERIAL_PT_volume_options,
1215     MATERIAL_PT_custom_props,
1216     EEVEE_MATERIAL_PT_context_material,
1217     EEVEE_MATERIAL_PT_surface,
1218     EEVEE_MATERIAL_PT_options,
1219 )
1220
1221 if __name__ == "__main__":  # only for live edit.
1222     from bpy.utils import register_class
1223     for cls in classes:
1224         register_class(cls)