BGE Patch: Add Shape Action support and update MSCV_7 project file for glew.
[blender.git] / source / blender / blenkernel / intern / sca.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) 2001-2002 by NaN Holding BV.
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  * these all are linked to objects (listbase)
29  * all data is 'direct data', not Blender lib data.
30  */
31
32 #ifdef HAVE_CONFIG_H
33 #include <config.h>
34 #endif
35
36 #include <stdio.h>
37 #include <string.h>
38 #include "MEM_guardedalloc.h"
39
40 #include "nla.h"        /* For __NLA: Important, do not remove */
41 #include "DNA_text_types.h"
42 #include "DNA_controller_types.h"
43 #include "DNA_sensor_types.h"
44 #include "DNA_actuator_types.h"
45 #include "DNA_object_types.h"
46
47 #include "BLI_blenlib.h"
48 #include "BKE_bad_level_calls.h"
49 #include "BKE_utildefines.h"
50 #include "BKE_global.h"
51 #include "BKE_main.h"
52 #include "BKE_blender.h"
53 #include "BKE_sca.h"
54
55 void free_text_controllers(Text *txt)
56 {
57         Object *ob;
58         bController *cont;
59         
60         ob= G.main->object.first;
61         while(ob) {
62                 cont= ob->controllers.first;
63                 while(cont) {
64                         if(cont->type==CONT_PYTHON) {
65                                 bPythonCont *pc;
66                                 
67                                 pc= cont->data;
68                                 if(pc->text==txt) pc->text= NULL;
69                         }
70                         cont= cont->next;
71                 }
72                 ob= ob->id.next;
73         }
74 }
75
76
77 /* ******************* SENSORS ************************ */
78
79 void free_sensor(bSensor *sens)
80 {
81         if(sens->links) MEM_freeN(sens->links);
82         if(sens->data) MEM_freeN(sens->data);
83         MEM_freeN(sens);
84         
85 }
86
87 void free_sensors(ListBase *lb)
88 {
89         bSensor *sens;
90         
91         while((sens= lb->first)) {
92                 BLI_remlink(lb, sens);
93                 free_sensor(sens);
94         }
95 }
96
97 bSensor *copy_sensor(bSensor *sens)
98 {
99         bSensor *sensn;
100         
101         sensn= MEM_dupallocN(sens);
102         sensn->flag |= SENS_NEW;
103         if(sens->data) {
104                 sensn->data= MEM_dupallocN(sens->data);
105         }
106
107         if(sens->links) sensn->links= MEM_dupallocN(sens->links);
108         
109         return sensn;
110 }
111
112 void copy_sensors(ListBase *lbn, ListBase *lbo)
113 {
114         bSensor *sens, *sensn;
115         
116         lbn->first= lbn->last= 0;
117         sens= lbo->first;
118         while(sens) {
119                 sensn= copy_sensor(sens);
120                 BLI_addtail(lbn, sensn);
121                 sens= sens->next;
122         }
123 }
124
125 void init_sensor(bSensor *sens)
126 {
127         /* also use when sensor changes type */
128         bNearSensor *ns;
129         bMouseSensor *ms;
130         
131         if(sens->data) MEM_freeN(sens->data);
132         sens->data= NULL;
133         sens->pulse = 0;
134         
135         switch(sens->type) {
136         case SENS_ALWAYS:
137                 sens->pulse = 1;
138                 break;
139         case SENS_TOUCH:
140                 sens->data= MEM_callocN(sizeof(bTouchSensor), "touchsens");
141                 break;
142         case SENS_NEAR:
143                 ns=sens->data= MEM_callocN(sizeof(bNearSensor), "nearsens");
144                 ns->dist= 1.0;
145                 ns->resetdist= 2.0;
146                 break;
147         case SENS_KEYBOARD:
148                 sens->data= MEM_callocN(sizeof(bKeyboardSensor), "keysens");
149                 break;
150         case SENS_PROPERTY:
151                 sens->data= MEM_callocN(sizeof(bPropertySensor), "propsens");
152                 break;
153         case SENS_MOUSE:
154                 ms=sens->data= MEM_callocN(sizeof(bMouseSensor), "mousesens");
155                 ms->type= LEFTMOUSE;
156                 break;
157         case SENS_COLLISION:
158                 sens->data= MEM_callocN(sizeof(bCollisionSensor), "colsens");
159                 break;
160         case SENS_RADAR:
161                 sens->data= MEM_callocN(sizeof(bRadarSensor), "radarsens");
162                 break;
163         case SENS_RANDOM:
164                 sens->data= MEM_callocN(sizeof(bRandomSensor), "randomsens");
165                 break;
166         case SENS_RAY:
167                 sens->data= MEM_callocN(sizeof(bRaySensor), "raysens");
168                 break;
169         case SENS_MESSAGE:
170                 sens->data= MEM_callocN(sizeof(bMessageSensor), "messagesens");
171                 break;
172         case SENS_JOYSTICK:
173                 sens->data= MEM_callocN(sizeof(bJoystickSensor), "joysticksens");
174                 break;
175         default:
176                 ; /* this is very severe... I cannot make any memory for this        */
177                 /* logic brick...                                                    */
178         }
179 }
180
181 bSensor *new_sensor(int type)
182 {
183         bSensor *sens;
184
185         sens= MEM_callocN(sizeof(bSensor), "Sensor");
186         sens->type= type;
187         sens->flag= SENS_SHOW;
188         
189         init_sensor(sens);
190         
191         strcpy(sens->name, "sensor");
192         make_unique_prop_names(sens->name);
193         
194         return sens;
195 }
196
197 /* ******************* CONTROLLERS ************************ */
198
199 void unlink_controller(bController *cont)
200 {
201         bSensor *sens;
202         Object *ob;
203         int a, removed;
204         
205         /* check for controller pointers in sensors */
206         ob= G.main->object.first;
207         while(ob) {
208                 sens= ob->sensors.first;
209                 while(sens) {
210                         removed= 0;
211                         for(a=0; a<sens->totlinks; a++) {
212                                 if(removed) (sens->links)[a-1] = (sens->links)[a];
213                                 else if((sens->links)[a] == cont) removed= 1;
214                         }
215                         if(removed) {
216                                 sens->totlinks--;
217                                 
218                                 if(sens->totlinks==0) {
219                                         MEM_freeN(sens->links);
220                                         sens->links= NULL;
221                                 }
222                         }
223                         sens= sens->next;
224                 }
225                 ob= ob->id.next;
226         }
227 }
228
229 void unlink_controllers(ListBase *lb)
230 {
231         bController *cont;
232         
233         for (cont= lb->first; cont; cont= cont->next)
234                 unlink_controller(cont);        
235 }
236
237 void free_controller(bController *cont)
238 {
239         if(cont->links) MEM_freeN(cont->links);
240
241         /* the controller itself */
242         if(cont->data) MEM_freeN(cont->data);
243         MEM_freeN(cont);
244         
245 }
246
247 void free_controllers(ListBase *lb)
248 {
249         bController *cont;
250         
251         while((cont= lb->first)) {
252                 BLI_remlink(lb, cont);
253                 if(cont->slinks) MEM_freeN(cont->slinks);
254                 free_controller(cont);
255         }
256 }
257
258 bController *copy_controller(bController *cont)
259 {
260         bController *contn;
261         
262         cont->mynew=contn= MEM_dupallocN(cont);
263         contn->flag |= CONT_NEW;
264         if(cont->data) {
265                 contn->data= MEM_dupallocN(cont->data);
266         }
267
268         if(cont->links) contn->links= MEM_dupallocN(cont->links);
269         contn->slinks= NULL;
270         contn->totslinks= 0;
271         
272         return contn;
273 }
274
275 void copy_controllers(ListBase *lbn, ListBase *lbo)
276 {
277         bController *cont, *contn;
278         
279         lbn->first= lbn->last= 0;
280         cont= lbo->first;
281         while(cont) {
282                 contn= copy_controller(cont);
283                 BLI_addtail(lbn, contn);
284                 cont= cont->next;
285         }
286 }
287
288 void init_controller(bController *cont)
289 {
290         /* also use when controller changes type, leave actuators... */
291         
292         if(cont->data) MEM_freeN(cont->data);
293         cont->data= 0;
294         
295         switch(cont->type) {
296         case CONT_EXPRESSION:
297                 cont->data= MEM_callocN(sizeof(bExpressionCont), "expcont");
298                 break;
299         case CONT_PYTHON:
300                 cont->data= MEM_callocN(sizeof(bPythonCont), "pycont");
301                 break;
302         }
303 }
304
305 bController *new_controller(int type)
306 {
307         bController *cont;
308
309         cont= MEM_callocN(sizeof(bController), "Controller");
310         cont->type= type;
311         cont->flag= CONT_SHOW;
312
313         init_controller(cont);
314         
315         strcpy(cont->name, "cont");
316         make_unique_prop_names(cont->name);
317         
318         return cont;
319 }
320
321 /* ******************* ACTUATORS ************************ */
322
323 void unlink_actuator(bActuator *act)
324 {
325         bController *cont;
326         Object *ob;
327         int a, removed;
328         
329         /* check for actuator pointers in controllers */
330         ob= G.main->object.first;
331         while(ob) {
332                 cont= ob->controllers.first;
333                 while(cont) {
334                         removed= 0;
335                         for(a=0; a<cont->totlinks; a++) {
336                                 if(removed) (cont->links)[a-1] = (cont->links)[a];
337                                 else if((cont->links)[a] == act) removed= 1;
338                         }
339                         if(removed) {
340                                 cont->totlinks--;
341                                 
342                                 if(cont->totlinks==0) {
343                                         MEM_freeN(cont->links);
344                                         cont->links= NULL;
345                                 }
346                         }
347                         cont= cont->next;
348                 }
349                 ob= ob->id.next;
350         }
351 }
352
353 void unlink_actuators(ListBase *lb)
354 {
355         bActuator *act;
356         
357         for (act= lb->first; act; act= act->next)
358                 unlink_actuator(act);
359 }
360
361 void free_actuator(bActuator *act)
362 {
363         if(act->data) MEM_freeN(act->data);
364         MEM_freeN(act);
365 }
366
367 void free_actuators(ListBase *lb)
368 {
369         bActuator *act;
370         
371         while((act= lb->first)) {
372                 BLI_remlink(lb, act);
373                 free_actuator(act);
374         }
375 }
376
377 bActuator *copy_actuator(bActuator *act)
378 {
379         bActuator *actn;
380         
381         act->mynew=actn= MEM_dupallocN(act);
382         actn->flag |= ACT_NEW;
383         if(act->data) {
384                 actn->data= MEM_dupallocN(act->data);
385         }
386         
387         return actn;
388 }
389
390 void copy_actuators(ListBase *lbn, ListBase *lbo)
391 {
392         bActuator *act, *actn;
393         
394         lbn->first= lbn->last= 0;
395         act= lbo->first;
396         while(act) {
397                 actn= copy_actuator(act);
398                 BLI_addtail(lbn, actn);
399                 act= act->next;
400         }
401 }
402
403 void init_actuator(bActuator *act)
404 {
405         /* also use when actuator changes type */
406         bObjectActuator *oa;
407         
408         if(act->data) MEM_freeN(act->data);
409         act->data= 0;
410         
411         switch(act->type) {
412 #ifdef __NLA
413         case ACT_ACTION:
414         case ACT_SHAPEACTION:
415                 act->data= MEM_callocN(sizeof(bActionActuator), "actionact");
416                 break;
417 #endif
418         case ACT_SOUND:
419                 act->data= MEM_callocN(sizeof(bSoundActuator), "soundact");
420                 break;
421         case ACT_CD:
422                 act->data= MEM_callocN(sizeof(bCDActuator), "cdact");
423                 break;
424         case ACT_OBJECT:
425                 act->data= MEM_callocN(sizeof(bObjectActuator), "objectact");
426                 oa= act->data;
427                 oa->flag= 15;
428                 break;
429         case ACT_IPO:
430                 act->data= MEM_callocN(sizeof(bIpoActuator), "ipoact");
431                 break;
432         case ACT_PROPERTY:
433                 act->data= MEM_callocN(sizeof(bPropertyActuator), "propact");
434                 break;
435         case ACT_CAMERA:
436                 act->data= MEM_callocN(sizeof(bCameraActuator), "camact");
437                 break;
438         case ACT_EDIT_OBJECT:
439                 act->data= MEM_callocN(sizeof(bEditObjectActuator), "editobact");
440                 break;
441         case ACT_CONSTRAINT:
442                 act->data= MEM_callocN(sizeof(bConstraintActuator), "cons act");
443                 break;
444         case ACT_SCENE:
445                 act->data= MEM_callocN(sizeof(bSceneActuator), "scene act");
446                 break;
447         case ACT_GROUP:
448                 act->data= MEM_callocN(sizeof(bGroupActuator), "group act");
449                 break;
450         case ACT_RANDOM:
451                 act->data= MEM_callocN(sizeof(bRandomActuator), "random act");
452                 break;
453         case ACT_MESSAGE:
454                 act->data= MEM_callocN(sizeof(bMessageActuator), "message act");
455                 break;
456         case ACT_GAME:
457                 act->data= MEM_callocN(sizeof(bGameActuator), "game act");
458                 break;
459         case ACT_VISIBILITY:
460                 act->data= MEM_callocN(sizeof(bVisibilityActuator), "visibility act");
461                 break;
462     case ACT_2DFILTER:
463         act->data = MEM_callocN(sizeof( bTwoDFilterActuator ), "2d filter act");
464         break;
465     case ACT_PARENT:
466         act->data = MEM_callocN(sizeof( bParentActuator ), "parent act");
467         break;
468         default:
469                 ; /* this is very severe... I cannot make any memory for this        */
470                 /* logic brick...                                                    */
471         }
472 }
473
474 bActuator *new_actuator(int type)
475 {
476         bActuator *act;
477
478         act= MEM_callocN(sizeof(bActuator), "Actuator");
479         act->type= type;
480         act->flag= ACT_SHOW;
481         
482         init_actuator(act);
483         
484         strcpy(act->name, "act");
485         make_unique_prop_names(act->name);
486         
487         return act;
488 }
489
490 /* ******************** GENERAL ******************* */
491
492 void clear_sca_new_poins_ob(Object *ob)
493 {
494         bSensor *sens;
495         bController *cont;
496         bActuator *act;
497         
498         sens= ob->sensors.first;
499         while(sens) {
500                 sens->flag &= ~SENS_NEW;
501                 sens= sens->next;
502         }
503         cont= ob->controllers.first;
504         while(cont) {
505                 cont->mynew= NULL;
506                 cont->flag &= ~CONT_NEW;
507                 cont= cont->next;
508         }
509         act= ob->actuators.first;
510         while(act) {
511                 act->mynew= NULL;
512                 act->flag &= ~ACT_NEW;
513                 act= act->next;
514         }
515 }
516
517 void clear_sca_new_poins()
518 {
519         Object *ob;
520         
521         ob= G.main->object.first;
522         while(ob) {
523                 clear_sca_new_poins_ob(ob);
524                 ob= ob->id.next;        
525         }
526 }
527
528 void set_sca_new_poins_ob(Object *ob)
529 {
530         bSensor *sens;
531         bController *cont;
532         bActuator *act;
533         int a;
534         
535         sens= ob->sensors.first;
536         while(sens) {
537                 if(sens->flag & SENS_NEW) {
538                         for(a=0; a<sens->totlinks; a++) {
539                                 if(sens->links[a] && sens->links[a]->mynew)
540                                         sens->links[a]= sens->links[a]->mynew;
541                         }
542                 }
543                 sens= sens->next;
544         }
545
546         cont= ob->controllers.first;
547         while(cont) {
548                 if(cont->flag & CONT_NEW) {
549                         for(a=0; a<cont->totlinks; a++) {
550                                 if( cont->links[a] && cont->links[a]->mynew)
551                                         cont->links[a]= cont->links[a]->mynew;
552                         }
553                 }
554                 cont= cont->next;
555         }
556         
557         
558         act= ob->actuators.first;
559         while(act) {
560                 if(act->flag & ACT_NEW) {
561                         if(act->type==ACT_EDIT_OBJECT) {
562                                 bEditObjectActuator *eoa= act->data;
563                                 ID_NEW(eoa->ob);
564                         }
565                         else if(act->type==ACT_SCENE) {
566                                 bSceneActuator *sca= act->data;
567                                 ID_NEW(sca->camera);
568                         }
569                         else if(act->type==ACT_CAMERA) {
570                                 bCameraActuator *ca= act->data;
571                                 ID_NEW(ca->ob);
572                         }
573                         else if(act->type==ACT_SCENE) {
574                                 bSceneActuator *sca= act->data;
575                                 ID_NEW(sca->camera);
576                         }
577                 }
578                 act= act->next;
579         }
580 }
581
582
583 void set_sca_new_poins()
584 {
585         Object *ob;
586         
587         ob= G.main->object.first;
588         while(ob) {
589                 set_sca_new_poins_ob(ob);
590                 ob= ob->id.next;        
591         }
592 }
593
594 void sca_remove_ob_poin(Object *obt, Object *ob)
595 {
596         bSensor *sens;
597         bMessageSensor *ms;
598         bActuator *act;
599         bCameraActuator *ca;
600         bSceneActuator *sa;
601         bEditObjectActuator *eoa;
602         bPropertyActuator *pa;
603         bMessageActuator *ma;
604
605         sens= obt->sensors.first;
606         while(sens) {
607                 switch(sens->type) {
608                 case SENS_MESSAGE:
609                         ms= sens->data;
610                         if(ms->fromObject==ob) ms->fromObject= NULL;
611                 }
612                 sens= sens->next;
613         }
614
615         act= obt->actuators.first;
616         while(act) {
617                 switch(act->type) {
618                 case ACT_CAMERA:
619                         ca= act->data;
620                         if(ca->ob==ob) ca->ob= NULL;
621                         break;
622                 case ACT_PROPERTY:
623                         pa= act->data;
624                         if(pa->ob==ob) pa->ob= NULL;
625                         break;
626                 case ACT_SCENE:
627                         sa= act->data;
628                         if(sa->camera==ob) sa->camera= NULL;
629                         break;
630                 case ACT_EDIT_OBJECT:
631                         eoa= act->data;
632                         if(eoa->ob==ob) eoa->ob= NULL;
633                         break;
634                 case ACT_MESSAGE:
635                         ma= act->data;
636                         if(ma->toObject==ob) ma->toObject= NULL;
637                         break;
638
639                 }
640                 act= act->next;
641         }       
642 }