Cycles: add Principled Volume shader.
[blender.git] / release / scripts / startup / bl_operators / object_quick_effects.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-80 compliant>
20
21 from mathutils import Vector
22 import bpy
23 from bpy.types import Operator
24 from bpy.props import (
25     BoolProperty,
26     EnumProperty,
27     FloatProperty,
28     FloatVectorProperty,
29     IntProperty,
30 )
31
32
33 def object_ensure_material(obj, mat_name):
34     """ Use an existing material or add a new one.
35     """
36     mat = mat_slot = None
37     for mat_slot in obj.material_slots:
38         mat = mat_slot.material
39         if mat:
40             break
41     if mat is None:
42         mat = bpy.data.materials.new(mat_name)
43         if mat_slot:
44             mat_slot.material = mat
45         else:
46             obj.data.materials.append(mat)
47     return mat
48
49
50 class QuickFur(Operator):
51     bl_idname = "object.quick_fur"
52     bl_label = "Quick Fur"
53     bl_options = {'REGISTER', 'UNDO'}
54
55     density = EnumProperty(
56             name="Fur Density",
57             items=(('LIGHT', "Light", ""),
58                    ('MEDIUM', "Medium", ""),
59                    ('HEAVY', "Heavy", "")),
60             default='MEDIUM',
61             )
62     view_percentage = IntProperty(
63             name="View %",
64             min=1, max=100,
65             soft_min=1, soft_max=100,
66             default=10,
67             )
68     length = FloatProperty(
69             name="Length",
70             min=0.001, max=100,
71             soft_min=0.01, soft_max=10,
72             default=0.1,
73             )
74
75     def execute(self, context):
76         fake_context = context.copy()
77         mesh_objects = [obj for obj in context.selected_objects
78                         if obj.type == 'MESH' and obj.mode == 'OBJECT']
79
80         if not mesh_objects:
81             self.report({'ERROR'}, "Select at least one mesh object")
82             return {'CANCELLED'}
83
84         mat = bpy.data.materials.new("Fur Material")
85         mat.strand.tip_size = 0.25
86         mat.strand.blend_distance = 0.5
87
88         for obj in mesh_objects:
89             fake_context["object"] = obj
90             bpy.ops.object.particle_system_add(fake_context)
91
92             psys = obj.particle_systems[-1]
93             psys.settings.type = 'HAIR'
94
95             if self.density == 'LIGHT':
96                 psys.settings.count = 100
97             elif self.density == 'MEDIUM':
98                 psys.settings.count = 1000
99             elif self.density == 'HEAVY':
100                 psys.settings.count = 10000
101
102             psys.settings.child_nbr = self.view_percentage
103             psys.settings.hair_length = self.length
104             psys.settings.use_strand_primitive = True
105             psys.settings.use_hair_bspline = True
106             psys.settings.child_type = 'INTERPOLATED'
107
108             obj.data.materials.append(mat)
109             psys.settings.material = len(obj.data.materials)
110
111         return {'FINISHED'}
112
113
114 class QuickExplode(Operator):
115     bl_idname = "object.quick_explode"
116     bl_label = "Quick Explode"
117     bl_options = {'REGISTER', 'UNDO'}
118
119     style = EnumProperty(
120             name="Explode Style",
121             items=(('EXPLODE', "Explode", ""),
122                    ('BLEND', "Blend", "")),
123             default='EXPLODE',
124             )
125     amount = IntProperty(
126             name="Amount of pieces",
127             min=2, max=10000,
128             soft_min=2, soft_max=10000,
129             default=100,
130             )
131     frame_duration = IntProperty(
132             name="Duration",
133             min=1, max=300000,
134             soft_min=1, soft_max=10000,
135             default=50,
136             )
137
138     frame_start = IntProperty(
139             name="Start Frame",
140             min=1, max=300000,
141             soft_min=1, soft_max=10000,
142             default=1,
143             )
144     frame_end = IntProperty(
145             name="End Frame",
146             min=1, max=300000,
147             soft_min=1, soft_max=10000,
148             default=10,
149             )
150
151     velocity = FloatProperty(
152             name="Outwards Velocity",
153             min=0, max=300000,
154             soft_min=0, soft_max=10,
155             default=1,
156             )
157
158     fade = BoolProperty(
159             name="Fade",
160             description="Fade the pieces over time",
161             default=True,
162             )
163
164     def execute(self, context):
165         fake_context = context.copy()
166         obj_act = context.active_object
167
168         if obj_act is None or obj_act.type != 'MESH':
169             self.report({'ERROR'}, "Active object is not a mesh")
170             return {'CANCELLED'}
171
172         mesh_objects = [obj for obj in context.selected_objects
173                         if obj.type == 'MESH' and obj != obj_act]
174         mesh_objects.insert(0, obj_act)
175
176         if self.style == 'BLEND' and len(mesh_objects) != 2:
177             self.report({'ERROR'}, "Select two mesh objects")
178             self.style = 'EXPLODE'
179             return {'CANCELLED'}
180         elif not mesh_objects:
181             self.report({'ERROR'}, "Select at least one mesh object")
182             return {'CANCELLED'}
183
184         for obj in mesh_objects:
185             if obj.particle_systems:
186                 self.report({'ERROR'},
187                             "Object %r already has a "
188                             "particle system" % obj.name)
189
190                 return {'CANCELLED'}
191
192         if self.fade:
193             tex = bpy.data.textures.new("Explode fade", 'BLEND')
194             tex.use_color_ramp = True
195
196             if self.style == 'BLEND':
197                 tex.color_ramp.elements[0].position = 0.333
198                 tex.color_ramp.elements[1].position = 0.666
199
200             tex.color_ramp.elements[0].color[3] = 1.0
201             tex.color_ramp.elements[1].color[3] = 0.0
202
203         if self.style == 'BLEND':
204             from_obj = mesh_objects[1]
205             to_obj = mesh_objects[0]
206
207         for obj in mesh_objects:
208             fake_context["object"] = obj
209             bpy.ops.object.particle_system_add(fake_context)
210
211             settings = obj.particle_systems[-1].settings
212             settings.count = self.amount
213             # first set frame end, to prevent frame start clamping
214             settings.frame_end = self.frame_end - self.frame_duration
215             settings.frame_start = self.frame_start
216             settings.lifetime = self.frame_duration
217             settings.normal_factor = self.velocity
218             settings.render_type = 'NONE'
219
220             explode = obj.modifiers.new(name='Explode', type='EXPLODE')
221             explode.use_edge_cut = True
222
223             if self.fade:
224                 explode.show_dead = False
225                 uv = obj.data.uv_textures.new("Explode fade")
226                 explode.particle_uv = uv.name
227
228                 mat = object_ensure_material(obj, "Explode Fade")
229
230                 mat.use_transparency = True
231                 mat.use_transparent_shadows = True
232                 mat.alpha = 0.0
233                 mat.specular_alpha = 0.0
234
235                 tex_slot = mat.texture_slots.add()
236
237                 tex_slot.texture = tex
238                 tex_slot.texture_coords = 'UV'
239                 tex_slot.uv_layer = uv.name
240
241                 tex_slot.use_map_alpha = True
242
243                 if self.style == 'BLEND':
244                     if obj == to_obj:
245                         tex_slot.alpha_factor = -1.0
246                         elem = tex.color_ramp.elements[1]
247                     else:
248                         elem = tex.color_ramp.elements[0]
249                     # Keep already defined alpha!
250                     elem.color[:3] = mat.diffuse_color
251                 else:
252                     tex_slot.use_map_color_diffuse = False
253
254             if self.style == 'BLEND':
255                 settings.physics_type = 'KEYED'
256                 settings.use_emit_random = False
257                 settings.rotation_mode = 'NOR'
258
259                 psys = obj.particle_systems[-1]
260
261                 fake_context["particle_system"] = obj.particle_systems[-1]
262                 bpy.ops.particle.new_target(fake_context)
263                 bpy.ops.particle.new_target(fake_context)
264
265                 if obj == from_obj:
266                     psys.targets[1].object = to_obj
267                 else:
268                     psys.targets[0].object = from_obj
269                     settings.normal_factor = -self.velocity
270                     explode.show_unborn = False
271                     explode.show_dead = True
272             else:
273                 settings.factor_random = self.velocity
274                 settings.angular_velocity_factor = self.velocity / 10.0
275
276         return {'FINISHED'}
277
278     def invoke(self, context, event):
279         self.frame_start = context.scene.frame_current
280         self.frame_end = self.frame_start + self.frame_duration
281         return self.execute(context)
282
283
284 def obj_bb_minmax(obj, min_co, max_co):
285     for i in range(0, 8):
286         bb_vec = obj.matrix_world * Vector(obj.bound_box[i])
287
288         min_co[0] = min(bb_vec[0], min_co[0])
289         min_co[1] = min(bb_vec[1], min_co[1])
290         min_co[2] = min(bb_vec[2], min_co[2])
291         max_co[0] = max(bb_vec[0], max_co[0])
292         max_co[1] = max(bb_vec[1], max_co[1])
293         max_co[2] = max(bb_vec[2], max_co[2])
294
295
296 def grid_location(x, y):
297     return (x * 200, y * 150)
298
299
300 class QuickSmoke(Operator):
301     bl_idname = "object.quick_smoke"
302     bl_label = "Quick Smoke"
303     bl_options = {'REGISTER', 'UNDO'}
304
305     style = EnumProperty(
306             name="Smoke Style",
307             items=(('SMOKE', "Smoke", ""),
308                    ('FIRE', "Fire", ""),
309                    ('BOTH', "Smoke + Fire", ""),
310                    ),
311             default='SMOKE',
312             )
313
314     show_flows = BoolProperty(
315             name="Render Smoke Objects",
316             description="Keep the smoke objects visible during rendering",
317             default=False,
318             )
319
320     def execute(self, context):
321         if not bpy.app.build_options.mod_smoke:
322             self.report({'ERROR'}, "Built without Smoke modifier support")
323             return {'CANCELLED'}
324
325         fake_context = context.copy()
326         mesh_objects = [obj for obj in context.selected_objects
327                         if obj.type == 'MESH']
328         min_co = Vector((100000.0, 100000.0, 100000.0))
329         max_co = -min_co
330
331         if not mesh_objects:
332             self.report({'ERROR'}, "Select at least one mesh object")
333             return {'CANCELLED'}
334
335         for obj in mesh_objects:
336             fake_context["object"] = obj
337             # make each selected object a smoke flow
338             bpy.ops.object.modifier_add(fake_context, type='SMOKE')
339             obj.modifiers[-1].smoke_type = 'FLOW'
340
341             # set type
342             obj.modifiers[-1].flow_settings.smoke_flow_type = self.style
343
344             if not self.show_flows:
345                 obj.draw_type = 'WIRE'
346
347             # store bounding box min/max for the domain object
348             obj_bb_minmax(obj, min_co, max_co)
349
350         # add the smoke domain object
351         bpy.ops.mesh.primitive_cube_add()
352         obj = context.active_object
353         obj.name = "Smoke Domain"
354
355         # give the smoke some room above the flows
356         obj.location = 0.5 * (max_co + min_co) + Vector((0.0, 0.0, 1.0))
357         obj.scale = 0.5 * (max_co - min_co) + Vector((1.0, 1.0, 2.0))
358
359         # setup smoke domain
360         bpy.ops.object.modifier_add(type='SMOKE')
361         obj.modifiers[-1].smoke_type = 'DOMAIN'
362         if self.style == 'FIRE' or self.style == 'BOTH':
363             obj.modifiers[-1].domain_settings.use_high_resolution = True
364
365         # Setup material
366
367         # Cycles
368         if context.scene.render.use_shading_nodes:
369             bpy.ops.object.material_slot_add()
370
371             mat = bpy.data.materials.new("Smoke Domain Material")
372             obj.material_slots[0].material = mat
373
374             # Make sure we use nodes
375             mat.use_nodes = True
376
377             # Set node variables and clear the default nodes
378             tree = mat.node_tree
379             nodes = tree.nodes
380             links = tree.links
381
382             nodes.clear()
383
384             # Create shader nodes
385
386             # Material output
387             node_out = nodes.new(type='ShaderNodeOutputMaterial')
388             node_out.location = grid_location(6, 1)
389
390             # Add Principled Volume
391             node_principled = nodes.new(type='ShaderNodeVolumePrincipled')
392             node_principled.location = grid_location(4, 1)
393             links.new(node_principled.outputs["Volume"],
394                     node_out.inputs["Volume"])
395
396             node_principled.inputs["Density"].default_value = 5.0
397
398             if self.style in {'FIRE', 'BOTH'}:
399                 node_principled.inputs["Blackbody Intensity"].default_value = 1.0
400
401         # Blender Internal
402         else:
403             # create a volume material with a voxel data texture for the domain
404             bpy.ops.object.material_slot_add()
405
406             mat = bpy.data.materials.new("Smoke Domain Material")
407             obj.material_slots[0].material = mat
408             mat.type = 'VOLUME'
409             mat.volume.density = 0
410             mat.volume.density_scale = 5
411             mat.volume.step_size = 0.1
412
413             tex = bpy.data.textures.new("Smoke Density", 'VOXEL_DATA')
414             tex.voxel_data.domain_object = obj
415             tex.voxel_data.interpolation = 'TRICUBIC_BSPLINE'
416
417             tex_slot = mat.texture_slots.add()
418             tex_slot.texture = tex
419             tex_slot.texture_coords = 'ORCO'
420             tex_slot.use_map_color_emission = False
421             tex_slot.use_map_density = True
422             tex_slot.use_map_color_reflection = True
423
424             # for fire add a second texture for flame emission
425             mat.volume.emission_color = Vector((0.0, 0.0, 0.0))
426             tex = bpy.data.textures.new("Flame", 'VOXEL_DATA')
427             tex.voxel_data.domain_object = obj
428             tex.voxel_data.smoke_data_type = 'SMOKEFLAME'
429             tex.voxel_data.interpolation = 'TRICUBIC_BSPLINE'
430             tex.use_color_ramp = True
431
432             tex_slot = mat.texture_slots.add()
433             tex_slot.texture = tex
434             tex_slot.texture_coords = 'ORCO'
435
436             # add color ramp for flame color
437             ramp = tex.color_ramp
438             # dark orange
439             elem = ramp.elements.new(0.333)
440             elem.color = (0.2, 0.03, 0.0, 1.0)
441
442             # yellow glow
443             elem = ramp.elements.new(0.666)
444             elem.color = (1, 0.65, 0.25, 1.0)
445
446             mat.texture_slots[1].use_map_density = True
447             mat.texture_slots[1].use_map_emission = True
448             mat.texture_slots[1].emission_factor = 5
449
450         return {'FINISHED'}
451
452
453 class QuickFluid(Operator):
454     bl_idname = "object.quick_fluid"
455     bl_label = "Quick Fluid"
456     bl_options = {'REGISTER', 'UNDO'}
457
458     style = EnumProperty(
459             name="Fluid Style",
460             items=(('INFLOW', "Inflow", ""),
461                    ('BASIC', "Basic", "")),
462             default='BASIC',
463             )
464     initial_velocity = FloatVectorProperty(
465             name="Initial Velocity",
466             description="Initial velocity of the fluid",
467             min=-100.0, max=100.0,
468             default=(0.0, 0.0, 0.0),
469             subtype='VELOCITY',
470             )
471     show_flows = BoolProperty(
472             name="Render Fluid Objects",
473             description="Keep the fluid objects visible during rendering",
474             default=False,
475             )
476     start_baking = BoolProperty(
477             name="Start Fluid Bake",
478             description=("Start baking the fluid immediately "
479                          "after creating the domain object"),
480             default=False,
481             )
482
483     def execute(self, context):
484         if not bpy.app.build_options.mod_fluid:
485             self.report({'ERROR'}, "Built without Fluid modifier support")
486             return {'CANCELLED'}
487
488         fake_context = context.copy()
489         mesh_objects = [obj for obj in context.selected_objects
490                         if (obj.type == 'MESH' and 0.0 not in obj.dimensions)]
491         min_co = Vector((100000.0, 100000.0, 100000.0))
492         max_co = -min_co
493
494         if not mesh_objects:
495             self.report({'ERROR'}, "Select at least one mesh object")
496             return {'CANCELLED'}
497
498         for obj in mesh_objects:
499             fake_context["object"] = obj
500             # make each selected object a fluid
501             bpy.ops.object.modifier_add(fake_context, type='FLUID_SIMULATION')
502
503             # fluid has to be before constructive modifiers,
504             # so it might not be the last modifier
505             for mod in obj.modifiers:
506                 if mod.type == 'FLUID_SIMULATION':
507                     break
508
509             if self.style == 'INFLOW':
510                 mod.settings.type = 'INFLOW'
511                 mod.settings.inflow_velocity = self.initial_velocity
512             else:
513                 mod.settings.type = 'FLUID'
514                 mod.settings.initial_velocity = self.initial_velocity
515
516             obj.hide_render = not self.show_flows
517             if not self.show_flows:
518                 obj.draw_type = 'WIRE'
519
520             # store bounding box min/max for the domain object
521             obj_bb_minmax(obj, min_co, max_co)
522
523         # add the fluid domain object
524         bpy.ops.mesh.primitive_cube_add()
525         obj = context.active_object
526         obj.name = "Fluid Domain"
527
528         # give the fluid some room below the flows
529         # and scale with initial velocity
530         v = 0.5 * self.initial_velocity
531         obj.location = 0.5 * (max_co + min_co) + Vector((0.0, 0.0, -1.0)) + v
532         obj.scale = (0.5 * (max_co - min_co) +
533                      Vector((1.0, 1.0, 2.0)) +
534                      Vector((abs(v[0]), abs(v[1]), abs(v[2])))
535                      )
536
537         # setup smoke domain
538         bpy.ops.object.modifier_add(type='FLUID_SIMULATION')
539         obj.modifiers[-1].settings.type = 'DOMAIN'
540
541         # make the domain smooth so it renders nicely
542         bpy.ops.object.shade_smooth()
543
544         # create a ray-transparent material for the domain
545         bpy.ops.object.material_slot_add()
546
547         mat = bpy.data.materials.new("Fluid Domain Material")
548         obj.material_slots[0].material = mat
549
550         mat.specular_intensity = 1
551         mat.specular_hardness = 100
552         mat.use_transparency = True
553         mat.alpha = 0.0
554         mat.transparency_method = 'RAYTRACE'
555         mat.raytrace_transparency.ior = 1.33
556         mat.raytrace_transparency.depth = 4
557
558         if self.start_baking:
559             bpy.ops.fluid.bake('INVOKE_DEFAULT')
560
561         return {'FINISHED'}
562
563
564 classes = (
565     QuickExplode,
566     QuickFluid,
567     QuickFur,
568     QuickSmoke,
569 )