edits to the bone copy metarig type from Cessen, pointcache warning fix
[blender.git] / source / blender / editors / physics / physics_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 <stdlib.h>
31
32 #include "MEM_guardedalloc.h"
33
34 #include "DNA_scene_types.h"
35 #include "DNA_object_force.h"
36 #include "DNA_modifier_types.h"
37
38 #include "BKE_context.h"
39 #include "BKE_particle.h"
40 #include "BKE_report.h"
41 #include "BKE_scene.h"
42 #include "BKE_utildefines.h" 
43 #include "BKE_pointcache.h"
44 #include "BKE_global.h"
45 #include "BKE_modifier.h"
46
47 #include "BLI_blenlib.h"
48
49 #include "ED_screen.h"
50 #include "ED_physics.h"
51 #include "ED_particle.h"
52
53 #include "UI_interface.h"
54 #include "UI_resources.h"
55
56 #include "WM_api.h"
57 #include "WM_types.h"
58
59 #include "RNA_access.h"
60 #include "RNA_define.h"
61
62 #include "physics_intern.h"
63
64 static int cache_break_test(void *cbd) {
65         return G.afbreek==1;
66 }
67 static int ptcache_bake_all_poll(bContext *C)
68 {
69         Scene *scene= CTX_data_scene(C);
70
71         if(!scene)
72                 return 0;
73         
74         return 1;
75 }
76
77 static int ptcache_poll(bContext *C)
78 {
79         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
80         return (ptr.data && ptr.id.data);
81 }
82
83 void bake_console_progress(void *arg, int nr)
84 {
85         printf("\rbake: %3i%%", nr);
86         fflush(stdout);
87 }
88
89 void bake_console_progress_end(void *arg)
90 {
91         printf("\n");
92 }
93
94 static int ptcache_bake_all_exec(bContext *C, wmOperator *op)
95 {
96         Scene *scene= CTX_data_scene(C);
97         wmWindow *win = CTX_wm_window(C);
98         PTCacheBaker baker;
99
100
101         baker.scene = scene;
102         baker.pid = NULL;
103         baker.bake = RNA_boolean_get(op->ptr, "bake");
104         baker.render = 0;
105         baker.anim_init = 0;
106         baker.quick_step = 1;
107         baker.break_test = cache_break_test;
108         baker.break_data = NULL;
109
110         if (win) {
111                 baker.progressbar = (void (*)(void *, int))WM_timecursor;
112                 baker.progressend = (void (*)(void *))WM_cursor_restore;
113                 baker.progresscontext = win;
114         } else {
115                 baker.progressbar = bake_console_progress;
116                 baker.progressend = bake_console_progress_end;
117                 baker.progresscontext = NULL;
118         }
119
120         BKE_ptcache_make_cache(&baker);
121
122         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
123
124         return OPERATOR_FINISHED;
125 }
126 static int ptcache_free_bake_all_exec(bContext *C, wmOperator *op)
127 {
128         Scene *scene= CTX_data_scene(C);
129         Base *base;
130         PTCacheID *pid;
131         ListBase pidlist;
132
133         for(base=scene->base.first; base; base= base->next) {
134                 BKE_ptcache_ids_from_object(&pidlist, base->object);
135
136                 for(pid=pidlist.first; pid; pid=pid->next) {
137                         pid->cache->flag &= ~PTCACHE_BAKED;
138                 }
139                 
140                 BLI_freelistN(&pidlist);
141         }
142
143         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
144
145         return OPERATOR_FINISHED;
146 }
147
148 void PTCACHE_OT_bake_all(wmOperatorType *ot)
149 {
150         /* identifiers */
151         ot->name= "Bake All Physics";
152         ot->idname= "PTCACHE_OT_bake_all";
153         
154         /* api callbacks */
155         ot->exec= ptcache_bake_all_exec;
156         ot->poll= ptcache_bake_all_poll;
157
158         /* flags */
159         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
160
161         RNA_def_boolean(ot->srna, "bake", 1, "Bake", "");
162 }
163 void PTCACHE_OT_free_bake_all(wmOperatorType *ot)
164 {
165         /* identifiers */
166         ot->name= "Free All Physics Bakes";
167         ot->idname= "PTCACHE_OT_free_bake_all";
168         
169         /* api callbacks */
170         ot->exec= ptcache_free_bake_all_exec;
171         ot->poll= ptcache_bake_all_poll;
172
173         /* flags */
174         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
175 }
176 static int ptcache_bake_exec(bContext *C, wmOperator *op)
177 {
178         Scene *scene = CTX_data_scene(C);
179         wmWindow *win = CTX_wm_window(C);
180         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
181         Object *ob= ptr.id.data;
182         PointCache *cache= ptr.data;
183         PTCacheBaker baker;
184         PTCacheID *pid;
185         ListBase pidlist;
186
187         BKE_ptcache_ids_from_object(&pidlist, ob);
188         
189         for(pid=pidlist.first; pid; pid=pid->next) {
190                 if(pid->cache == cache)
191                         break;
192         }
193
194         baker.scene = scene;
195         baker.pid = pid;
196         baker.bake = RNA_boolean_get(op->ptr, "bake");
197         baker.render = 0;
198         baker.anim_init = 0;
199         baker.quick_step = 1;
200         baker.break_test = cache_break_test;
201         baker.break_data = NULL;
202
203         if (win) {
204                 baker.progressbar = (void (*)(void *, int))WM_timecursor;
205                 baker.progressend = (void (*)(void *))WM_cursor_restore;
206                 baker.progresscontext = win;
207         } else {
208                 printf("\n"); /* empty first line before console reports */
209                 baker.progressbar = bake_console_progress;
210                 baker.progressend = bake_console_progress_end;
211                 baker.progresscontext = NULL;
212         }
213
214         BKE_ptcache_make_cache(&baker);
215
216         BLI_freelistN(&pidlist);
217
218         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
219
220         return OPERATOR_FINISHED;
221 }
222 static int ptcache_free_bake_exec(bContext *C, wmOperator *op)
223 {
224         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
225         PointCache *cache= ptr.data;
226
227         if(cache->edit) {
228                 if(!cache->edit->edited || 1) {// XXX okee("Lose changes done in particle mode?")) {
229                         PE_free_ptcache_edit(cache->edit);
230                         cache->edit = NULL;
231                         cache->flag &= ~PTCACHE_BAKED;
232                 }
233         }
234         else
235                 cache->flag &= ~PTCACHE_BAKED;
236
237         return OPERATOR_FINISHED;
238 }
239 static int ptcache_bake_from_cache_exec(bContext *C, wmOperator *op)
240 {
241         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
242         PointCache *cache= ptr.data;
243         
244         cache->flag |= PTCACHE_BAKED;
245
246         return OPERATOR_FINISHED;
247 }
248 void PTCACHE_OT_bake(wmOperatorType *ot)
249 {
250         /* identifiers */
251         ot->name= "Bake Physics";
252         ot->idname= "PTCACHE_OT_bake";
253         
254         /* api callbacks */
255         ot->exec= ptcache_bake_exec;
256         ot->poll= ptcache_poll;
257
258         /* flags */
259         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
260
261         RNA_def_boolean(ot->srna, "bake", 0, "Bake", "");
262 }
263 void PTCACHE_OT_free_bake(wmOperatorType *ot)
264 {
265         /* identifiers */
266         ot->name= "Free Physics Bake";
267         ot->idname= "PTCACHE_OT_free_bake";
268         
269         /* api callbacks */
270         ot->exec= ptcache_free_bake_exec;
271         ot->poll= ptcache_poll;
272
273         /* flags */
274         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
275 }
276 void PTCACHE_OT_bake_from_cache(wmOperatorType *ot)
277 {
278         /* identifiers */
279         ot->name= "Bake From Cache";
280         ot->idname= "PTCACHE_OT_bake_from_cache";
281         
282         /* api callbacks */
283         ot->exec= ptcache_bake_from_cache_exec;
284         ot->poll= ptcache_poll;
285
286         /* flags */
287         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
288 }
289
290 static int ptcache_add_new_exec(bContext *C, wmOperator *op)
291 {
292         Scene *scene = CTX_data_scene(C);
293         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
294         Object *ob= ptr.id.data;
295         PointCache *cache= ptr.data;
296         PTCacheID *pid;
297         ListBase pidlist;
298
299         BKE_ptcache_ids_from_object(&pidlist, ob);
300         
301         for(pid=pidlist.first; pid; pid=pid->next) {
302                 if(pid->cache == cache) {
303                         *(pid->cache_ptr) = BKE_ptcache_add(pid->ptcaches);
304                         break;
305                 }
306         }
307
308         BLI_freelistN(&pidlist);
309
310         WM_event_add_notifier(C, NC_SCENE|ND_FRAME, scene);
311
312         return OPERATOR_FINISHED;
313 }
314 static int ptcache_remove_exec(bContext *C, wmOperator *op)
315 {
316         PointerRNA ptr= CTX_data_pointer_get_type(C, "PointCache", &RNA_PointCache);
317         Object *ob= ptr.id.data;
318         PointCache *cache= ptr.data;
319         PTCacheID *pid;
320         ListBase pidlist;
321
322         BKE_ptcache_ids_from_object(&pidlist, ob);
323         
324         for(pid=pidlist.first; pid; pid=pid->next) {
325                 if(pid->cache == cache) {
326                         if(pid->ptcaches->first == pid->ptcaches->last)
327                                 continue; /* don't delete last cache */
328
329                         BLI_remlink(pid->ptcaches, pid->cache);
330                         BKE_ptcache_free(pid->cache);
331                         *(pid->cache_ptr) = pid->ptcaches->first;
332
333                         break;
334                 }
335         }
336
337         BLI_freelistN(&pidlist);
338
339         return OPERATOR_FINISHED;
340 }
341 void PTCACHE_OT_add(wmOperatorType *ot)
342 {
343         /* identifiers */
344         ot->name= "Add new cache";
345         ot->idname= "PTCACHE_OT_add";
346         
347         /* api callbacks */
348         ot->exec= ptcache_add_new_exec;
349         ot->poll= ptcache_poll; // ptcache_bake_all_poll;
350
351         /* flags */
352         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
353 }
354 void PTCACHE_OT_remove(wmOperatorType *ot)
355 {
356         /* identifiers */
357         ot->name= "Delete current cache";
358         ot->idname= "PTCACHE_OT_remove";
359         
360         /* api callbacks */
361         ot->exec= ptcache_remove_exec;
362         ot->poll= ptcache_poll;
363
364         /* flags */
365         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
366 }
367