svn merge -r 21041:21301 https://svn.blender.org/svnroot/bf-blender/branches/blender2...
[blender.git] / source / blender / editors / physics / ed_pointcache.c
1 /*
2  * $Id$
3  *
4  * ***** BEGIN GPL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software Foundation,
18  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19  *
20  * The Original Code is Copyright (C) 2007 by Janne Karhu.
21  * All rights reserved.
22  *
23  * The Original Code is: all of this file.
24  *
25  * Contributor(s): none yet.
26  *
27  * ***** END GPL LICENSE BLOCK *****
28  */
29
30 #include "MEM_guardedalloc.h"
31
32 #include "DNA_scene_types.h"
33 #include "DNA_object_force.h"
34 #include "DNA_modifier_types.h"
35
36 #include "BKE_context.h"
37 #include "BKE_particle.h"
38 #include "BKE_report.h"
39 #include "BKE_scene.h"
40 #include "BKE_utildefines.h" 
41 #include "BKE_pointcache.h"
42 #include "BKE_global.h"
43 #include "BKE_modifier.h"
44
45 #include "BLI_blenlib.h"
46
47 #include "ED_screen.h"
48 #include "ED_pointcache.h"
49
50 #include "UI_interface.h"
51 #include "UI_resources.h"
52
53 #include "WM_api.h"
54 #include "WM_types.h"
55
56 #include "RNA_access.h"
57 #include "RNA_define.h"
58
59 #include "physics_intern.h"
60
61 static int cache_break_test(void *cbd) {
62         return G.afbreek==1;
63 }
64 /**************************** general **********************************/
65 static int ptcache_bake_all_poll(bContext *C)
66 {
67         Scene *scene= CTX_data_scene(C);
68
69         if(!scene)
70                 return 0;
71         
72         return 1;
73 }
74
75 static int ptcache_bake_all_exec(bContext *C, wmOperator *op)
76 {
77         Scene *scene= CTX_data_scene(C);
78         PTCacheBaker baker;
79
80
81         baker.scene = scene;
82         baker.pid = NULL;
83         baker.bake = RNA_boolean_get(op->ptr, "bake");
84         baker.render = 0;
85         baker.quick_step = 1;
86         baker.break_test = cache_break_test;
87         baker.break_data = NULL;
88         baker.progressbar = (void (*)(void *, int))WM_timecursor;
89         baker.progresscontext = CTX_wm_window(C);
90
91         BKE_ptcache_make_cache(&baker);
92
93         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
94
95         return OPERATOR_FINISHED;
96 }
97 static int ptcache_free_bake_all_exec(bContext *C, wmOperator *op)
98 {
99         Scene *scene= CTX_data_scene(C);
100         Base *base;
101         PTCacheID *pid;
102         ListBase pidlist;
103
104         for(base=scene->base.first; base; base= base->next) {
105                 BKE_ptcache_ids_from_object(&pidlist, base->object);
106
107                 for(pid=pidlist.first; pid; pid=pid->next) {
108                         pid->cache->flag &= ~PTCACHE_BAKED;
109                 }
110                 
111                 BLI_freelistN(&pidlist);
112         }
113
114         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
115
116         return OPERATOR_FINISHED;
117 }
118
119 void PTCACHE_OT_bake_all(wmOperatorType *ot)
120 {
121         /* identifiers */
122         ot->name= "Bake All Physics";
123         ot->idname= "PTCACHE_OT_bake_all";
124         
125         /* api callbacks */
126         ot->exec= ptcache_bake_all_exec;
127         ot->poll= ptcache_bake_all_poll;
128
129         /* flags */
130         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
131
132         RNA_def_boolean(ot->srna, "bake", 0, "Bake", "");
133 }
134 void PTCACHE_OT_free_bake_all(wmOperatorType *ot)
135 {
136         /* identifiers */
137         ot->name= "Free All Physics Bakes";
138         ot->idname= "PTCACHE_OT_free_bake_all";
139         
140         /* api callbacks */
141         ot->exec= ptcache_free_bake_all_exec;
142         ot->poll= ptcache_bake_all_poll;
143
144         /* flags */
145         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
146 }
147
148 /**************************** cloth **********************************/
149 static int ptcache_bake_cloth_poll(bContext *C)
150 {
151         Scene *scene= CTX_data_scene(C);
152         Object *ob= CTX_data_active_object(C);
153         ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
154
155         if(!scene || !ob || ob->id.lib || !clmd)
156                 return 0;
157         
158         return 1;
159 }
160
161 static int ptcache_bake_cloth_exec(bContext *C, wmOperator *op)
162 {
163         Scene *scene= CTX_data_scene(C);
164         Object *ob= CTX_data_active_object(C);
165         ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
166         PTCacheID pid;
167         PTCacheBaker baker;
168
169         BKE_ptcache_id_from_cloth(&pid, ob, clmd);
170
171         baker.scene = scene;
172         baker.pid = &pid;
173         baker.bake = RNA_boolean_get(op->ptr, "bake");
174         baker.render = 0;
175         baker.quick_step = 1;
176         baker.break_test = cache_break_test;
177         baker.break_data = NULL;
178         baker.progressbar = WM_timecursor;
179         baker.progresscontext = CTX_wm_window(C);
180
181         BKE_ptcache_make_cache(&baker);
182
183         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
184
185         return OPERATOR_FINISHED;
186 }
187 static int ptcache_free_bake_cloth_exec(bContext *C, wmOperator *op)
188 {
189         Scene *scene= CTX_data_scene(C);
190         Object *ob= CTX_data_active_object(C);
191         ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
192         PTCacheID pid;
193
194         BKE_ptcache_id_from_cloth(&pid, ob, clmd);
195         pid.cache->flag &= ~PTCACHE_BAKED;
196
197         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
198
199         return OPERATOR_FINISHED;
200 }
201 void PTCACHE_OT_cache_cloth(wmOperatorType *ot)
202 {
203         /* identifiers */
204         ot->name= "Bake Cloth";
205         ot->idname= "PTCACHE_OT_cache_cloth";
206         
207         /* api callbacks */
208         ot->exec= ptcache_bake_cloth_exec;
209         ot->poll= ptcache_bake_cloth_poll;
210
211         /* flags */
212         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
213
214         RNA_def_boolean(ot->srna, "bake", 0, "Bake", "");
215 }
216 void PTCACHE_OT_free_bake_cloth(wmOperatorType *ot)
217 {
218         /* identifiers */
219         ot->name= "Free Cloth Bake";
220         ot->idname= "PTCACHE_OT_free_bake_cloth";
221         
222         /* api callbacks */
223         ot->exec= ptcache_free_bake_cloth_exec;
224         ot->poll= ptcache_bake_cloth_poll;
225
226         /* flags */
227         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
228 }
229 static int ptcache_bake_from_cloth_cache_exec(bContext *C, wmOperator *op)
230 {
231         Object *ob= CTX_data_active_object(C);
232         ClothModifierData *clmd = (ClothModifierData *)modifiers_findByType(ob, eModifierType_Cloth);
233         PTCacheID pid;
234
235         BKE_ptcache_id_from_cloth(&pid, ob, clmd);
236         pid.cache->flag |= PTCACHE_BAKED;
237
238         return OPERATOR_FINISHED;
239 }
240 void PTCACHE_OT_bake_from_cloth_cache(wmOperatorType *ot)
241 {
242         /* identifiers */
243         ot->name= "Bake From Cache";
244         ot->idname= "PTCACHE_OT_bake_from_cloth_cache";
245         
246         /* api callbacks */
247         ot->exec= ptcache_bake_from_cloth_cache_exec;
248         ot->poll= ptcache_bake_cloth_poll;
249
250         /* flags */
251         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
252 }
253
254 /**************************** particles **********************************/
255 static int ptcache_bake_particle_system_poll(bContext *C)
256 {
257         Scene *scene= CTX_data_scene(C);
258         Object *ob= CTX_data_active_object(C);
259
260         if(!scene || !ob || ob->id.lib)
261                 return 0;
262         
263         return (ob->particlesystem.first != NULL);
264 }
265
266 static int ptcache_bake_particle_system_exec(bContext *C, wmOperator *op)
267 {
268         Scene *scene= CTX_data_scene(C);
269         Object *ob= CTX_data_active_object(C);
270         ParticleSystem *psys =psys_get_current(ob);
271         PTCacheID pid;
272         PTCacheBaker baker;
273
274         BKE_ptcache_id_from_particles(&pid, ob, psys);
275
276         baker.scene = scene;
277         baker.pid = &pid;
278         baker.bake = RNA_boolean_get(op->ptr, "bake");
279         baker.render = 0;
280         baker.quick_step = 1;
281         baker.break_test = cache_break_test;
282         baker.break_data = NULL;
283         baker.progressbar = (void (*)(void *, int))WM_timecursor;
284         baker.progresscontext = CTX_wm_window(C);
285
286         BKE_ptcache_make_cache(&baker);
287
288         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
289
290         return OPERATOR_FINISHED;
291 }
292 static int ptcache_free_bake_particle_system_exec(bContext *C, wmOperator *op)
293 {
294         Scene *scene= CTX_data_scene(C);
295         Object *ob= CTX_data_active_object(C);
296         ParticleSystem *psys= psys_get_current(ob);
297         PTCacheID pid;
298
299         BKE_ptcache_id_from_particles(&pid, ob, psys);
300         psys->pointcache->flag &= ~PTCACHE_BAKED;
301
302         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
303
304         return OPERATOR_FINISHED;
305 }
306 void PTCACHE_OT_cache_particle_system(wmOperatorType *ot)
307 {
308         /* identifiers */
309         ot->name= "Bake Particles";
310         ot->idname= "PTCACHE_OT_cache_particle_system";
311         
312         /* api callbacks */
313         ot->exec= ptcache_bake_particle_system_exec;
314         ot->poll= ptcache_bake_particle_system_poll;
315
316         /* flags */
317         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
318
319         RNA_def_boolean(ot->srna, "bake", 0, "Bake", "");
320 }
321 void PTCACHE_OT_free_bake_particle_system(wmOperatorType *ot)
322 {
323         /* identifiers */
324         ot->name= "Free Particles Bake";
325         ot->idname= "PTCACHE_OT_free_bake_particle_system";
326         
327         /* api callbacks */
328         ot->exec= ptcache_free_bake_particle_system_exec;
329         ot->poll= ptcache_bake_particle_system_poll;
330
331         /* flags */
332         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
333 }
334 static int ptcache_bake_from_particles_cache_exec(bContext *C, wmOperator *op)
335 {
336         Object *ob= CTX_data_active_object(C);
337         ParticleSystem *psys= psys_get_current(ob);
338         PTCacheID pid;
339
340         BKE_ptcache_id_from_particles(&pid, ob, psys);
341         psys->pointcache->flag |= PTCACHE_BAKED;
342
343         return OPERATOR_FINISHED;
344 }
345 void PTCACHE_OT_bake_from_particles_cache(wmOperatorType *ot)
346 {
347         /* identifiers */
348         ot->name= "Bake From Cache";
349         ot->idname= "PTCACHE_OT_bake_from_particles_cache";
350         
351         /* api callbacks */
352         ot->exec= ptcache_bake_from_particles_cache_exec;
353         ot->poll= ptcache_bake_particle_system_poll;
354
355         /* flags */
356         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
357 }
358
359 /**************************** registration **********************************/
360
361 void ED_operatortypes_pointcache(void)
362 {
363         WM_operatortype_append(PTCACHE_OT_bake_all);
364         WM_operatortype_append(PTCACHE_OT_free_bake_all);
365         WM_operatortype_append(PTCACHE_OT_cache_particle_system);
366         WM_operatortype_append(PTCACHE_OT_free_bake_particle_system);
367         WM_operatortype_append(PTCACHE_OT_bake_from_particles_cache);
368         WM_operatortype_append(PTCACHE_OT_cache_cloth);
369         WM_operatortype_append(PTCACHE_OT_free_bake_cloth);
370         WM_operatortype_append(PTCACHE_OT_bake_from_cloth_cache);
371 }
372
373 //void ED_keymap_pointcache(wmWindowManager *wm)
374 //{
375 //      ListBase *keymap= WM_keymap_listbase(wm, "Pointcache", 0, 0);
376 //      
377 //      WM_keymap_add_item(keymap, "PHYSICS_OT_bake_all", AKEY, KM_PRESS, 0, 0);
378 //      WM_keymap_add_item(keymap, "PHYSICS_OT_free_all", PADPLUSKEY, KM_PRESS, KM_CTRL, 0);
379 //      WM_keymap_add_item(keymap, "PHYSICS_OT_bake_particle_system", PADMINUS, KM_PRESS, KM_CTRL, 0);
380 //      WM_keymap_add_item(keymap, "PHYSICS_OT_free_particle_system", LKEY, KM_PRESS, 0, 0);
381 //}
382