sca.c

Go to the documentation of this file.

/*
 * $Id: sca.c 37455 2011-06-13 17:08:33Z dfelinto $
 *
 * ***** BEGIN GPL 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.
 *
 * 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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 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 <float.h>

#include "MEM_guardedalloc.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_utildefines.h"
#include "BKE_global.h"
#include "BKE_main.h"
#include "BKE_library.h"
#include "BKE_sca.h"

/* ******************* 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= NULL;
        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;
        bJoystickSensor *js;
        bRaySensor *rs;
        
        if(sens->data) MEM_freeN(sens->data);
        sens->data= NULL;
        sens->pulse = 0;
        
        switch(sens->type) {
        case SENS_ALWAYS:
                sens->pulse = 0;
                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_ARMATURE:
                sens->data= MEM_callocN(sizeof(bArmatureSensor), "armsens");
                break;
        case SENS_ACTUATOR:
                sens->data= MEM_callocN(sizeof(bActuatorSensor), "actsens");
                break;
        case SENS_DELAY:
                sens->data= MEM_callocN(sizeof(bDelaySensor), "delaysens");
                break;
        case SENS_MOUSE:
                ms=sens->data= MEM_callocN(sizeof(bMouseSensor), "mousesens");
                ms->type= 1; // LEFTMOUSE workaround because Mouse Sensor types enum starts in 1
                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");
                rs = sens->data;
                rs->range = 0.01f;
                break;
        case SENS_MESSAGE:
                sens->data= MEM_callocN(sizeof(bMessageSensor), "messagesens");
                break;
        case SENS_JOYSTICK:
                sens->data= MEM_callocN(sizeof(bJoystickSensor), "joysticksens");
                js= sens->data;
                js->hatf = SENS_JOY_HAT_UP;
                js->axis = 1;
                js->hat = 1;
                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");
// XXX  make_unique_prop_names(sens->name);
        
        return sens;
}

/* ******************* CONTROLLERS ************************ */

