clone and stencil layer access added, renamed mask to stencil layer internally
[blender.git] / source / blender / makesrna / intern / rna_boid.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) 2009 by Janne Karhu.
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  */
29
30 #include <float.h>
31 #include <limits.h>
32 #include <stdlib.h>
33
34 #include "RNA_define.h"
35 #include "RNA_types.h"
36
37 #include "rna_internal.h"
38
39 #include "DNA_scene_types.h"
40 #include "DNA_boid_types.h"
41 #include "DNA_object_types.h"
42 #include "DNA_particle_types.h"
43
44 #include "WM_api.h"
45 #include "WM_types.h"
46
47 EnumPropertyItem boidrule_type_items[] ={
48         {eBoidRuleType_Goal, "GOAL", 0, "Goal", "Go to assigned object or loudest assigned signal source."},
49         {eBoidRuleType_Avoid, "AVOID", 0, "Avoid", "Get away from assigned object or loudest assigned signal source."},
50         {eBoidRuleType_AvoidCollision, "AVOID_COLLISION", 0, "Avoid Collision", "Monoeuver to avoid collisions with other boids and deflector objects in near future."},
51         {eBoidRuleType_Separate, "SEPARATE", 0, "Separate", "Keep from going through other boids."},
52         {eBoidRuleType_Flock, "FLOCK", 0, "Flock", "Move to center of neighbors and match their velocity."},
53         {eBoidRuleType_FollowLeader, "FOLLOW_LEADER", 0, "Follow Leader", "Follow a boid or assigned object."},
54         {eBoidRuleType_AverageSpeed, "AVERAGE_SPEED", 0, "Average Speed", "Maintain speed, flight level or wander."},
55         {eBoidRuleType_Fight, "FIGHT", 0, "Fight", "Go to closest enemy and attack when in range."},
56         //{eBoidRuleType_Protect, "PROTECT", 0, "Protect", "Go to enemy closest to target and attack when in range."},
57         //{eBoidRuleType_Hide, "HIDE", 0, "Hide", "Find a deflector move to it's other side from closest enemy."},
58         //{eBoidRuleType_FollowPath, "FOLLOW_PATH", 0, "Follow Path", "Move along a assigned curve or closest curve in a group."},
59         //{eBoidRuleType_FollowWall, "FOLLOW_WALL", 0, "Follow Wall", "Move next to a deflector object's in direction of it's tangent."},
60         {0, NULL, 0, NULL, NULL}};
61
62 EnumPropertyItem boidruleset_type_items[] ={
63         {eBoidRulesetType_Fuzzy, "FUZZY", 0, "Fuzzy", "Rules are gone through top to bottom. Only the first rule that effect above fuzziness threshold is evaluated."},
64         {eBoidRulesetType_Random, "RANDOM", 0, "Random", "A random rule is selected for each boid."},
65         {eBoidRulesetType_Average, "AVERAGE", 0, "Average", "All rules are averaged."},
66         {0, NULL, 0, NULL, NULL}};
67
68
69 #ifdef RNA_RUNTIME
70
71 #include "BKE_context.h"
72 #include "BKE_depsgraph.h"
73 #include "BKE_particle.h"
74
75 static void rna_Boids_reset(Main *bmain, Scene *scene, PointerRNA *ptr)
76 {
77         if(ptr->type==&RNA_ParticleSystem) {
78                 ParticleSystem *psys = (ParticleSystem*)ptr->data;
79                 
80                 psys->recalc = PSYS_RECALC_RESET;
81
82                 DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA);
83         }
84         else
85                 DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA|PSYS_RECALC_RESET);
86
87         WM_main_add_notifier(NC_OBJECT|ND_PARTICLE_DATA, NULL);
88 }
89 static void rna_Boids_reset_deps(Main *bmain, Scene *scene, PointerRNA *ptr)
90 {
91         if(ptr->type==&RNA_ParticleSystem) {
92                 ParticleSystem *psys = (ParticleSystem*)ptr->data;
93                 
94                 psys->recalc = PSYS_RECALC_RESET;
95
96                 DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA);
97         }
98         else
99                 DAG_id_flush_update(ptr->id.data, OB_RECALC_DATA|PSYS_RECALC_RESET);
100
101         DAG_scene_sort(scene);
102
103         WM_main_add_notifier(NC_OBJECT|ND_PARTICLE_DATA, NULL);
104 }
105
106 static StructRNA* rna_BoidRule_refine(struct PointerRNA *ptr)
107 {
108         BoidRule *rule= (BoidRule*)ptr->data;
109
110         switch(rule->type) {
111                 case eBoidRuleType_Goal:
112                         return &RNA_BoidRuleGoal;
113                 case eBoidRuleType_Avoid:
114                         return &RNA_BoidRuleAvoid;
115                 case eBoidRuleType_AvoidCollision:
116                         return &RNA_BoidRuleAvoidCollision;
117                 case eBoidRuleType_FollowLeader:
118                         return &RNA_BoidRuleFollowLeader;
119                 case eBoidRuleType_AverageSpeed:
120                         return &RNA_BoidRuleAverageSpeed;
121                 case eBoidRuleType_Fight:
122                         return &RNA_BoidRuleFight;
123                 default:
124                         return &RNA_BoidRule;
125         }
126 }
127
128 static char *rna_BoidRule_path(PointerRNA *ptr)
129 {
130         return BLI_sprintfN("rules[\"%s\"]", ((BoidRule*)ptr->data)->name);  // XXX not unique
131 }
132
133 static PointerRNA rna_BoidState_active_boid_rule_get(PointerRNA *ptr)
134 {
135         BoidState *state= (BoidState*)ptr->data;
136         BoidRule *rule = (BoidRule*)state->rules.first;
137
138         for(; rule; rule=rule->next) {
139                 if(rule->flag & BOIDRULE_CURRENT)
140                         return rna_pointer_inherit_refine(ptr, &RNA_BoidRule, rule);
141         }
142         return rna_pointer_inherit_refine(ptr, &RNA_BoidRule, NULL);
143 }
144 static void rna_BoidState_active_boid_rule_index_range(PointerRNA *ptr, int *min, int *max)
145 {
146         BoidState *state= (BoidState*)ptr->data;
147         *min= 0;
148         *max= BLI_countlist(&state->rules)-1;
149         *max= MAX2(0, *max);
150 }
151
152 static int rna_BoidState_active_boid_rule_index_get(PointerRNA *ptr)
153 {
154         BoidState *state= (BoidState*)ptr->data;
155         BoidRule *rule = (BoidRule*)state->rules.first;
156         int i=0;
157
158         for(; rule; rule=rule->next, i++) {
159                 if(rule->flag & BOIDRULE_CURRENT)
160                         return i;
161         }
162         return 0;
163 }
164
165 static void rna_BoidState_active_boid_rule_index_set(struct PointerRNA *ptr, int value)
166 {
167         BoidState *state= (BoidState*)ptr->data;
168         BoidRule *rule = (BoidRule*)state->rules.first;
169         int i=0;
170
171         for(; rule; rule=rule->next, i++) {
172                 if(i==value)
173                         rule->flag |= BOIDRULE_CURRENT;
174                 else
175                         rule->flag &= ~BOIDRULE_CURRENT;
176         }
177 }
178
179 static PointerRNA rna_BoidSettings_active_boid_state_get(PointerRNA *ptr)
180 {
181         BoidSettings *boids= (BoidSettings*)ptr->data;
182         BoidState *state = (BoidState*)boids->states.first;
183
184         for(; state; state=state->next) {
185                 if(state->flag & BOIDSTATE_CURRENT)
186                         return rna_pointer_inherit_refine(ptr, &RNA_BoidState, state);
187         }
188         return rna_pointer_inherit_refine(ptr, &RNA_BoidState, NULL);
189 }
190 static void rna_BoidSettings_active_boid_state_index_range(PointerRNA *ptr, int *min, int *max)
191 {
192         BoidSettings *boids= (BoidSettings*)ptr->data;
193         *min= 0;
194         *max= BLI_countlist(&boids->states)-1;
195         *max= MAX2(0, *max);
196 }
197
198 static int rna_BoidSettings_active_boid_state_index_get(PointerRNA *ptr)
199 {
200         BoidSettings *boids= (BoidSettings*)ptr->data;
201         BoidState *state = (BoidState*)boids->states.first;
202         int i=0;
203
204         for(; state; state=state->next, i++) {
205                 if(state->flag & BOIDSTATE_CURRENT)
206                         return i;
207         }
208         return 0;
209 }
210
211 static void rna_BoidSettings_active_boid_state_index_set(struct PointerRNA *ptr, int value)
212 {
213         BoidSettings *boids= (BoidSettings*)ptr->data;
214         BoidState *state = (BoidState*)boids->states.first;
215         int i=0;
216
217         for(; state; state=state->next, i++) {
218                 if(i==value)
219                         state->flag |= BOIDSTATE_CURRENT;
220                 else
221                         state->flag &= ~BOIDSTATE_CURRENT;
222         }
223 }
224
225 #else
226
227 static void rna_def_boidrule_goal(BlenderRNA *brna)
228 {
229         StructRNA *srna;
230         PropertyRNA *prop;
231
232         srna= RNA_def_struct(brna, "BoidRuleGoal", "BoidRule");
233         RNA_def_struct_ui_text(srna, "Goal", "");
234         RNA_def_struct_sdna(srna, "BoidRuleGoalAvoid");
235
236         prop= RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
237         RNA_def_property_pointer_sdna(prop, NULL, "ob");
238         RNA_def_property_flag(prop, PROP_EDITABLE);
239         RNA_def_property_ui_text(prop, "Object", "Goal object.");
240         RNA_def_property_update(prop, 0, "rna_Boids_reset_deps");
241
242         prop= RNA_def_property(srna, "predict", PROP_BOOLEAN, PROP_NONE);
243         RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_GOAL_AVOID_PREDICT);
244         RNA_def_property_ui_text(prop, "Predict", "Predict target movement.");
245         RNA_def_property_update(prop, 0, "rna_Boids_reset");
246 }
247
248 static void rna_def_boidrule_avoid(BlenderRNA *brna)
249 {
250         StructRNA *srna;
251         PropertyRNA *prop;
252
253         srna= RNA_def_struct(brna, "BoidRuleAvoid", "BoidRule");
254         RNA_def_struct_ui_text(srna, "Avoid", "");
255         RNA_def_struct_sdna(srna, "BoidRuleGoalAvoid");
256
257         prop= RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
258         RNA_def_property_pointer_sdna(prop, NULL, "ob");
259         RNA_def_property_flag(prop, PROP_EDITABLE);
260         RNA_def_property_ui_text(prop, "Object", "Object to avoid.");
261         RNA_def_property_update(prop, 0, "rna_Boids_reset_deps");
262
263         prop= RNA_def_property(srna, "predict", PROP_BOOLEAN, PROP_NONE);
264         RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_GOAL_AVOID_PREDICT);
265         RNA_def_property_ui_text(prop, "Predict", "Predict target movement.");
266         RNA_def_property_update(prop, 0, "rna_Boids_reset");
267
268         prop= RNA_def_property(srna, "fear_factor", PROP_FLOAT, PROP_NONE);
269         RNA_def_property_range(prop, 0.0f, 100.0f);
270         RNA_def_property_ui_text(prop, "Fear factor", "Avoid object if danger from it is above this threshol.");
271         RNA_def_property_update(prop, 0, "rna_Boids_reset");
272 }
273
274 static void rna_def_boidrule_avoid_collision(BlenderRNA *brna)
275 {
276         StructRNA *srna;
277         PropertyRNA *prop;
278
279         srna= RNA_def_struct(brna, "BoidRuleAvoidCollision", "BoidRule");
280         RNA_def_struct_ui_text(srna, "Avoid Collision", "");
281
282         prop= RNA_def_property(srna, "boids", PROP_BOOLEAN, PROP_NONE);
283         RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_ACOLL_WITH_BOIDS);
284         RNA_def_property_ui_text(prop, "Boids", "Avoid collision with other boids.");
285         RNA_def_property_update(prop, 0, "rna_Boids_reset");
286
287         prop= RNA_def_property(srna, "deflectors", PROP_BOOLEAN, PROP_NONE);
288         RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_ACOLL_WITH_DEFLECTORS);
289         RNA_def_property_ui_text(prop, "Deflectors", "Avoid collision with deflector objects.");
290         RNA_def_property_update(prop, 0, "rna_Boids_reset");
291
292         prop= RNA_def_property(srna, "look_ahead", PROP_FLOAT, PROP_NONE);
293         RNA_def_property_range(prop, 0.0f, 100.0f);
294         RNA_def_property_ui_text(prop, "Look ahead", "Time to look ahead in seconds.");
295         RNA_def_property_update(prop, 0, "rna_Boids_reset");
296 }
297
298 static void rna_def_boidrule_follow_leader(BlenderRNA *brna)
299 {
300         StructRNA *srna;
301         PropertyRNA *prop;
302
303         srna= RNA_def_struct(brna, "BoidRuleFollowLeader", "BoidRule");
304         RNA_def_struct_ui_text(srna, "Follow Leader", "");
305
306         prop= RNA_def_property(srna, "object", PROP_POINTER, PROP_NONE);
307         RNA_def_property_pointer_sdna(prop, NULL, "ob");
308         RNA_def_property_flag(prop, PROP_EDITABLE);
309         RNA_def_property_ui_text(prop, "Object", "Follow this object instead of a boid.");
310         RNA_def_property_update(prop, 0, "rna_Boids_reset_deps");
311
312         prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
313         RNA_def_property_range(prop, 0.0f, 100.0f);
314         RNA_def_property_ui_text(prop, "Distance", "Distance behind leader to follow.");
315         RNA_def_property_update(prop, 0, "rna_Boids_reset");
316
317         prop= RNA_def_property(srna, "queue_size", PROP_INT, PROP_NONE);
318         RNA_def_property_range(prop, 0.0f, 100.0f);
319         RNA_def_property_ui_text(prop, "Queue Size", "How many boids in a line.");
320         RNA_def_property_update(prop, 0, "rna_Boids_reset");
321
322         prop= RNA_def_property(srna, "line", PROP_BOOLEAN, PROP_NONE);
323         RNA_def_property_boolean_sdna(prop, NULL, "options", BRULE_LEADER_IN_LINE);
324         RNA_def_property_ui_text(prop, "Line", "Follow leader in a line.");
325         RNA_def_property_update(prop, 0, "rna_Boids_reset");
326 }
327
328 static void rna_def_boidrule_average_speed(BlenderRNA *brna)
329 {
330         StructRNA *srna;
331         PropertyRNA *prop;
332
333         srna= RNA_def_struct(brna, "BoidRuleAverageSpeed", "BoidRule");
334         RNA_def_struct_ui_text(srna, "Average Speed", "");
335
336         prop= RNA_def_property(srna, "wander", PROP_FLOAT, PROP_NONE);
337         RNA_def_property_range(prop, 0.0f, 1.0f);
338         RNA_def_property_ui_text(prop, "Wander", "How fast velocity's direction is randomized.");
339         RNA_def_property_update(prop, 0, "rna_Boids_reset");
340
341         prop= RNA_def_property(srna, "level", PROP_FLOAT, PROP_NONE);
342         RNA_def_property_range(prop, 0.0f, 1.0f);
343         RNA_def_property_ui_text(prop, "Level", "How much velocity's z-component is kept constant.");
344         RNA_def_property_update(prop, 0, "rna_Boids_reset");
345
346         prop= RNA_def_property(srna, "speed", PROP_FLOAT, PROP_NONE);
347         RNA_def_property_range(prop, 0.0f, 1.0f);
348         RNA_def_property_ui_text(prop, "Speed", "Percentage of maximum speed.");
349         RNA_def_property_update(prop, 0, "rna_Boids_reset");
350 }
351
352 static void rna_def_boidrule_fight(BlenderRNA *brna)
353 {
354         StructRNA *srna;
355         PropertyRNA *prop;
356
357         srna= RNA_def_struct(brna, "BoidRuleFight", "BoidRule");
358         RNA_def_struct_ui_text(srna, "Fight", "");
359
360         prop= RNA_def_property(srna, "distance", PROP_FLOAT, PROP_NONE);
361         RNA_def_property_range(prop, 0.0f, 100.0f);
362         RNA_def_property_ui_text(prop, "Fight Distance", "Attack boids at max this distance.");
363         RNA_def_property_update(prop, 0, "rna_Boids_reset");
364
365         prop= RNA_def_property(srna, "flee_distance", PROP_FLOAT, PROP_NONE);
366         RNA_def_property_range(prop, 0.0f, 100.0f);
367         RNA_def_property_ui_text(prop, "Flee Distance", "Flee to this distance.");
368         RNA_def_property_update(prop, 0, "rna_Boids_reset");
369 }
370
371 static void rna_def_boidrule(BlenderRNA *brna)
372 {
373         StructRNA *srna;
374         PropertyRNA *prop;
375         
376         /* data */
377         srna= RNA_def_struct(brna, "BoidRule", NULL);
378         RNA_def_struct_ui_text(srna , "Boid Rule", "");
379         RNA_def_struct_refine_func(srna, "rna_BoidRule_refine");
380         RNA_def_struct_path_func(srna, "rna_BoidRule_path");
381         
382         /* strings */
383         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
384         RNA_def_property_ui_text(prop, "Name", "Boid rule name.");
385         RNA_def_struct_name_property(srna, prop);
386         
387         /* enums */
388         prop= RNA_def_property(srna, "type", PROP_ENUM, PROP_NONE);
389         RNA_def_property_clear_flag(prop, PROP_EDITABLE);
390         RNA_def_property_enum_sdna(prop, NULL, "type");
391         RNA_def_property_enum_items(prop, boidrule_type_items);
392         RNA_def_property_ui_text(prop, "Type", "");
393         
394         /* flags */
395         prop= RNA_def_property(srna, "in_air", PROP_BOOLEAN, PROP_NONE);
396         RNA_def_property_boolean_sdna(prop, NULL, "flag", BOIDRULE_IN_AIR);
397         RNA_def_property_ui_text(prop, "In Air", "Use rule when boid is flying.");
398         RNA_def_property_update(prop, 0, "rna_Boids_reset");
399         
400         prop= RNA_def_property(srna, "on_land", PROP_BOOLEAN, PROP_NONE);
401         RNA_def_property_boolean_sdna(prop, NULL, "flag", BOIDRULE_ON_LAND);
402         RNA_def_property_ui_text(prop, "On Land", "Use rule when boid is on land.");
403         RNA_def_property_update(prop, 0, "rna_Boids_reset");
404         
405         //prop= RNA_def_property(srna, "expanded", PROP_BOOLEAN, PROP_NONE);
406         //RNA_def_property_boolean_sdna(prop, NULL, "mode", eModifierMode_Expanded);
407         //RNA_def_property_ui_text(prop, "Expanded", "Set modifier expanded in the user interface.");
408
409         /* types */
410         rna_def_boidrule_goal(brna);
411         rna_def_boidrule_avoid(brna);
412         rna_def_boidrule_avoid_collision(brna);
413         rna_def_boidrule_follow_leader(brna);
414         rna_def_boidrule_average_speed(brna);
415         rna_def_boidrule_fight(brna);
416 }
417
418 static void rna_def_boidstate(BlenderRNA *brna)
419 {
420         StructRNA *srna;
421         PropertyRNA *prop;
422
423         srna = RNA_def_struct(brna, "BoidState", NULL);
424         RNA_def_struct_ui_text(srna, "Boid State", "Boid state for boid physics.");
425
426         prop= RNA_def_property(srna, "name", PROP_STRING, PROP_NONE);
427         RNA_def_property_ui_text(prop, "Name", "Boid state name.");
428         RNA_def_struct_name_property(srna, prop);
429
430         prop= RNA_def_property(srna, "ruleset_type", PROP_ENUM, PROP_NONE);
431         RNA_def_property_enum_items(prop, boidruleset_type_items);
432         RNA_def_property_ui_text(prop, "Rule Evaluation", "How the rules in the list are evaluated.");
433
434         prop= RNA_def_property(srna, "rules", PROP_COLLECTION, PROP_NONE);
435         RNA_def_property_struct_type(prop, "BoidRule");
436         RNA_def_property_ui_text(prop, "Boid Rules", "");
437
438         prop= RNA_def_property(srna, "active_boid_rule", PROP_POINTER, PROP_NONE);
439         RNA_def_property_struct_type(prop, "BoidRule");
440         RNA_def_property_pointer_funcs(prop, "rna_BoidState_active_boid_rule_get", NULL, NULL);
441         RNA_def_property_ui_text(prop, "Active Boid Rule", "");
442
443         prop= RNA_def_property(srna, "active_boid_rule_index", PROP_INT, PROP_UNSIGNED);
444         RNA_def_property_int_funcs(prop, "rna_BoidState_active_boid_rule_index_get", "rna_BoidState_active_boid_rule_index_set", "rna_BoidState_active_boid_rule_index_range");
445         RNA_def_property_ui_text(prop, "Active Boid Rule Index", "");
446
447         prop= RNA_def_property(srna, "rule_fuzziness", PROP_FLOAT, PROP_NONE);
448         RNA_def_property_range(prop, 0.0, 1.0);
449         RNA_def_property_ui_text(prop, "Rule Fuzzines", "");
450         RNA_def_property_update(prop, 0, "rna_Boids_reset");
451
452         prop= RNA_def_property(srna, "volume", PROP_FLOAT, PROP_NONE);
453         RNA_def_property_range(prop, 0.0, 100.0);
454         RNA_def_property_ui_text(prop, "Volume", "");
455         RNA_def_property_update(prop, 0, "rna_Boids_reset");
456
457         prop= RNA_def_property(srna, "falloff", PROP_FLOAT, PROP_NONE);
458         RNA_def_property_range(prop, 0.0, 10.0);
459         RNA_def_property_ui_text(prop, "Falloff", "");
460         RNA_def_property_update(prop, 0, "rna_Boids_reset");
461 }
462 static void rna_def_boid_settings(BlenderRNA *brna)
463 {
464         StructRNA *srna;
465         PropertyRNA *prop;
466
467         srna = RNA_def_struct(brna, "BoidSettings", NULL);
468         RNA_def_struct_ui_text(srna, "Boid Settings", "Settings for boid physics.");
469
470         prop= RNA_def_property(srna, "landing_smoothness", PROP_FLOAT, PROP_NONE);
471         RNA_def_property_range(prop, 0.0, 10.0);
472         RNA_def_property_ui_text(prop, "Landing Smoothness", "How smoothly the boids land.");
473         RNA_def_property_update(prop, 0, "rna_Boids_reset");
474
475         prop= RNA_def_property(srna, "banking", PROP_FLOAT, PROP_NONE);
476         RNA_def_property_range(prop, 0.0, 2.0);
477         RNA_def_property_ui_text(prop, "Banking", "Amount of rotation around velocity vector on turns.");
478         RNA_def_property_update(prop, 0, "rna_Boids_reset");
479
480         prop= RNA_def_property(srna, "height", PROP_FLOAT, PROP_NONE);
481         RNA_def_property_range(prop, 0.0, 2.0);
482         RNA_def_property_ui_text(prop, "Height", "Boid height relative to particle size.");
483         RNA_def_property_update(prop, 0, "rna_Boids_reset");
484
485         /* states */
486         prop= RNA_def_property(srna, "states", PROP_COLLECTION, PROP_NONE);
487         RNA_def_property_struct_type(prop, "BoidState");
488         RNA_def_property_ui_text(prop, "Boid States", "");
489
490         prop= RNA_def_property(srna, "active_boid_state", PROP_POINTER, PROP_NONE);
491         RNA_def_property_struct_type(prop, "BoidRule");
492         RNA_def_property_pointer_funcs(prop, "rna_BoidSettings_active_boid_state_get", NULL, NULL);
493         RNA_def_property_ui_text(prop, "Active Boid Rule", "");
494
495         prop= RNA_def_property(srna, "active_boid_state_index", PROP_INT, PROP_UNSIGNED);
496         RNA_def_property_int_funcs(prop, "rna_BoidSettings_active_boid_state_index_get", "rna_BoidSettings_active_boid_state_index_set", "rna_BoidSettings_active_boid_state_index_range");
497         RNA_def_property_ui_text(prop, "Active Boid State Index", "");
498
499         /* character properties */
500         prop= RNA_def_property(srna, "health", PROP_FLOAT, PROP_NONE);
501         RNA_def_property_range(prop, 0.0, 100.0);
502         RNA_def_property_ui_text(prop, "Health", "Initial boid health when born.");
503         RNA_def_property_update(prop, 0, "rna_Boids_reset");
504
505         prop= RNA_def_property(srna, "strength", PROP_FLOAT, PROP_NONE);
506         RNA_def_property_range(prop, 0.0, 100.0);
507         RNA_def_property_ui_text(prop, "Strength", "Maximum caused damage on attack per second.");
508         RNA_def_property_update(prop, 0, "rna_Boids_reset");
509
510         prop= RNA_def_property(srna, "aggression", PROP_FLOAT, PROP_NONE);
511         RNA_def_property_range(prop, 0.0, 100.0);
512         RNA_def_property_ui_text(prop, "Aggression", "Boid will fight this times stronger enemy.");
513         RNA_def_property_update(prop, 0, "rna_Boids_reset");
514
515         prop= RNA_def_property(srna, "accuracy", PROP_FLOAT, PROP_NONE);
516         RNA_def_property_range(prop, 0.0, 1.0);
517         RNA_def_property_ui_text(prop, "Accuracy", "Accuracy of attack.");
518         RNA_def_property_update(prop, 0, "rna_Boids_reset");
519
520         prop= RNA_def_property(srna, "range", PROP_FLOAT, PROP_NONE);
521         RNA_def_property_range(prop, 0.0, 100.0);
522         RNA_def_property_ui_text(prop, "Range", "The maximum distance from which a boid can attack.");
523         RNA_def_property_update(prop, 0, "rna_Boids_reset");
524
525         /* physical properties */
526         prop= RNA_def_property(srna, "air_min_speed", PROP_FLOAT, PROP_NONE);
527         RNA_def_property_range(prop, 0.0, 1.0);
528         RNA_def_property_ui_text(prop, "Min Air Speed", "Minimum speed in air (relative to maximum speed).");
529         RNA_def_property_update(prop, 0, "rna_Boids_reset");
530
531         prop= RNA_def_property(srna, "air_max_speed", PROP_FLOAT, PROP_NONE);
532         RNA_def_property_range(prop, 0.0, 100.0);
533         RNA_def_property_ui_text(prop, "Max Air Speed", "Maximum speed in air.");
534         RNA_def_property_update(prop, 0, "rna_Boids_reset");
535
536         prop= RNA_def_property(srna, "air_max_acc", PROP_FLOAT, PROP_NONE);
537         RNA_def_property_range(prop, 0.0, 1.0);
538         RNA_def_property_ui_text(prop, "Max Air Acceleration", "Maximum acceleration in air (relative to maximum speed).");
539         RNA_def_property_update(prop, 0, "rna_Boids_reset");
540
541         prop= RNA_def_property(srna, "air_max_ave", PROP_FLOAT, PROP_NONE);
542         RNA_def_property_range(prop, 0.0, 1.0);
543         RNA_def_property_ui_text(prop, "Max Air Angular Velocity", "Maximum angular velocity in air (relative to 180 degrees).");
544         RNA_def_property_update(prop, 0, "rna_Boids_reset");
545
546         prop= RNA_def_property(srna, "air_personal_space", PROP_FLOAT, PROP_NONE);
547         RNA_def_property_range(prop, 0.0, 10.0);
548         RNA_def_property_ui_text(prop, "Air Personal Space", "Radius of boids personal space in air (% of particle size).");
549         RNA_def_property_update(prop, 0, "rna_Boids_reset");
550
551         prop= RNA_def_property(srna, "land_jump_speed", PROP_FLOAT, PROP_NONE);
552         RNA_def_property_range(prop, 0.0, 100.0);
553         RNA_def_property_ui_text(prop, "Jump Speed", "Maximum speed for jumping.");
554         RNA_def_property_update(prop, 0, "rna_Boids_reset");
555
556         prop= RNA_def_property(srna, "land_max_speed", PROP_FLOAT, PROP_NONE);
557         RNA_def_property_range(prop, 0.0, 100.0);
558         RNA_def_property_ui_text(prop, "Max Land Speed", "Maximum speed on land.");
559         RNA_def_property_update(prop, 0, "rna_Boids_reset");
560
561         prop= RNA_def_property(srna, "land_max_acc", PROP_FLOAT, PROP_NONE);
562         RNA_def_property_range(prop, 0.0, 1.0);
563         RNA_def_property_ui_text(prop, "Max Land Acceleration", "Maximum acceleration on land (relative to maximum speed).");
564         RNA_def_property_update(prop, 0, "rna_Boids_reset");
565
566         prop= RNA_def_property(srna, "land_max_ave", PROP_FLOAT, PROP_NONE);
567         RNA_def_property_range(prop, 0.0, 1.0);
568         RNA_def_property_ui_text(prop, "Max Land Angular Velocity", "Maximum angular velocity on land (relative to 180 degrees).");
569         RNA_def_property_update(prop, 0, "rna_Boids_reset");
570
571         prop= RNA_def_property(srna, "land_personal_space", PROP_FLOAT, PROP_NONE);
572         RNA_def_property_range(prop, 0.0, 10.0);
573         RNA_def_property_ui_text(prop, "Land Personal Space", "Radius of boids personal space on land (% of particle size).");
574         RNA_def_property_update(prop, 0, "rna_Boids_reset");
575
576         prop= RNA_def_property(srna, "land_stick_force", PROP_FLOAT, PROP_NONE);
577         RNA_def_property_range(prop, 0.0, 1000.0);
578         RNA_def_property_ui_text(prop, "Land Stick Force", "How strong a force must be to start effecting a boid on land.");
579         RNA_def_property_update(prop, 0, "rna_Boids_reset");
580
581         /* options */
582         prop= RNA_def_property(srna, "allow_flight", PROP_BOOLEAN, PROP_NONE);
583         RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_FLIGHT);
584         RNA_def_property_ui_text(prop, "Allow Flight", "Allow boids to move in air.");
585         RNA_def_property_update(prop, 0, "rna_Boids_reset");
586
587         prop= RNA_def_property(srna, "allow_land", PROP_BOOLEAN, PROP_NONE);
588         RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_LAND);
589         RNA_def_property_ui_text(prop, "Allow Land", "Allow boids to move on land.");
590         RNA_def_property_update(prop, 0, "rna_Boids_reset");
591
592         prop= RNA_def_property(srna, "allow_climb", PROP_BOOLEAN, PROP_NONE);
593         RNA_def_property_boolean_sdna(prop, NULL, "options", BOID_ALLOW_CLIMB);
594         RNA_def_property_ui_text(prop, "Allow Climbing", "Allow boids to climb goal objects.");
595         RNA_def_property_update(prop, 0, "rna_Boids_reset");
596 }
597
598 void RNA_def_boid(BlenderRNA *brna)
599 {
600         rna_def_boidrule(brna);
601         rna_def_boidstate(brna);
602         rna_def_boid_settings(brna);
603 }
604
605 #endif