b0f5e786eefe23591b3b15dd03f17e0a89b76e77
[blender.git] / source / blender / editors / space_logic / logic_ops.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version. 
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2009 Blender Foundation.
19  * All rights reserved.
20  *
21  * 
22  * Contributor(s): Blender Foundation
23  *
24  * ***** END GPL LICENSE BLOCK *****
25  */
26
27 /** \file blender/editors/space_logic/logic_ops.c
28  *  \ingroup splogic
29  */
30
31 #include <stddef.h>
32
33 #include "DNA_object_types.h"
34 #include "DNA_sensor_types.h"
35 #include "DNA_controller_types.h"
36 #include "DNA_actuator_types.h"
37
38 #include "BLI_blenlib.h"
39 #include "BLI_utildefines.h"
40
41 #include "BKE_context.h"
42 #include "BKE_main.h"
43 #include "BKE_sca.h"
44 #include "BKE_material.h" //for texface convert
45
46 #include "ED_logic.h"
47 #include "ED_object.h"
48 #include "ED_screen.h"
49
50 #include "RNA_access.h"
51 #include "RNA_define.h"
52 #include "RNA_enum_types.h"
53
54 #include "WM_api.h"
55 #include "WM_types.h"
56
57 #include "logic_intern.h"
58
59 // temporary new includes for texface functions
60 #include "DNA_mesh_types.h"
61 #include "DNA_material_types.h"
62 #include "DNA_meshdata_types.h"
63
64 /* ************* Generic Operator Helpers ************* */
65 static int edit_sensor_poll(bContext *C)
66 {
67         PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
68
69         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
70         return 1;
71 }
72
73 static int edit_controller_poll(bContext *C)
74 {
75         PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
76
77         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
78         return 1;
79 }
80
81 static int edit_actuator_poll(bContext *C)
82 {
83         PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
84
85         if (ptr.data && ((ID*)ptr.id.data)->lib) return 0;
86         return 1;
87 }
88
89 static void edit_sensor_properties(wmOperatorType *ot)
90 {
91         RNA_def_string(ot->srna, "sensor", "", MAX_NAME, "Sensor", "Name of the sensor to edit");
92         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the object the sensor belongs to");
93 }
94
95 static int edit_sensor_invoke_properties(bContext *C, wmOperator *op)
96 {
97         PointerRNA ptr= CTX_data_pointer_get_type(C, "sensor", &RNA_Sensor);
98         
99         if (RNA_property_is_set(op->ptr, "sensor") && RNA_property_is_set(op->ptr, "object") )
100                 return 1;
101         
102         if (ptr.data) {
103                 bSensor *sens = ptr.data;
104                 Object *ob = ptr.id.data;
105                 
106                 RNA_string_set(op->ptr, "sensor", sens->name);
107                 RNA_string_set(op->ptr, "object", ob->id.name+2);
108                 return 1;
109         }
110         
111         return 0;
112 }
113
114 static Object *edit_object_property_get(bContext *C, wmOperator *op)
115 {
116         char ob_name[MAX_NAME];
117         Object *ob;
118
119         RNA_string_get(op->ptr, "object", ob_name);
120
121         /* if ob_name is valid try to find the object with this name
122         otherwise gets the active object */
123         if (BLI_strnlen(ob_name, MAX_NAME) > 0)
124                 ob = BLI_findstring(&(CTX_data_main(C)->object), ob_name, offsetof(ID, name) + 2);
125         else
126                 ob= ED_object_active_context(C);
127
128         return ob;
129 }
130
131 static bSensor *edit_sensor_property_get(bContext *C, wmOperator *op, Object **ob)
132 {
133         char sensor_name[MAX_NAME];
134         bSensor *sens;
135         
136         RNA_string_get(op->ptr, "sensor", sensor_name);
137
138         *ob= edit_object_property_get(C, op);
139         if (!*ob) return NULL;
140         
141         sens = BLI_findstring(&((*ob)->sensors), sensor_name, offsetof(bSensor, name)); 
142         return sens;
143 }
144
145 static void edit_controller_properties(wmOperatorType *ot)
146 {
147         RNA_def_string(ot->srna, "controller", "", MAX_NAME, "Controller", "Name of the controller to edit");
148         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the object the controller belongs to");
149 }
150
151 static int edit_controller_invoke_properties(bContext *C, wmOperator *op)
152 {
153         PointerRNA ptr= CTX_data_pointer_get_type(C, "controller", &RNA_Controller);
154         
155         if (RNA_property_is_set(op->ptr, "controller") && RNA_property_is_set(op->ptr, "object") )
156                 return 1;
157         
158         if (ptr.data) {
159                 bController *cont = ptr.data;
160                 Object *ob = ptr.id.data;
161                 
162                 RNA_string_set(op->ptr, "controller", cont->name);
163                 RNA_string_set(op->ptr, "object", ob->id.name+2);
164                 return 1;
165         }
166         
167         return 0;
168 }
169
170 static bController *edit_controller_property_get(bContext *C, wmOperator *op, Object **ob)
171 {
172         char controller_name[MAX_NAME];
173         bController *cont;
174         
175         RNA_string_get(op->ptr, "controller", controller_name);
176
177         *ob= edit_object_property_get(C, op);
178         if (!*ob) return NULL;
179         
180         cont = BLI_findstring(&((*ob)->controllers), controller_name, offsetof(bController, name));     
181         return cont;
182 }
183
184 static void edit_actuator_properties(wmOperatorType *ot)
185 {
186         RNA_def_string(ot->srna, "actuator", "", MAX_NAME, "Actuator", "Name of the actuator to edit");
187         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the object the actuator belongs to");
188 }
189
190 static int edit_actuator_invoke_properties(bContext *C, wmOperator *op)
191 {
192         PointerRNA ptr= CTX_data_pointer_get_type(C, "actuator", &RNA_Actuator);
193         
194         if (RNA_property_is_set(op->ptr, "actuator") && RNA_property_is_set(op->ptr, "object") )
195                 return 1;
196         
197         if (ptr.data) {
198                 bActuator *act = ptr.data;
199                 Object *ob = ptr.id.data;
200                 
201                 RNA_string_set(op->ptr, "actuator",act->name);
202                 RNA_string_set(op->ptr, "object", ob->id.name+2);
203                 return 1;
204         }
205         
206         return 0;
207 }
208
209 static bActuator *edit_actuator_property_get(bContext *C, wmOperator *op, Object **ob)
210 {
211         char actuator_name[MAX_NAME];
212         bActuator *act;
213         
214         RNA_string_get(op->ptr, "actuator", actuator_name);
215
216         *ob= edit_object_property_get(C, op);
217         if (!*ob) return NULL;
218         
219         act = BLI_findstring(&((*ob)->actuators), actuator_name, offsetof(bActuator, name));    
220         return act;
221 }
222
223 static int logicbricks_move_property_get(wmOperator *op)
224 {
225         int type = RNA_enum_get(op->ptr, "direction");
226
227         if (type == 1)
228                 return TRUE;
229         else
230                 return FALSE;
231 }
232
233 /* ************* Add/Remove Sensor Operator ************* */
234
235 static int sensor_remove_exec(bContext *C, wmOperator *op)
236 {
237         Object *ob=NULL;
238         bSensor *sens = edit_sensor_property_get(C, op, &ob);
239         
240         if (!sens)
241                 return OPERATOR_CANCELLED;
242         
243         BLI_remlink(&(ob->sensors), sens);
244         free_sensor(sens);
245         
246         WM_event_add_notifier(C, NC_LOGIC, NULL);
247         
248         return OPERATOR_FINISHED;
249 }
250
251  static int sensor_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
252 {
253         if (edit_sensor_invoke_properties(C, op))
254                 return sensor_remove_exec(C, op);
255         else
256                 return OPERATOR_CANCELLED;
257 }
258
259 static void LOGIC_OT_sensor_remove(wmOperatorType *ot)
260 {
261         ot->name= "Remove Sensor";
262         ot->description= "Remove a sensor from the active object";
263         ot->idname= "LOGIC_OT_sensor_remove";
264         
265         ot->invoke= sensor_remove_invoke;
266         ot->exec= sensor_remove_exec;
267         ot->poll= edit_sensor_poll;
268         
269         /* flags */
270         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
271         edit_sensor_properties(ot);
272 }
273
274 static int sensor_add_exec(bContext *C, wmOperator *op)
275 {
276         Object *ob;
277         bSensor *sens;
278         PointerRNA sens_ptr;
279         PropertyRNA *prop;
280         const char *sens_name;
281         char name[MAX_NAME];
282         int type= RNA_enum_get(op->ptr, "type");
283
284         ob= edit_object_property_get(C, op);
285         if (!ob)
286                 return OPERATOR_CANCELLED;
287
288         sens= new_sensor(type);
289         BLI_addtail(&(ob->sensors), sens);
290         
291         /* set the sensor name based on rna type enum */
292         RNA_pointer_create((ID *)ob, &RNA_Sensor, sens, &sens_ptr);
293         prop = RNA_struct_find_property(&sens_ptr, "type");
294
295         RNA_string_get(op->ptr, "name", name);
296         if(BLI_strnlen(name, MAX_NAME) < 1){
297                 RNA_property_enum_name(C, &sens_ptr, prop, RNA_property_enum_get(&sens_ptr, prop), &sens_name);
298                 BLI_strncpy(sens->name, sens_name, sizeof(sens->name));
299         }
300         else
301                 BLI_strncpy(sens->name, name, sizeof(sens->name));
302
303         make_unique_prop_names(C, sens->name);
304         ob->scaflag |= OB_SHOWSENS;
305
306         WM_event_add_notifier(C, NC_LOGIC, NULL);
307         
308         return OPERATOR_FINISHED;
309 }
310
311 static void LOGIC_OT_sensor_add(wmOperatorType *ot)
312 {
313         PropertyRNA *prop;
314         
315         /* identifiers */
316         ot->name= "Add Sensor";
317         ot->description = "Add a sensor to the active object";
318         ot->idname= "LOGIC_OT_sensor_add";
319         
320         /* api callbacks */
321         ot->invoke= WM_menu_invoke;
322         ot->exec= sensor_add_exec;
323         ot->poll= ED_operator_object_active_editable;
324         
325         /* flags */
326         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
327         
328         /* properties */
329         ot->prop= prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, SENS_ALWAYS, "Type", "Type of sensor to add");
330         RNA_def_enum_funcs(prop, rna_Sensor_type_itemf);
331         RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Name of the Sensor to add");
332         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the Object to add the Sensor to");
333 }
334
335 /* ************* Add/Remove Controller Operator ************* */
336
337 static int controller_remove_exec(bContext *C, wmOperator *op)
338 {
339         Object *ob = NULL;
340         bController *cont = edit_controller_property_get(C, op, &ob);
341         
342         if (!cont)
343                 return OPERATOR_CANCELLED;
344         
345         BLI_remlink(&(ob->controllers), cont);
346         unlink_controller(cont);
347         free_controller(cont);
348         
349         WM_event_add_notifier(C, NC_LOGIC, NULL);
350         
351         return OPERATOR_FINISHED;
352 }
353
354  static int controller_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
355 {
356         if (edit_controller_invoke_properties(C, op))
357                 return controller_remove_exec(C, op);
358         else
359                 return OPERATOR_CANCELLED;
360 }
361
362 static void LOGIC_OT_controller_remove(wmOperatorType *ot)
363 {
364         ot->name= "Remove Controller";
365         ot->description= "Remove a controller from the active object";
366         ot->idname= "LOGIC_OT_controller_remove";
367         
368         ot->invoke= controller_remove_invoke;
369         ot->exec= controller_remove_exec;
370         ot->poll= edit_controller_poll;
371         
372         /* flags */
373         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
374         edit_controller_properties(ot);
375 }
376
377 static int controller_add_exec(bContext *C, wmOperator *op)
378 {
379         Object *ob;
380         bController *cont;
381         PointerRNA cont_ptr;
382         PropertyRNA *prop;
383         const char *cont_name;
384         int bit;
385         char name[MAX_NAME];
386         int type= RNA_enum_get(op->ptr, "type");
387
388         ob= edit_object_property_get(C, op);
389         if(!ob)
390                 return OPERATOR_CANCELLED;
391         
392         cont= new_controller(type);
393         BLI_addtail(&(ob->controllers), cont);
394         
395         /* set the controller name based on rna type enum */
396         RNA_pointer_create((ID *)ob, &RNA_Controller, cont, &cont_ptr);
397         prop = RNA_struct_find_property(&cont_ptr, "type");
398
399         RNA_string_get(op->ptr, "name", name);
400         if(BLI_strnlen(name, MAX_NAME) < 1){
401                 RNA_property_enum_name(C, &cont_ptr, prop, RNA_property_enum_get(&cont_ptr, prop), &cont_name);
402                 BLI_strncpy(cont->name, cont_name, sizeof(cont->name));
403         }
404         else
405                 BLI_strncpy(cont->name, name, sizeof(cont->name));
406
407         make_unique_prop_names(C, cont->name);
408         /* set the controller state mask from the current object state.
409          A controller is always in a single state, so select the lowest bit set
410          from the object state */
411         for (bit=0; bit<OB_MAX_STATES; bit++) {
412                 if (ob->state & (1<<bit))
413                         break;
414         }
415         cont->state_mask = (1<<bit);
416         if (cont->state_mask == 0) {
417                 /* shouldn't happen, object state is never 0 */
418                 cont->state_mask = 1;
419         }
420         
421         ob->scaflag |= OB_SHOWCONT;
422         
423         WM_event_add_notifier(C, NC_LOGIC, NULL);
424         
425         return OPERATOR_FINISHED;
426 }
427
428 static void LOGIC_OT_controller_add(wmOperatorType *ot)
429 {
430         /* identifiers */
431         ot->name= "Add Controller";
432         ot->description = "Add a controller to the active object";
433         ot->idname= "LOGIC_OT_controller_add";
434         
435         /* api callbacks */
436         ot->invoke= WM_menu_invoke;
437         ot->exec= controller_add_exec;
438         ot->poll= ED_operator_object_active_editable;
439         
440         /* flags */
441         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
442         
443         /* properties */
444         ot->prop= RNA_def_enum(ot->srna, "type", controller_type_items, CONT_LOGIC_AND, "Type", "Type of controller to add");
445         RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Name of the Controller to add");
446         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the Object to add the Controller to");
447 }
448
449 /* ************* Add/Remove Actuator Operator ************* */
450
451 static int actuator_remove_exec(bContext *C, wmOperator *op)
452 {
453         Object *ob=NULL;
454         bActuator *act = edit_actuator_property_get(C, op, &ob);
455         
456         if (!act)
457                 return OPERATOR_CANCELLED;
458         
459         BLI_remlink(&(ob->actuators), act);
460         unlink_actuator(act);
461         free_actuator(act);
462         
463         WM_event_add_notifier(C, NC_LOGIC, NULL);
464         
465         return OPERATOR_FINISHED;
466 }
467
468 static int actuator_remove_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
469 {
470         if (edit_actuator_invoke_properties(C, op))
471                 return actuator_remove_exec(C, op);
472         else
473                 return OPERATOR_CANCELLED;
474 }
475
476 static void LOGIC_OT_actuator_remove(wmOperatorType *ot)
477 {
478         ot->name= "Remove Actuator";
479         ot->description= "Remove an actuator from the active object";
480         ot->idname= "LOGIC_OT_actuator_remove";
481         
482         ot->invoke= actuator_remove_invoke;
483         ot->exec= actuator_remove_exec;
484         ot->poll= edit_actuator_poll;
485         
486         /* flags */
487         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
488         edit_actuator_properties(ot);
489 }
490
491 static int actuator_add_exec(bContext *C, wmOperator *op)
492 {
493         Object *ob;
494         bActuator *act;
495         PointerRNA act_ptr;
496         PropertyRNA *prop;
497         const char *act_name;
498         char  name[MAX_NAME];
499         int type= RNA_enum_get(op->ptr, "type");
500                 
501         ob= edit_object_property_get(C, op);
502         if(!ob)
503                 return OPERATOR_CANCELLED;
504
505         act= new_actuator(type);
506         BLI_addtail(&(ob->actuators), act);
507         
508         /* set the actuator name based on rna type enum */
509         RNA_pointer_create((ID *)ob, &RNA_Actuator, act, &act_ptr);
510         prop = RNA_struct_find_property(&act_ptr, "type");
511
512         RNA_string_get(op->ptr, "name", name);
513         if (BLI_strnlen(name, MAX_NAME) < 1){
514                 RNA_property_enum_name(C, &act_ptr, prop, RNA_property_enum_get(&act_ptr, prop), &act_name);
515                 BLI_strncpy(act->name, act_name, sizeof(act->name));
516         }
517         else
518                 BLI_strncpy(act->name, name, sizeof(act->name));
519
520         make_unique_prop_names(C, act->name);
521         ob->scaflag |= OB_SHOWACT;
522         
523         WM_event_add_notifier(C, NC_LOGIC, NULL);
524         
525         return OPERATOR_FINISHED;
526 }
527
528 static void LOGIC_OT_actuator_add(wmOperatorType *ot)
529 {
530         PropertyRNA *prop;
531         
532         /* identifiers */
533         ot->name= "Add Actuator";
534         ot->description = "Add an actuator to the active object";
535         ot->idname= "LOGIC_OT_actuator_add";
536         
537         /* api callbacks */
538         ot->invoke= WM_menu_invoke;
539         ot->exec= actuator_add_exec;
540         ot->poll= ED_operator_object_active_editable;
541         
542         /* flags */
543         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
544         
545         /* properties */
546         ot->prop= prop= RNA_def_enum(ot->srna, "type", DummyRNA_NULL_items, CONT_LOGIC_AND, "Type", "Type of actuator to add");
547         RNA_def_enum_funcs(prop, rna_Actuator_type_itemf);
548         RNA_def_string(ot->srna, "name", "", MAX_NAME, "Name", "Name of the Actuator to add");
549         RNA_def_string(ot->srna, "object", "", MAX_NAME, "Object", "Name of the Object to add the Actuator to");
550 }
551
552 /* ************* Move Logic Bricks Operator ************* */
553 static EnumPropertyItem logicbricks_move_direction[] ={
554                 {1, "UP", 0, "Move Up", ""},
555                 {2, "DOWN", 0, "Move Down", ""},
556                 {0, NULL, 0, NULL, NULL}};
557
558
559 static int sensor_move_exec(bContext *C, wmOperator *op)
560 {
561         Object *ob=NULL;
562         bSensor *sens= edit_sensor_property_get(C, op, &ob);
563         int move_up= logicbricks_move_property_get(op);
564         
565         if (!sens)
566                 return OPERATOR_CANCELLED;
567
568         sca_move_sensor(sens, ob, move_up);
569
570         WM_event_add_notifier(C, NC_LOGIC, NULL);
571         
572         return OPERATOR_FINISHED;
573 }
574
575 static int sensor_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
576 {
577         if (edit_sensor_invoke_properties(C, op)) {
578                 return sensor_move_exec(C, op);
579         }
580         else
581                 return OPERATOR_CANCELLED;
582 }
583
584 static void LOGIC_OT_sensor_move(wmOperatorType *ot)
585 {
586         /* identifiers */
587         ot->name= "Move Sensor";
588         ot->description = "Move Sensor";
589         ot->idname= "LOGIC_OT_sensor_move";
590         
591         /* api callbacks */
592         ot->invoke= sensor_move_invoke;
593         ot->exec= sensor_move_exec;
594         ot->poll= edit_sensor_poll;
595         
596         /* flags */
597         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
598         
599         /* properties */
600         edit_sensor_properties(ot);
601         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
602 }
603
604 static int controller_move_exec(bContext *C, wmOperator *op)
605 {
606         Object *ob=NULL;
607         bController *cont= edit_controller_property_get(C, op, &ob);
608         int move_up= logicbricks_move_property_get(op);
609         
610         if (!cont)
611                 return OPERATOR_CANCELLED;
612
613         sca_move_controller(cont, ob, move_up);
614
615         WM_event_add_notifier(C, NC_LOGIC, NULL);
616         
617         return OPERATOR_FINISHED;
618 }
619
620 static int controller_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
621 {
622         if (edit_controller_invoke_properties(C, op)) {
623                 return controller_move_exec(C, op);
624         }
625         else
626                 return OPERATOR_CANCELLED;
627 }
628
629 static void LOGIC_OT_controller_move(wmOperatorType *ot)
630 {
631         /* identifiers */
632         ot->name= "Move Controller";
633         ot->description = "Move Controller";
634         ot->idname= "LOGIC_OT_controller_move";
635         
636         /* api callbacks */
637         ot->invoke= controller_move_invoke;
638         ot->exec= controller_move_exec;
639         ot->poll= edit_controller_poll;
640         
641         /* flags */
642         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
643         
644         /* properties */
645         edit_controller_properties(ot);
646         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
647 }
648
649 static int actuator_move_exec(bContext *C, wmOperator *op)
650 {
651         Object *ob=NULL;
652         bActuator *act = edit_actuator_property_get(C, op, &ob);
653         int move_up= logicbricks_move_property_get(op);
654
655         if (!act)
656                 return OPERATOR_CANCELLED;
657
658         sca_move_actuator(act, ob, move_up);
659
660         WM_event_add_notifier(C, NC_LOGIC, NULL);
661         
662         return OPERATOR_FINISHED;
663 }
664
665 static int actuator_move_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
666 {
667         if (edit_actuator_invoke_properties(C, op)) {
668                 return actuator_move_exec(C, op);
669         }
670         else
671                 return OPERATOR_CANCELLED;
672 }
673
674 static void LOGIC_OT_actuator_move(wmOperatorType *ot)
675 {
676         /* identifiers */
677         ot->name= "Move Actuator";
678         ot->description = "Move Actuator";
679         ot->idname= "LOGIC_OT_actuator_move";
680         
681         /* api callbacks */
682         ot->invoke= actuator_move_invoke;
683         ot->exec= actuator_move_exec;
684         ot->poll= edit_actuator_poll;
685         
686         /* flags */
687         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
688         
689         /* properties */
690         edit_actuator_properties(ot);
691         RNA_def_enum(ot->srna, "direction", logicbricks_move_direction, 1, "Direction", "Move Up or Down");
692 }
693
694 /* ************* TexFace Converter Operator ************* */
695 static int texface_convert_exec(bContext *C, wmOperator *UNUSED(op))
696 {
697         Main *bmain= CTX_data_main(C);
698         do_version_tface(bmain, 0);
699         
700         return OPERATOR_FINISHED;
701 }
702
703 static int texface_convert_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
704 {
705         return texface_convert_exec(C, op);
706 }
707
708  static void LOGIC_OT_texface_convert(wmOperatorType *ot)
709 {
710         /* identifiers */
711         ot->name= "TexFace to Material Converter";
712         ot->description = "Convert old texface settings into material. It may create new materials if needed";
713         ot->idname= "LOGIC_OT_texface_convert";
714
715         /* api callbacks */
716         ot->invoke= texface_convert_invoke;
717         ot->exec= texface_convert_exec;
718 //      ot->poll= texface_convert_poll;
719  
720         /* flags */
721         ot->flag= OPTYPE_REGISTER|OPTYPE_UNDO;
722 }
723
724
725 void ED_operatortypes_logic(void)
726 {
727         WM_operatortype_append(LOGIC_OT_sensor_remove);
728         WM_operatortype_append(LOGIC_OT_sensor_add);
729         WM_operatortype_append(LOGIC_OT_sensor_move);
730         WM_operatortype_append(LOGIC_OT_controller_remove);
731         WM_operatortype_append(LOGIC_OT_controller_add);
732         WM_operatortype_append(LOGIC_OT_controller_move);
733         WM_operatortype_append(LOGIC_OT_actuator_remove);
734         WM_operatortype_append(LOGIC_OT_actuator_add);
735         WM_operatortype_append(LOGIC_OT_actuator_move);
736         WM_operatortype_append(LOGIC_OT_texface_convert);
737 }