void unlink_controller(bController *cont)
{
        bSensor *sens;
        Object *ob;
        
        /* check for controller pointers in sensors */
        ob= G.main->object.first;
        while(ob) {
                sens= ob->sensors.first;
                while(sens) {
                        unlink_logicbricks((void **)&cont, (void ***)&(sens->links), &sens->totlinks);
                        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= NULL;
        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= NULL;
        
        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");
// XXX  make_unique_prop_names(cont->name);
        
        return cont;
}

/* ******************* ACTUATORS ************************ */

void unlink_actuator(bActuator *act)
{
        bController *cont;
        Object *ob;
        
        /* check for actuator pointers in controllers */
        ob= G.main->object.first;
        while(ob) {
                cont= ob->controllers.first;
                while(cont) {
                        unlink_logicbricks((void **)&act, (void ***)&(cont->links), &cont->totlinks);
                        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)
{
        bSoundActuator *sa;

        if(act->data) {
                switch (act->type) {
                case ACT_SOUND:
                        sa = (bSoundActuator *) act->data;
                        if(sa->sound)
                                id_us_min((ID *) sa->sound);
                        break;
                }

                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;
        bSoundActuator *sa;
        
        act->mynew=actn= MEM_dupallocN(act);
        actn->flag |= ACT_NEW;
        if(act->data) {
                actn->data= MEM_dupallocN(act->data);
        }
        
        switch (act->type) {
                case ACT_SOUND:
                        sa= (bSoundActuator *)act->data;
                        if(sa->sound)
                                id_us_plus((ID *) sa->sound);
                        break;
        }
        return actn;
}

void copy_actuators(ListBase *lbn, ListBase *lbo)
{
        bActuator *act, *actn;
        
        lbn->first= lbn->last= NULL;
        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 */
        bCameraActuator *ca;
        bObjectActuator *oa;
        bRandomActuator *ra;
        bSoundActuator *sa;
        
        if(act->data) MEM_freeN(act->data);
        act->data= NULL;
        
        switch(act->type) {
        case ACT_ACTION:
        case ACT_SHAPEACTION:
                act->data= MEM_callocN(sizeof(bActionActuator), "actionact");
                break;
        case ACT_SOUND:
                sa = act->data= MEM_callocN(sizeof(bSoundActuator), "soundact");
                sa->volume = 1.0f;
                sa->sound3D.rolloff_factor = 1.0f;
                sa->sound3D.reference_distance = 1.0f;
                sa->sound3D.max_gain = 1.0f;
                sa->sound3D.cone_inner_angle = 360.0f;
                sa->sound3D.cone_outer_angle = 360.0f;
                sa->sound3D.max_distance = FLT_MAX;
                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");
                ca = act->data;
                ca->axis = ACT_CAMERA_X;
                ca->damping = 1.0/32.0;
                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");
                ra=act->data;
                ra->float_arg_1 = 0.1f;
                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;
        case ACT_2DFILTER:
                act->data = MEM_callocN(sizeof( bTwoDFilterActuator ), "2d filter act");
                break;
        case ACT_PARENT:
                act->data = MEM_callocN(sizeof( bParentActuator ), "parent act");
                break;
        case ACT_STATE:
                act->data = MEM_callocN(sizeof( bStateActuator ), "state act");
                break;
        case ACT_ARMATURE:
                act->data = MEM_callocN(sizeof( bArmatureActuator ), "armature 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");
// XXX  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(void)
{
        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_OBJECT) {
                                bObjectActuator *oa= act->data;
                                ID_NEW(oa->reference);
                        }
                        else if(act->type==ACT_MESSAGE) {
                                bMessageActuator *ma= act->data;
                                ID_NEW(ma->toObject);
                        }
                        else if(act->type==ACT_PARENT) {
                                bParentActuator *para = act->data;
                                ID_NEW(para->ob);
                        }
                        else if(act->type==ACT_ARMATURE) {
                                bArmatureActuator *aa = act->data;
                                ID_NEW(aa->target);
                                ID_NEW(aa->subtarget);
                        }
                        else if(act->type==ACT_PROPERTY) {
                                bPropertyActuator *pa= act->data;
                                ID_NEW(pa->ob);
                        }
                }
                act= act->next;
        }
}


void set_sca_new_poins(void)
{
        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;
        bObjectActuator *oa;
        bSceneActuator *sa;
        bEditObjectActuator *eoa;
        bPropertyActuator *pa;
        bMessageActuator *ma;
        bParentActuator *para;
        bArmatureActuator *aa;

        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_OBJECT:
                        oa= act->data;
                        if(oa->reference==ob) oa->reference= 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;
                case ACT_PARENT:
                        para = act->data;
                        if (para->ob==ob) para->ob = NULL;
                        break;
                case ACT_ARMATURE:
                        aa = act->data;
                        if (aa->target == ob) aa->target = NULL;
                        if (aa->subtarget == ob) aa->subtarget = NULL;
                        break;
                }
                act= act->next;
        }       
}

/* ******************** INTERFACE ******************* */
void sca_move_sensor(bSensor *sens_to_move, Object *ob, int move_up)
{
        bSensor *sens, *tmp;

        int val;
        val = move_up ? 1:2;

        /* make sure this sensor belongs to this object */
        sens= ob->sensors.first;
        while(sens) {
                if(sens == sens_to_move) break;
                sens= sens->next;
        }
        if(!sens) return;

        /* move up */
        if( val==1 && sens->prev) {
                for (tmp=sens->prev; tmp; tmp=tmp->prev) {
                        if (tmp->flag & SENS_VISIBLE)
                                break;
                }
                if (tmp) {
                        BLI_remlink(&ob->sensors, sens);
                        BLI_insertlinkbefore(&ob->sensors, tmp, sens);
                }
        }
        /* move down */
        else if( val==2 && sens->next) {
                for (tmp=sens->next; tmp; tmp=tmp->next) {
                        if (tmp->flag & SENS_VISIBLE)
                                break;
                }
                if (tmp) {
                        BLI_remlink(&ob->sensors, sens);
                        BLI_insertlink(&ob->sensors, tmp, sens);
                }
        }
}

void sca_move_controller(bController *cont_to_move, Object *ob, int move_up)
{
        bController *cont, *tmp;

        int val;
        val = move_up ? 1:2;

        /* make sure this controller belongs to this object */
        cont= ob->controllers.first;
        while(cont) {
                if(cont == cont_to_move) break;
                cont= cont->next;
        }
        if(!cont) return;

        /* move up */
        if( val==1 && cont->prev) {
                /* locate the controller that has the same state mask but is earlier in the list */
                tmp = cont->prev;
                while(tmp) {
                        if(tmp->state_mask & cont->state_mask) 
                                break;
                        tmp = tmp->prev;
                }
                if (tmp) {
                        BLI_remlink(&ob->controllers, cont);
                        BLI_insertlinkbefore(&ob->controllers, tmp, cont);
                }
        }

        /* move down */
        else if( val==2 && cont->next) {
                tmp = cont->next;
                while(tmp) {
                        if(tmp->state_mask & cont->state_mask) 
                                break;
                        tmp = tmp->next;
                }
                BLI_remlink(&ob->controllers, cont);
                BLI_insertlink(&ob->controllers, tmp, cont);
        }
}

void sca_move_actuator(bActuator *act_to_move, Object *ob, int move_up)
{
        bActuator *act, *tmp;
        int val;

        val = move_up ? 1:2;

        /* make sure this actuator belongs to this object */
        act= ob->actuators.first;
        while(act) {
                if(act == act_to_move) break;
                act= act->next;
        }
        if(!act) return;

        /* move up */
        if( val==1 && act->prev) {
                /* locate the first visible actuators before this one */
                for (tmp = act->prev; tmp; tmp=tmp->prev) {
                        if (tmp->flag & ACT_VISIBLE)
                                break;
                }
                if (tmp) {
                        BLI_remlink(&ob->actuators, act);
                        BLI_insertlinkbefore(&ob->actuators, tmp, act);
                }
        }
        /* move down */
        else if( val==2 && act->next) {
                /* locate the first visible actuators after this one */
                for (tmp=act->next; tmp; tmp=tmp->next) {
                        if (tmp->flag & ACT_VISIBLE)
                                break;
                }
                if (tmp) {
                        BLI_remlink(&ob->actuators, act);
                        BLI_insertlink(&ob->actuators, tmp, act);
                }
        }
}

void link_logicbricks(void **poin, void ***ppoin, short *tot, short size)
{
        void **old_links= NULL;
        
        int ibrick;

        /* check if the bricks are already linked */
        for (ibrick=0; ibrick < *tot; ibrick++) {
                if ((*ppoin)[ibrick] == *poin)
                        return;
        }

        if (*ppoin) {
                old_links= *ppoin;

                (*tot) ++;
                *ppoin = MEM_callocN((*tot)*size, "new link");
        
                for (ibrick=0; ibrick < *(tot) - 1; ibrick++) {
                        (*ppoin)[ibrick] = old_links[ibrick];
                }
                (*ppoin)[ibrick] = *poin;

                if(old_links) MEM_freeN(old_links);
        }
        else {
                (*tot) = 1;
                *ppoin = MEM_callocN((*tot)*size, "new link");
                (*ppoin)[0] = *poin;
        }
}

void unlink_logicbricks(void **poin, void ***ppoin, short *tot)
{
        int ibrick, removed;

        removed= 0;
        for (ibrick=0; ibrick < *tot; ibrick++) {
                if(removed) (*ppoin)[ibrick - removed] = (*ppoin)[ibrick];
                else if((*ppoin)[ibrick] == *poin) removed = 1;
        }

        if (removed) {
                (*tot) --;

                if(*tot == 0) {
                        MEM_freeN(*ppoin);
                        (*ppoin)= NULL;
                }
                return;
        }
}