diff options
Diffstat (limited to 'source/blender/blenkernel/intern/sca.c')
| -rw-r--r-- | source/blender/blenkernel/intern/sca.c | 631 |
1 files changed, 631 insertions, 0 deletions
diff --git a/source/blender/blenkernel/intern/sca.c b/source/blender/blenkernel/intern/sca.c new file mode 100644 index 00000000000..a105b240942 --- /dev/null +++ b/source/blender/blenkernel/intern/sca.c @@ -0,0 +1,631 @@ +/** + * $Id$ + * + * ***** BEGIN GPL/BL DUAL LICENSE BLOCK ***** + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. The Blender + * Foundation also sells licenses for use in proprietary software under + * the Blender License. See http://www.blender.org/BL/ for information + * about this. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software Foundation, + * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + * + * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV. + * All rights reserved. + * + * The Original Code is: all of this file. + * + * Contributor(s): none yet. + * + * ***** END GPL/BL DUAL LICENSE BLOCK ***** + * these all are linked to objects (listbase) + * all data is 'direct data', not Blender lib data. + */ + +#include <stdio.h> +#include <string.h> +#include "MEM_guardedalloc.h" + +#include "nla.h" /* For __NLA: Important, do not remove */ +#include "DNA_text_types.h" +#include "DNA_controller_types.h" +#include "DNA_sensor_types.h" +#include "DNA_actuator_types.h" +#include "DNA_object_types.h" + +#include "BLI_blenlib.h" +#include "BKE_bad_level_calls.h" +#include "BKE_utildefines.h" +#include "BKE_global.h" +#include "BKE_main.h" +#include "BKE_blender.h" +#include "BKE_sca.h" + +void free_text_controllers(Text *txt) +{ + Object *ob; + bController *cont; + + ob= G.main->object.first; + while(ob) { + cont= ob->controllers.first; + while(cont) { + if(cont->type==CONT_PYTHON) { + bPythonCont *pc; + + pc= cont->data; + if(pc->text==txt) pc->text= NULL; + } + cont= cont->next; + } + ob= ob->id.next; + } +} + + +/* ******************* SENSORS ************************ */ + +void free_sensor(bSensor *sens) +{ + if(sens->links) MEM_freeN(sens->links); + if(sens->data) MEM_freeN(sens->data); + MEM_freeN(sens); + +} + +void free_sensors(ListBase *lb) +{ + bSensor *sens; + + while((sens= lb->first)) { + BLI_remlink(lb, sens); + free_sensor(sens); + } +} + +bSensor *copy_sensor(bSensor *sens) +{ + bSensor *sensn; + + sensn= MEM_dupallocN(sens); + sensn->flag |= SENS_NEW; + if(sens->data) { + sensn->data= MEM_dupallocN(sens->data); + } + + if(sens->links) sensn->links= MEM_dupallocN(sens->links); + + return sensn; +} + +void copy_sensors(ListBase *lbn, ListBase *lbo) +{ + bSensor *sens, *sensn; + + lbn->first= lbn->last= 0; + sens= lbo->first; + while(sens) { + sensn= copy_sensor(sens); + BLI_addtail(lbn, sensn); + sens= sens->next; + } +} + +void init_sensor(bSensor *sens) +{ + /* also use when sensor changes type */ + bNearSensor *ns; + bMouseSensor *ms; + + if(sens->data) MEM_freeN(sens->data); + sens->data= NULL; + sens->pulse = 0; + + switch(sens->type) { + case SENS_ALWAYS: + sens->pulse = 1; + break; + case SENS_TOUCH: + sens->data= MEM_callocN(sizeof(bTouchSensor), "touchsens"); + break; + case SENS_NEAR: + ns=sens->data= MEM_callocN(sizeof(bNearSensor), "nearsens"); + ns->dist= 1.0; + ns->resetdist= 2.0; + break; + case SENS_KEYBOARD: + sens->data= MEM_callocN(sizeof(bKeyboardSensor), "keysens"); + break; + case SENS_PROPERTY: + sens->data= MEM_callocN(sizeof(bPropertySensor), "propsens"); + break; + case SENS_MOUSE: + ms=sens->data= MEM_callocN(sizeof(bMouseSensor), "mousesens"); + ms->type= LEFTMOUSE; + break; + case SENS_COLLISION: + sens->data= MEM_callocN(sizeof(bCollisionSensor), "colsens"); + break; + case SENS_RADAR: + sens->data= MEM_callocN(sizeof(bRadarSensor), "radarsens"); + break; + case SENS_RANDOM: + sens->data= MEM_callocN(sizeof(bRandomSensor), "randomsens"); + break; + case SENS_RAY: + sens->data= MEM_callocN(sizeof(bRaySensor), "raysens"); + break; + case SENS_MESSAGE: + sens->data= MEM_callocN(sizeof(bMessageSensor), "messagesens"); + break; + default: + ; /* this is very severe... I cannot make any memory for this */ + /* logic brick... */ + } +} + +bSensor *new_sensor(int type) +{ + bSensor *sens; + + sens= MEM_callocN(sizeof(bSensor), "Sensor"); + sens->type= type; + sens->flag= SENS_SHOW; + + init_sensor(sens); + + strcpy(sens->name, "sensor"); + make_unique_prop_names(sens->name); + + return sens; +} + +/* ******************* CONTROLLERS ************************ */ + +void unlink_controller(bController *cont) +{ + bSensor *sens; + Object *ob; + int a, removed; + + /* check for controller pointers in sensors */ + ob= G.main->object.first; + while(ob) { + sens= ob->sensors.first; + while(sens) { + removed= 0; + for(a=0; a<sens->totlinks; a++) { + if(removed) (sens->links)[a-1] = (sens->links)[a]; + else if((sens->links)[a] == cont) removed= 1; + } + if(removed) { + sens->totlinks--; + + if(sens->totlinks==0) { + MEM_freeN(sens->links); + sens->links= NULL; + } + } + sens= sens->next; + } + ob= ob->id.next; + } +} + +void unlink_controllers(ListBase *lb) +{ + bController *cont; + + for (cont= lb->first; cont; cont= cont->next) + unlink_controller(cont); +} + +void free_controller(bController *cont) +{ + if(cont->links) MEM_freeN(cont->links); + + /* the controller itself */ + if(cont->data) MEM_freeN(cont->data); + MEM_freeN(cont); + +} + +void free_controllers(ListBase *lb) +{ + bController *cont; + + while((cont= lb->first)) { + BLI_remlink(lb, cont); + if(cont->slinks) MEM_freeN(cont->slinks); + free_controller(cont); + } +} + +bController *copy_controller(bController *cont) +{ + bController *contn; + + cont->mynew=contn= MEM_dupallocN(cont); + contn->flag |= CONT_NEW; + if(cont->data) { + contn->data= MEM_dupallocN(cont->data); + } + + if(cont->links) contn->links= MEM_dupallocN(cont->links); + contn->slinks= NULL; + contn->totslinks= 0; + + return contn; +} + +void copy_controllers(ListBase *lbn, ListBase *lbo) +{ + bController *cont, *contn; + + lbn->first= lbn->last= 0; + cont= lbo->first; + while(cont) { + contn= copy_controller(cont); + BLI_addtail(lbn, contn); + cont= cont->next; + } +} + +void init_controller(bController *cont) +{ + /* also use when controller changes type, leave actuators... */ + + if(cont->data) MEM_freeN(cont->data); + cont->data= 0; + + switch(cont->type) { + case CONT_EXPRESSION: + cont->data= MEM_callocN(sizeof(bExpressionCont), "expcont"); + break; + case CONT_PYTHON: + cont->data= MEM_callocN(sizeof(bPythonCont), "pycont"); + break; + } +} + +bController *new_controller(int type) +{ + bController *cont; + + cont= MEM_callocN(sizeof(bController), "Controller"); + cont->type= type; + cont->flag= CONT_SHOW; + + init_controller(cont); + + strcpy(cont->name, "cont"); + make_unique_prop_names(cont->name); + + return cont; +} + +/* ******************* ACTUATORS ************************ */ + +void unlink_actuator(bActuator *act) +{ + bController *cont; + Object *ob; + int a, removed; + + /* check for actuator pointers in controllers */ + ob= G.main->object.first; + while(ob) { + cont= ob->controllers.first; + while(cont) { + removed= 0; + for(a=0; a<cont->totlinks; a++) { + if(removed) (cont->links)[a-1] = (cont->links)[a]; + else if((cont->links)[a] == act) removed= 1; + } + if(removed) { + cont->totlinks--; + + if(cont->totlinks==0) { + MEM_freeN(cont->links); + cont->links= NULL; + } + } + cont= cont->next; + } + ob= ob->id.next; + } +} + +void unlink_actuators(ListBase *lb) +{ + bActuator *act; + + for (act= lb->first; act; act= act->next) + unlink_actuator(act); +} + +void free_actuator(bActuator *act) +{ + if(act->data) MEM_freeN(act->data); + MEM_freeN(act); +} + +void free_actuators(ListBase *lb) +{ + bActuator *act; + + while((act= lb->first)) { + BLI_remlink(lb, act); + free_actuator(act); + } +} + +bActuator *copy_actuator(bActuator *act) +{ + bActuator *actn; + + act->mynew=actn= MEM_dupallocN(act); + actn->flag |= ACT_NEW; + if(act->data) { + actn->data= MEM_dupallocN(act->data); + } + + return actn; +} + +void copy_actuators(ListBase *lbn, ListBase *lbo) +{ + bActuator *act, *actn; + + lbn->first= lbn->last= 0; + act= lbo->first; + while(act) { + actn= copy_actuator(act); + BLI_addtail(lbn, actn); + act= act->next; + } +} + +void init_actuator(bActuator *act) +{ + /* also use when actuator changes type */ + bObjectActuator *oa; + + if(act->data) MEM_freeN(act->data); + act->data= 0; + + switch(act->type) { +#ifdef __NLA + case ACT_ACTION: + act->data= MEM_callocN(sizeof(bActionActuator), "actionact"); + break; +#endif + case ACT_SOUND: + act->data= MEM_callocN(sizeof(bSoundActuator), "soundact"); + break; + case ACT_CD: + act->data= MEM_callocN(sizeof(bCDActuator), "cdact"); + break; + case ACT_OBJECT: + act->data= MEM_callocN(sizeof(bObjectActuator), "objectact"); + oa= act->data; + oa->flag= 15; + break; + case ACT_IPO: + act->data= MEM_callocN(sizeof(bIpoActuator), "ipoact"); + break; + case ACT_PROPERTY: + act->data= MEM_callocN(sizeof(bPropertyActuator), "propact"); + break; + case ACT_CAMERA: + act->data= MEM_callocN(sizeof(bCameraActuator), "camact"); + break; + case ACT_EDIT_OBJECT: + act->data= MEM_callocN(sizeof(bEditObjectActuator), "editobact"); + break; + case ACT_CONSTRAINT: + act->data= MEM_callocN(sizeof(bConstraintActuator), "cons act"); + break; + case ACT_SCENE: + act->data= MEM_callocN(sizeof(bSceneActuator), "scene act"); + break; + case ACT_GROUP: + act->data= MEM_callocN(sizeof(bGroupActuator), "group act"); + break; + case ACT_RANDOM: + act->data= MEM_callocN(sizeof(bRandomActuator), "random act"); + break; + case ACT_MESSAGE: + act->data= MEM_callocN(sizeof(bMessageActuator), "message act"); + break; + case ACT_GAME: + act->data= MEM_callocN(sizeof(bGameActuator), "game act"); + break; + case ACT_VISIBILITY: + act->data= MEM_callocN(sizeof(bVisibilityActuator), "visibility act"); + break; + default: + ; /* this is very severe... I cannot make any memory for this */ + /* logic brick... */ + } +} + +bActuator *new_actuator(int type) +{ + bActuator *act; + + act= MEM_callocN(sizeof(bActuator), "Actuator"); + act->type= type; + act->flag= ACT_SHOW; + + init_actuator(act); + + strcpy(act->name, "act"); + make_unique_prop_names(act->name); + + return act; +} + +/* ******************** GENERAL ******************* */ + +void clear_sca_new_poins_ob(Object *ob) +{ + bSensor *sens; + bController *cont; + bActuator *act; + + sens= ob->sensors.first; + while(sens) { + sens->flag &= ~SENS_NEW; + sens= sens->next; + } + cont= ob->controllers.first; + while(cont) { + cont->mynew= NULL; + cont->flag &= ~CONT_NEW; + cont= cont->next; + } + act= ob->actuators.first; + while(act) { + act->mynew= NULL; + act->flag &= ~ACT_NEW; + act= act->next; + } +} + +void clear_sca_new_poins() +{ + Object *ob; + + ob= G.main->object.first; + while(ob) { + clear_sca_new_poins_ob(ob); + ob= ob->id.next; + } +} + +void set_sca_new_poins_ob(Object *ob) +{ + bSensor *sens; + bController *cont; + bActuator *act; + int a; + + sens= ob->sensors.first; + while(sens) { + if(sens->flag & SENS_NEW) { + for(a=0; a<sens->totlinks; a++) { + if(sens->links[a] && sens->links[a]->mynew) + sens->links[a]= sens->links[a]->mynew; + } + } + sens= sens->next; + } + + cont= ob->controllers.first; + while(cont) { + if(cont->flag & CONT_NEW) { + for(a=0; a<cont->totlinks; a++) { + if( cont->links[a] && cont->links[a]->mynew) + cont->links[a]= cont->links[a]->mynew; + } + } + cont= cont->next; + } + + + act= ob->actuators.first; + while(act) { + if(act->flag & ACT_NEW) { + if(act->type==ACT_EDIT_OBJECT) { + bEditObjectActuator *eoa= act->data; + ID_NEW(eoa->ob); + } + else if(act->type==ACT_SCENE) { + bSceneActuator *sca= act->data; + ID_NEW(sca->camera); + } + else if(act->type==ACT_CAMERA) { + bCameraActuator *ca= act->data; + ID_NEW(ca->ob); + } + else if(act->type==ACT_SCENE) { + bSceneActuator *sca= act->data; + ID_NEW(sca->camera); + } + } + act= act->next; + } +} + + +void set_sca_new_poins() +{ + Object *ob; + + ob= G.main->object.first; + while(ob) { + set_sca_new_poins_ob(ob); + ob= ob->id.next; + } +} + +void sca_remove_ob_poin(Object *obt, Object *ob) +{ + bSensor *sens; + bMessageSensor *ms; + bActuator *act; + bCameraActuator *ca; + bSceneActuator *sa; + bEditObjectActuator *eoa; + bPropertyActuator *pa; + bMessageActuator *ma; + + sens= obt->sensors.first; + while(sens) { + switch(sens->type) { + case SENS_MESSAGE: + ms= sens->data; + if(ms->fromObject==ob) ms->fromObject= NULL; + } + sens= sens->next; + } + + act= obt->actuators.first; + while(act) { + switch(act->type) { + case ACT_CAMERA: + ca= act->data; + if(ca->ob==ob) ca->ob= NULL; + break; + case ACT_PROPERTY: + pa= act->data; + if(pa->ob==ob) pa->ob= NULL; + break; + case ACT_SCENE: + sa= act->data; + if(sa->camera==ob) sa->camera= NULL; + break; + case ACT_EDIT_OBJECT: + eoa= act->data; + if(eoa->ob==ob) eoa->ob= NULL; + break; + case ACT_MESSAGE: + ma= act->data; + if(ma->toObject==ob) ma->toObject= NULL; + break; + + } + act= act->next; + } +} |