minor pep8 edits, also added 'test_pep8' & 'test_cmake' to the GNUmakefile for conven...
[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 compliant>
20
21 from mathutils import Vector
22 import bpy
23 from bpy.props import BoolProperty, EnumProperty, IntProperty, FloatProperty, FloatVectorProperty
24
25
26 class MakeFur(bpy.types.Operator):
27     bl_idname = "object.make_fur"
28     bl_label = "Make Fur"
29     bl_options = {'REGISTER', 'UNDO'}
30
31     density = EnumProperty(items=(
32                         ('LIGHT', "Light", ""),
33                         ('MEDIUM', "Medium", ""),
34                         ('HEAVY', "Heavy", "")),
35                 name="Fur Density",
36                 description="",
37                 default='MEDIUM')
38
39     view_percentage = IntProperty(name="View %",
40             default=10, min=1, max=100, soft_min=1, soft_max=100)
41
42     length = FloatProperty(name="Length",
43             default=0.1, min=0.001, max=100, soft_min=0.01, soft_max=10)
44
45     def execute(self, context):
46         fake_context = bpy.context.copy()
47         mesh_objects = [obj for obj in context.selected_objects if obj.type == 'MESH']
48
49         if not mesh_objects:
50             self.report({'ERROR'}, "Select at least one mesh object.")
51             return {'CANCELLED'}
52
53         mat = bpy.data.materials.new("Fur Material")
54         mat.strand.tip_size = 0.25
55         mat.strand.blend_distance = 0.5
56
57         for obj in mesh_objects:
58             fake_context["active_object"] = obj
59             bpy.ops.object.particle_system_add(fake_context)
60
61             psys = obj.particle_systems[-1]
62             psys.settings.type = 'HAIR'
63
64             if self.density == 'LIGHT':
65                 psys.settings.count = 100
66             elif self.density == 'MEDIUM':
67                 psys.settings.count = 1000
68             elif self.density == 'HEAVY':
69                 psys.settings.count = 10000
70
71             psys.settings.child_nbr = self.view_percentage
72             psys.settings.hair_length = self.length
73             psys.settings.use_strand_primitive = True
74             psys.settings.use_hair_bspline = True
75             psys.settings.child_type = 'INTERPOLATED'
76
77             obj.data.materials.append(mat)
78             obj.particle_systems[-1].settings.material = len(obj.data.materials)
79
80         return {'FINISHED'}
81
82
83 def obj_bb_minmax(obj, min_co, max_co):
84     for i in range(0, 8):
85         bb_vec = Vector((obj.bound_box[i][0], obj.bound_box[i][1], obj.bound_box[i][2])) * obj.matrix_world
86
87         min_co[0] = min(bb_vec[0], min_co[0])
88         min_co[1] = min(bb_vec[1], min_co[1])
89         min_co[2] = min(bb_vec[2], min_co[2])
90         max_co[0] = max(bb_vec[0], max_co[0])
91         max_co[1] = max(bb_vec[1], max_co[1])
92         max_co[2] = max(bb_vec[2], max_co[2])
93
94
95 class MakeSmoke(bpy.types.Operator):
96     bl_idname = "object.make_smoke"
97     bl_label = "Make Smoke"
98     bl_options = {'REGISTER', 'UNDO'}
99
100     style = EnumProperty(items=(
101                         ('STREAM', "Stream", ""),
102                         ('PUFF', "Puff", ""),
103                         ('FIRE', "Fire", "")),
104                 name="Smoke Style",
105                 description="",
106                 default='STREAM')
107
108     show_flows = BoolProperty(name="Render Smoke Objects",
109                 description="Keep the smoke objects visible during rendering.",
110                 default=False)
111
112     def execute(self, context):
113         mesh_objects = [obj for obj in context.selected_objects if obj.type == 'MESH']
114         min_co = Vector((100000, 100000, 100000))
115         max_co = Vector((-100000, -100000, -100000))
116
117         if not mesh_objects:
118             self.report({'ERROR'}, "Select at least one mesh object.")
119             return {'CANCELLED'}
120
121         for obj in mesh_objects:
122             # make each selected object a smoke flow
123             bpy.ops.object.modifier_add({"object": obj}, type='SMOKE')
124             obj.modifiers[-1].smoke_type = 'FLOW'
125
126             psys = obj.particle_systems[-1]
127             if self.style == 'PUFF':
128                 psys.settings.frame_end = psys.settings.frame_start
129                 psys.settings.emit_from = 'VOLUME'
130                 psys.settings.distribution = 'RAND'
131             elif self.style == 'FIRE':
132                 psys.settings.effector_weights.gravity = -1
133                 psys.settings.lifetime = 5
134                 psys.settings.count = 100000
135
136                 obj.modifiers[-2].flow_settings.initial_velocity = True
137                 obj.modifiers[-2].flow_settings.temperature = 2
138
139             psys.settings.use_render_emitter = self.show_flows
140             if not self.show_flows:
141                 obj.draw_type = 'WIRE'
142
143             # store bounding box min/max for the domain object
144             obj_bb_minmax(obj, min_co, max_co)
145
146         # add the smoke domain object
147         bpy.ops.mesh.primitive_cube_add()
148         obj = context.active_object
149         obj.name = "Smoke Domain"
150
151         # give the smoke some room above the flows
152         obj.location = 0.5 * (max_co + min_co) + Vector((0.0, 0.0, 1.0))
153         obj.scale = 0.5 * (max_co - min_co) + Vector((1.0, 1.0, 2.0))
154
155         # setup smoke domain
156         bpy.ops.object.modifier_add({"object": obj}, type='SMOKE')
157         obj.modifiers[-1].smoke_type = 'DOMAIN'
158         if self.style == 'FIRE':
159             obj.modifiers[-1].domain_settings.use_dissolve_smoke = True
160             obj.modifiers[-1].domain_settings.dissolve_speed = 20
161             obj.modifiers[-1].domain_settings.use_high_resolution = True
162
163         # create a volume material with a voxel data texture for the domain
164         bpy.ops.object.material_slot_add({"object": obj})
165
166         mat = bpy.data.materials.new("Smoke Domain Material")
167         obj.material_slots[0].material = mat
168         mat.type = 'VOLUME'
169         mat.volume.density = 0
170         mat.volume.density_scale = 5
171
172         mat.texture_slots.add()
173         mat.texture_slots[0].texture = bpy.data.textures.new("Smoke Density", 'VOXEL_DATA')
174         mat.texture_slots[0].texture.voxel_data.domain_object = obj
175         mat.texture_slots[0].use_map_color_emission = False
176         mat.texture_slots[0].use_map_density = True
177
178         # for fire add a second texture for emission and emission color
179         if self.style == 'FIRE':
180             mat.volume.emission = 5
181             mat.texture_slots.add()
182             mat.texture_slots[1].texture = bpy.data.textures.new("Smoke Heat", 'VOXEL_DATA')
183             mat.texture_slots[1].texture.voxel_data.domain_object = obj
184             mat.texture_slots[1].texture.use_color_ramp = True
185
186             ramp = mat.texture_slots[1].texture.color_ramp
187
188             elem = ramp.elements.new(0.333)
189             elem.color[0] = elem.color[3] = 1
190             elem.color[1] = elem.color[2] = 0
191
192             elem = ramp.elements.new(0.666)
193             elem.color[0] = elem.color[1] = elem.color[3] = 1
194             elem.color[2] = 0
195
196             mat.texture_slots[1].use_map_emission = True
197             mat.texture_slots[1].blend_type = 'MULTIPLY'
198
199         return {'FINISHED'}
200
201
202 class MakeFluid(bpy.types.Operator):
203     bl_idname = "object.make_fluid"
204     bl_label = "Make Fluid"
205     bl_options = {'REGISTER', 'UNDO'}
206
207     style = EnumProperty(items=(
208                         ('INFLOW', "Inflow", ""),
209                         ('BASIC', "Basic", "")),
210                 name="Fluid Style",
211                 description="",
212                 default='BASIC')
213
214     initial_velocity = FloatVectorProperty(name="Initial Velocity",
215         description="Initial velocity of the fluid",
216         default=(0.0, 0.0, 0.0), min=-100.0, max=100.0, subtype='VELOCITY')
217
218     show_flows = BoolProperty(name="Render Fluid Objects",
219                 description="Keep the fluid objects visible during rendering.",
220                 default=False)
221
222     start_baking = BoolProperty(name="Start Fluid Bake",
223                 description="Start baking the fluid immediately after creating the domain object.",
224                 default=False)
225
226     def execute(self, context):
227         mesh_objects = [obj for obj in context.selected_objects if (obj.type == 'MESH' and not 0 in obj.dimensions)]
228         min_co = Vector((100000, 100000, 100000))
229         max_co = Vector((-100000, -100000, -100000))
230
231         if not mesh_objects:
232             self.report({'ERROR'}, "Select at least one mesh object.")
233             return {'CANCELLED'}
234
235         for obj in mesh_objects:
236             # make each selected object a fluid
237             bpy.ops.object.modifier_add({"object": obj}, type='FLUID_SIMULATION')
238
239             # fluid has to be before constructive modifiers, so it might not be the last modifier
240             for mod in obj.modifiers:
241                 if mod.type == 'FLUID_SIMULATION':
242                     break
243
244             if self.style == 'INFLOW':
245                 mod.settings.type = 'INFLOW'
246                 mod.settings.inflow_velocity = self.initial_velocity.copy()
247             else:
248                 mod.settings.type = 'FLUID'
249                 mod.settings.initial_velocity = self.initial_velocity.copy()
250
251             obj.hide_render = not self.show_flows
252             if not self.show_flows:
253                 obj.draw_type = 'WIRE'
254
255             # store bounding box min/max for the domain object
256             obj_bb_minmax(obj, min_co, max_co)
257
258         # add the fluid domain object
259         bpy.ops.mesh.primitive_cube_add()
260         obj = context.active_object
261         obj.name = "Fluid Domain"
262
263         # give the fluid some room below the flows and scale with initial velocity
264         v = 0.5 * self.initial_velocity
265         obj.location = 0.5 * (max_co + min_co) + Vector((0.0, 0.0, -1.0)) + v
266         obj.scale = 0.5 * (max_co - min_co) + Vector((1.0, 1.0, 2.0)) + Vector((abs(v[0]), abs(v[1]), abs(v[2])))
267
268         # setup smoke domain
269         bpy.ops.object.modifier_add({"object": obj}, type='FLUID_SIMULATION')
270         obj.modifiers[-1].settings.type = 'DOMAIN'
271
272         # make the domain smooth so it renders nicely
273         bpy.ops.object.shade_smooth()
274
275         # create a ray-transparent material for the domain
276         bpy.ops.object.material_slot_add({"object": obj})
277
278         mat = bpy.data.materials.new("Fluid Domain Material")
279         obj.material_slots[0].material = mat
280
281         mat.specular_intensity = 1
282         mat.specular_hardness = 100
283         mat.use_transparency = True
284         mat.alpha = 0.0
285         mat.transparency_method = 'RAYTRACE'
286         mat.raytrace_transparency.ior = 1.33
287         mat.raytrace_transparency.depth = 4
288
289         if self.start_baking:
290             bpy.ops.fluid.bake()
291
292         return {'FINISHED'}