diff options
Diffstat (limited to 'source/blender/editors/space_logic/logic_ops.c')
-rw-r--r-- | source/blender/editors/space_logic/logic_ops.c | 697 |
1 files changed, 697 insertions, 0 deletions
diff --git a/source/blender/editors/space_logic/logic_ops.c b/source/blender/editors/space_logic/logic_ops.c new file mode 100644 index 00000000000..2a179ac281c --- /dev/null +++ b/source/blender/editors/space_logic/logic_ops.c @@ -0,0 +1,697 @@ +/** + * $Id$ + * + * ***** 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) 2009 Blender Foundation. + * All rights reserved. + * + * + * Contributor(s): Blender Foundation + * + * ***** END GPL LICENSE BLOCK ***** + */ +#include <stddef.h> + +#include "DNA_object_types.h" +#include "DNA_scene_types.h" +#include "DNA_sensor_types.h" +#include "DNA_controller_types.h" +#include "DNA_actuator_types.h" + +#include "BLI_blenlib.h" + +#include "BKE_context.h" +#include "BKE_main.h" +#include "BKE_sca.h" + +#include "ED_object.h" +#include "ED_screen.h" + +#include "RNA_access.h" +#include "RNA_define.h" +#include "RNA_enum_types.h" + +#include "WM_api.h" +#include "WM_types.h" + +#include "logic_intern.h" + +/* ************* Generic Operator Helpers ************* */ + +static int edit_sensor_poll(bContext *C) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor); + + if (ptr.data && ((ID*)ptr.id.data)->lib) return 0; + return 1; +} + +static int edit_controller_poll(bContext *C) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller); + + if (ptr.data && ((ID*)ptr.id.data)->lib) return 0; + return 1; +} + +static int edit_actuator_poll(bContext *C) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator); + + if (ptr.data && ((ID*)ptr.id.data)->lib) return 0; + return 1; +} + +static void edit_sensor_properties(wmOperatorType *ot) +{ + RNA_def_string(ot->srna, "sensor", "", 32, "Sensor", "Name of the sensor to edit"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the sensor belongs to"); +} + +static int edit_sensor_invoke_properties(bContext *C, wmOperator *op) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor); + + if (RNA_property_is_set(op->ptr, "sensor") && RNA_property_is_set(op->ptr, "object") ) + return 1; + + if (ptr.data) { + bSensor *sens = ptr.data; + Object *ob = ptr.id.data; + + RNA_string_set(op->ptr, "sensor", sens->name); + RNA_string_set(op->ptr, "object", ob->id.name+2); + return 1; + } + + return 0; +} + +static Object *edit_object_property_get(bContext *C, wmOperator *op) +{ + char ob_name[32]; + Object *ob; + + RNA_string_get(op->ptr, "object", ob_name); + + /* if ob_name is valid try to find the object with this name + otherwise gets the active object */ + if (BLI_strnlen(ob_name, 32) > 0) + ob = BLI_findstring(&(CTX_data_main(C)->object), ob_name, offsetof(ID, name) + 2); + else + ob= ED_object_active_context(C); + + return ob; +} + +static bSensor *edit_sensor_property_get(bContext *C, wmOperator *op, Object **ob) +{ + char sensor_name[32]; + bSensor *sens; + + RNA_string_get(op->ptr, "sensor", sensor_name); + + *ob= edit_object_property_get(C, op); + if (!*ob) return NULL; + + sens = BLI_findstring(&((*ob)->sensors), sensor_name, offsetof(bSensor, name)); + return sens; +} + +static void edit_controller_properties(wmOperatorType *ot) +{ + RNA_def_string(ot->srna, "controller", "", 32, "Controller", "Name of the controller to edit"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the controller belongs to"); +} + +static int edit_controller_invoke_properties(bContext *C, wmOperator *op) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller); + + if (RNA_property_is_set(op->ptr, "controller") && RNA_property_is_set(op->ptr, "object") ) + return 1; + + if (ptr.data) { + bController *cont = ptr.data; + Object *ob = ptr.id.data; + + RNA_string_set(op->ptr, "controller", cont->name); + RNA_string_set(op->ptr, "object", ob->id.name+2); + return 1; + } + + return 0; +} + +static bController *edit_controller_property_get(bContext *C, wmOperator *op, Object **ob) +{ + char controller_name[32]; + bController *cont; + + RNA_string_get(op->ptr, "controller", controller_name); + + *ob= edit_object_property_get(C, op); + if (!*ob) return NULL; + + cont = BLI_findstring(&((*ob)->controllers), controller_name, offsetof(bController, name)); + return cont; +} + +static void edit_actuator_properties(wmOperatorType *ot) +{ + RNA_def_string(ot->srna, "actuator", "", 32, "Actuator", "Name of the actuator to edit"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the object the actuator belongs to"); +} + +static int edit_actuator_invoke_properties(bContext *C, wmOperator *op) +{ + PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator); + + if (RNA_property_is_set(op->ptr, "actuator") && RNA_property_is_set(op->ptr, "object") ) + return 1; + + if (ptr.data) { + bActuator *act = ptr.data; + Object *ob = ptr.id.data; + + RNA_string_set(op->ptr, "actuator",act->name); + RNA_string_set(op->ptr, "object", ob->id.name+2); + return 1; + } + + return 0; +} + +static bActuator *edit_actuator_property_get(bContext *C, wmOperator *op, Object **ob) +{ + char actuator_name[32]; + bActuator *act; + + RNA_string_get(op->ptr, "actuator", actuator_name); + + *ob= edit_object_property_get(C, op); + if (!*ob) return NULL; + + act = BLI_findstring(&((*ob)->actuators), actuator_name, offsetof(bActuator, name)); + return act; +} + +static int logicbricks_move_property_get(wmOperator *op) +{ + int type = RNA_enum_get(op->ptr, "direction"); + + if (type == 1) + return TRUE; + else + return FALSE; +} + +/* ************* Add/Remove Sensor Operator ************* */ + +static int sensor_remove_exec(bContext *C, wmOperator *op) +{ + Object *ob=NULL; + bSensor *sens = edit_sensor_property_get(C, op, &ob); + + if (!sens) + return OPERATOR_CANCELLED; + + BLI_remlink(&(ob->sensors), sens); + free_sensor(sens); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + + static int sensor_remove_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_sensor_invoke_properties(C, op)) + return sensor_remove_exec(C, op); + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_sensor_remove(wmOperatorType *ot) +{ + ot->name= "Remove Sensor"; + ot->description= "Remove a sensor from the active object"; + ot->idname= "LOGIC_OT_sensor_remove"; + + ot->invoke= sensor_remove_invoke; + ot->exec= sensor_remove_exec; + ot->poll= edit_sensor_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + edit_sensor_properties(ot); +} + +static int sensor_add_exec(bContext *C, wmOperator *op) +{ + Object *ob; + bSensor *sens; + PointerRNA sens_ptr; + PropertyRNA *prop; + const char *sens_name; + char name[32]; + int type= RNA_enum_get(op->ptr, "type"); + + ob= edit_object_property_get(C, op); + if (!ob) + return OPERATOR_CANCELLED; + + sens= new_sensor(type); + BLI_addtail(&(ob->sensors), sens); + + /* set the sensor name based on rna type enum */ + RNA_pointer_create((ID *)ob, &RNA_Sensor, sens, &sens_ptr); + prop = RNA_struct_find_property(&sens_ptr, "type"); + + RNA_string_get(op->ptr, "name", name); + if(BLI_strnlen(name, 32) < 1){ + RNA_property_enum_name(C, &sens_ptr, prop, RNA_property_enum_get(&sens_ptr, prop), &sens_name); + BLI_strncpy(sens->name, sens_name, sizeof(sens->name)); + } + else + BLI_strncpy(sens->name, name, sizeof(sens->name)); + + make_unique_prop_names(C, sens->name); + ob->scaflag |= OB_SHOWSENS; + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +void LOGIC_OT_sensor_add(wmOperatorType *ot) +{ + PropertyRNA *prop; + + /* identifiers */ + ot->name= "Add Sensor"; + ot->description = "Add a sensor to the active object"; + ot->idname= "LOGIC_OT_sensor_add"; + + /* api callbacks */ + ot->invoke= WM_menu_invoke; + ot->exec= sensor_add_exec; + ot->poll= ED_operator_object_active_editable; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, SENS_ALWAYS, "Type", "Type of sensor to add"); + RNA_def_enum_funcs(prop, rna_Sensor_type_itemf); + RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Sensor to add"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Sensor to"); +} + +/* ************* Add/Remove Controller Operator ************* */ + +static int controller_remove_exec(bContext *C, wmOperator *op) +{ + Object *ob = NULL; + bController *cont = edit_controller_property_get(C, op, &ob); + + if (!cont) + return OPERATOR_CANCELLED; + + BLI_remlink(&(ob->controllers), cont); + unlink_controller(cont); + free_controller(cont); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + + static int controller_remove_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_controller_invoke_properties(C, op)) + return controller_remove_exec(C, op); + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_controller_remove(wmOperatorType *ot) +{ + ot->name= "Remove Controller"; + ot->description= "Remove a controller from the active object"; + ot->idname= "LOGIC_OT_controller_remove"; + + ot->invoke= controller_remove_invoke; + ot->exec= controller_remove_exec; + ot->poll= edit_controller_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + edit_controller_properties(ot); +} + +static int controller_add_exec(bContext *C, wmOperator *op) +{ + Object *ob; + bController *cont; + PointerRNA cont_ptr; + PropertyRNA *prop; + const char *cont_name; + int bit; + char name[32]; + int type= RNA_enum_get(op->ptr, "type"); + + ob= edit_object_property_get(C, op); + if(!ob) + return OPERATOR_CANCELLED; + + cont= new_controller(type); + BLI_addtail(&(ob->controllers), cont); + + /* set the controller name based on rna type enum */ + RNA_pointer_create((ID *)ob, &RNA_Controller, cont, &cont_ptr); + prop = RNA_struct_find_property(&cont_ptr, "type"); + + RNA_string_get(op->ptr, "name", name); + if(BLI_strnlen(name, 32) < 1){ + RNA_property_enum_name(C, &cont_ptr, prop, RNA_property_enum_get(&cont_ptr, prop), &cont_name); + BLI_strncpy(cont->name, cont_name, sizeof(cont->name)); + } + else + BLI_strncpy(cont->name, name, sizeof(cont->name)); + + make_unique_prop_names(C, cont->name); + /* set the controller state mask from the current object state. + A controller is always in a single state, so select the lowest bit set + from the object state */ + for (bit=0; bit<OB_MAX_STATES; bit++) { + if (ob->state & (1<<bit)) + break; + } + cont->state_mask = (1<<bit); + if (cont->state_mask == 0) { + /* shouldn't happen, object state is never 0 */ + cont->state_mask = 1; + } + + ob->scaflag |= OB_SHOWCONT; + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +void LOGIC_OT_controller_add(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Add Controller"; + ot->description = "Add a controller to the active object"; + ot->idname= "LOGIC_OT_controller_add"; + + /* api callbacks */ + ot->invoke= WM_menu_invoke; + ot->exec= controller_add_exec; + ot->poll= ED_operator_object_active_editable; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + RNA_def_enum(ot->srna, "type", controller_type_items, CONT_LOGIC_AND, "Type", "Type of controller to add"); + RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Controller to add"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Controller to"); +} + +/* ************* Add/Remove Actuator Operator ************* */ + +static int actuator_remove_exec(bContext *C, wmOperator *op) +{ + Object *ob=NULL; + bActuator *act = edit_actuator_property_get(C, op, &ob); + + if (!act) + return OPERATOR_CANCELLED; + + BLI_remlink(&(ob->actuators), act); + unlink_actuator(act); + free_actuator(act); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +static int actuator_remove_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_actuator_invoke_properties(C, op)) + return actuator_remove_exec(C, op); + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_actuator_remove(wmOperatorType *ot) +{ + ot->name= "Remove Actuator"; + ot->description= "Remove a actuator from the active object"; + ot->idname= "LOGIC_OT_actuator_remove"; + + ot->invoke= actuator_remove_invoke; + ot->exec= actuator_remove_exec; + ot->poll= edit_actuator_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + edit_actuator_properties(ot); +} + +static int actuator_add_exec(bContext *C, wmOperator *op) +{ + Object *ob; + bActuator *act; + PointerRNA act_ptr; + PropertyRNA *prop; + const char *act_name; + char name[32]; + int type= RNA_enum_get(op->ptr, "type"); + + ob= edit_object_property_get(C, op); + if(!ob) + return OPERATOR_CANCELLED; + + act= new_actuator(type); + BLI_addtail(&(ob->actuators), act); + + /* set the actuator name based on rna type enum */ + RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &act_ptr); + prop = RNA_struct_find_property(&act_ptr, "type"); + + RNA_string_get(op->ptr, "name", name); + if (BLI_strnlen(name, 32) < 1){ + RNA_property_enum_name(C, &act_ptr, prop, RNA_property_enum_get(&act_ptr, prop), &act_name); + BLI_strncpy(act->name, act_name, sizeof(act->name)); + } + else + BLI_strncpy(act->name, name, sizeof(act->name)); + + make_unique_prop_names(C, act->name); + ob->scaflag |= OB_SHOWACT; + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +void LOGIC_OT_actuator_add(wmOperatorType *ot) +{ + PropertyRNA *prop; + + /* identifiers */ + ot->name= "Add Actuator"; + ot->description = "Add a actuator to the active object"; + ot->idname= "LOGIC_OT_actuator_add"; + + /* api callbacks */ + ot->invoke= WM_menu_invoke; + ot->exec= actuator_add_exec; + ot->poll= ED_operator_object_active_editable; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, CONT_LOGIC_AND, "Type", "Type of actuator to add"); + RNA_def_enum_funcs(prop, rna_Actuator_type_itemf); + RNA_def_string(ot->srna, "name", "", 32, "Name", "Name of the Actuator to add"); + RNA_def_string(ot->srna, "object", "", 32, "Object", "Name of the Object to add the Actuator to"); +} + +/* ************* Move Logic Bricks Operator ************* */ +static EnumPropertyItem logicbricks_move_direction[] ={ + {1, "UP", 0, "Move Up", ""}, + {2, "DOWN", 0, "Move Down", ""}, + {0, NULL, 0, NULL, NULL}}; + + +static int sensor_move_exec(bContext *C, wmOperator *op) +{ + Object *ob=NULL; + bSensor *sens= edit_sensor_property_get(C, op, &ob); + int move_up= logicbricks_move_property_get(op); + + if (!sens) + return OPERATOR_CANCELLED; + + sca_move_sensor(sens, ob, move_up); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +static int sensor_move_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_sensor_invoke_properties(C, op)) { + return sensor_move_exec(C, op); + } + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_sensor_move(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Move Sensor"; + ot->description = "Move Densor"; + ot->idname= "LOGIC_OT_sensor_move"; + + /* api callbacks */ + ot->invoke= sensor_move_invoke; + ot->exec= sensor_move_exec; + ot->poll= edit_sensor_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + edit_sensor_properties(ot); + RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down"); +} + +static int controller_move_exec(bContext *C, wmOperator *op) +{ + Object *ob=NULL; + bController *cont= edit_controller_property_get(C, op, &ob); + int move_up= logicbricks_move_property_get(op); + + if (!cont) + return OPERATOR_CANCELLED; + + sca_move_controller(cont, ob, move_up); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +static int controller_move_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_controller_invoke_properties(C, op)) { + return controller_move_exec(C, op); + } + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_controller_move(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Move Controller"; + ot->description = "Move Controller"; + ot->idname= "LOGIC_OT_controller_move"; + + /* api callbacks */ + ot->invoke= controller_move_invoke; + ot->exec= controller_move_exec; + ot->poll= edit_controller_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + edit_controller_properties(ot); + RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down"); +} + +static int actuator_move_exec(bContext *C, wmOperator *op) +{ + Object *ob=NULL; + bActuator *act = edit_actuator_property_get(C, op, &ob); + int move_up= logicbricks_move_property_get(op); + + if (!act) + return OPERATOR_CANCELLED; + + sca_move_actuator(act, ob, move_up); + + WM_event_add_notifier(C, NC_LOGIC, NULL); + + return OPERATOR_FINISHED; +} + +static int actuator_move_invoke(bContext *C, wmOperator *op, wmEvent *event) +{ + if (edit_actuator_invoke_properties(C, op)) { + return actuator_move_exec(C, op); + } + else + return OPERATOR_CANCELLED; +} + +void LOGIC_OT_actuator_move(wmOperatorType *ot) +{ + /* identifiers */ + ot->name= "Move Actuator"; + ot->description = "Move Actuator"; + ot->idname= "LOGIC_OT_actuator_move"; + + /* api callbacks */ + ot->invoke= actuator_move_invoke; + ot->exec= actuator_move_exec; + ot->poll= edit_actuator_poll; + + /* flags */ + ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO; + + /* properties */ + edit_actuator_properties(ot); + RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down"); +} + + +void ED_operatortypes_logic(void) +{ + WM_operatortype_append(LOGIC_OT_sensor_remove); + WM_operatortype_append(LOGIC_OT_sensor_add); + WM_operatortype_append(LOGIC_OT_sensor_move); + WM_operatortype_append(LOGIC_OT_controller_remove); + WM_operatortype_append(LOGIC_OT_controller_add); + WM_operatortype_append(LOGIC_OT_controller_move); + WM_operatortype_append(LOGIC_OT_actuator_remove); + WM_operatortype_append(LOGIC_OT_actuator_add); + WM_operatortype_append(LOGIC_OT_actuator_move); +} |