Blender V5.3
boids.cc
Go to the documentation of this file.
1/* SPDX-FileCopyrightText: 2009 by Janne Karhu. All rights reserved.
2 *
3 * SPDX-License-Identifier: GPL-2.0-or-later */
4
8
9#include <cmath>
10#include <cstring>
11
12#include "MEM_guardedalloc.h"
13
15#include "DNA_scene_types.h"
16
17#include "BLI_kdtree.hh"
18#include "BLI_listbase.hh"
19#include "BLI_math_base_safe.hh"
21#include "BLI_math_vector_c.hh"
23#include "BLI_rand_c.hh"
24#include "BLI_string.hh"
25#include "BLI_string_utf8.hh"
26#include "BLI_utildefines.hh"
27
28#include "BKE_boids.h"
29#include "BKE_collision.h"
30#include "BKE_effect.h"
31#include "BKE_particle.h"
32#include "BLI_kdopbvh.hh"
33
34#include "BLT_translation.hh"
35
36#include "BKE_modifier.hh"
37
38#include "RNA_enum_types.hh"
39
40namespace blender {
42{
43 return [=](const float3 &co_search, const float3 &co_test) -> float {
44 float d[3], dist;
45
46 sub_v3_v3v3(d, co_test, co_search);
47
48 dist = len_squared_v3(d);
49
50 /* Avoid head-on collisions. */
51 if (dot_v3v3(d, normal) < 0.0f) {
52 dist *= 10.0f;
53 }
54 return dist;
55 };
56}
57
63
64static bool apply_boid_rule(
65 BoidBrainData *bbd, BoidRule *rule, BoidValues *val, ParticleData *pa, float fuzziness);
66
67static bool rule_none(BoidRule * /*rule*/,
68 BoidBrainData * /*data*/,
69 BoidValues * /*val*/,
70 ParticleData * /*pa*/)
71{
72 return false;
73}
74
76{
77 BoidRuleGoalAvoid *gabr = reinterpret_cast<BoidRuleGoalAvoid *>(rule);
78 BoidSettings *boids = bbd->part->boids;
79 BoidParticle *bpa = pa->boid;
80 EffectedPoint epoint;
81 ListBaseT<EffectorCache> *effectors = bbd->sim->psys->effectors;
82 EffectorCache *eff = nullptr;
83 EffectorCache temp_eff;
84 EffectorData efd, cur_efd;
85 float mul = (rule->type == eBoidRuleType_Avoid ? 1.0 : -1.0);
86 float priority = 0.0f, len = 0.0f;
87 bool ret = false;
88
89 int p = 0;
90 efd.index = cur_efd.index = &p;
91
92 pd_point_from_particle(bbd->sim, pa, &pa->state, &epoint);
93
94 /* first find out goal/predator with highest priority */
95 if (effectors) {
96 for (EffectorCache &cur : *effectors) {
97 Object *eob = cur.ob;
98 PartDeflect *pd = cur.pd;
99
100 if (gabr->ob && (rule->type != eBoidRuleType_Goal || gabr->ob != bpa->ground)) {
101 if (gabr->ob == eob) {
102 /* TODO: effectors with multiple points */
103 if (get_effector_data(&cur, &efd, &epoint, 0)) {
104 if (cur.pd && cur.pd->forcefield == PFIELD_BOID) {
105 priority = mul * pd->f_strength *
106 effector_falloff(&cur, &efd, &epoint, bbd->part->effector_weights);
107 }
108 else {
109 priority = 1.0;
110 }
111
112 eff = &cur;
113 }
114 break;
115 }
116 }
117 else if (rule->type == eBoidRuleType_Goal && eob == bpa->ground) {
118 /* skip current object */
119 }
120 else if (pd->forcefield == PFIELD_BOID && mul * pd->f_strength > 0.0f &&
121 get_effector_data(&cur, &cur_efd, &epoint, 0))
122 {
123 float temp = mul * pd->f_strength *
124 effector_falloff(&cur, &cur_efd, &epoint, bbd->part->effector_weights);
125
126 if (temp == 0.0f) {
127 /* do nothing */
128 }
129 else if (temp > priority) {
130 priority = temp;
131 eff = &cur;
132 efd = cur_efd;
133 len = efd.distance;
134 }
135 /* choose closest object with same priority */
136 else if (temp == priority && efd.distance < len) {
137 eff = &cur;
138 efd = cur_efd;
139 len = efd.distance;
140 }
141 }
142 }
143 }
144
145 /* if the object doesn't have effector data we have to fake it */
146 if (eff == nullptr && gabr->ob) {
147 memset(&temp_eff, 0, sizeof(EffectorCache));
148 temp_eff.ob = gabr->ob;
149 temp_eff.depsgraph = bbd->sim->depsgraph;
150 temp_eff.scene = bbd->sim->scene;
151 eff = &temp_eff;
152 get_effector_data(eff, &efd, &epoint, 0);
153 priority = 1.0f;
154 }
155
156 /* Then use that effector. */
157
158 /* With avoid, factor is "fear factor". */
159 if (priority > (rule->type == eBoidRuleType_Avoid ? gabr->fear_factor : 0.0f)) {
160 Object *eob = eff->ob;
161 PartDeflect *pd = eff->pd;
162 float surface = (pd && pd->shape == PFIELD_SHAPE_SURFACE) ? 1.0f : 0.0f;
163
164 if (gabr->options & BRULE_GOAL_AVOID_PREDICT) {
165 /* estimate future location of target */
166 get_effector_data(eff, &efd, &epoint, 1);
167
168 mul_v3_fl(efd.vel, efd.distance / (val->max_speed * bbd->timestep));
169 add_v3_v3(efd.loc, efd.vel);
171 efd.distance = len_v3(efd.vec_to_point);
172 }
173
174 if (rule->type == eBoidRuleType_Goal && boids->options & BOID_ALLOW_CLIMB && surface != 0.0f) {
175 if (!bbd->goal_ob || bbd->goal_priority < priority) {
176 bbd->goal_ob = eob;
177 copy_v3_v3(bbd->goal_co, efd.loc);
178 copy_v3_v3(bbd->goal_nor, efd.nor);
179 }
180 }
181 else if ((rule->type == eBoidRuleType_Avoid) && (bpa->data.mode == eBoidMode_Climbing) &&
182 (priority > 2.0f * gabr->fear_factor))
183 {
184 /* detach from surface and try to fly away from danger */
186 }
187
189 mul_v3_fl(bbd->wanted_co, mul);
190
191 bbd->wanted_speed = val->max_speed * priority;
192
193 /* with goals factor is approach velocity factor */
194 if (rule->type == eBoidRuleType_Goal && boids->landing_smoothness > 0.0f) {
195 float len2 = 2.0f * len_v3(pa->prev_state.vel);
196
197 surface *= pa->size * boids->height;
198
199 if (len2 > 0.0f && efd.distance - surface < len2) {
200 len2 = (efd.distance - surface) / len2;
201 bbd->wanted_speed *= powf(len2, boids->landing_smoothness);
202 }
203 }
204
205 ret = true;
206 }
207
208 return ret;
209}
210
212 BoidBrainData *bbd,
213 BoidValues *val,
214 ParticleData *pa)
215{
216 const int raycast_flag = BVH_RAYCAST_DEFAULT & ~BVH_RAYCAST_WATERTIGHT;
217 BoidRuleAvoidCollision *acbr = reinterpret_cast<BoidRuleAvoidCollision *>(rule);
218 KDTreeNearest<float3> *ptn = nullptr;
219 BoidParticle *bpa = pa->boid;
220 float vec[3] = {0.0f, 0.0f, 0.0f}, loc[3] = {0.0f, 0.0f, 0.0f};
221 float co1[3], vel1[3], co2[3], vel2[3];
222 float len, t, inp, t_min = 2.0f;
223 int n, neighbors = 0, nearest = 0;
224 bool ret = false;
225
226 /* Check deflector objects first. */
227 if (acbr->options & BRULE_ACOLL_WITH_DEFLECTORS && bbd->sim->colliders) {
229 BVHTreeRayHit hit;
230 float radius = val->personal_space * pa->size, ray_dir[3];
231
232 memset(&col, 0, sizeof(ParticleCollision));
233
234 copy_v3_v3(col.co1, pa->prev_state.co);
235 add_v3_v3v3(col.co2, pa->prev_state.co, pa->prev_state.vel);
236 sub_v3_v3v3(ray_dir, col.co2, col.co1);
237 mul_v3_fl(ray_dir, acbr->look_ahead);
238 col.f = 0.0f;
239 hit.index = -1;
240 hit.dist = col.original_ray_length = normalize_v3(ray_dir);
241
242 /* find out closest deflector object */
243 for (ColliderCache &coll : *bbd->sim->colliders) {
244 /* don't check with current ground object */
245 if (coll.ob == bpa->ground) {
246 continue;
247 }
248
249 col.current = coll.ob;
250 col.md = coll.collmd;
251
252 if (col.md && col.md->bvhtree) {
254 col.co1,
255 ray_dir,
256 radius,
257 &hit,
259 &col,
260 raycast_flag);
261 }
262 }
263 /* then avoid that object */
264 if (hit.index >= 0) {
265 t = hit.dist / col.original_ray_length;
266
267 /* avoid head-on collision */
268 if (dot_v3v3(col.pce.nor, pa->prev_state.ave) < -0.99f) {
269 /* don't know why, but uneven range [0.0, 1.0] */
270 /* works much better than even [-1.0, 1.0] */
271 bbd->wanted_co[0] = BLI_rng_get_float(bbd->rng);
272 bbd->wanted_co[1] = BLI_rng_get_float(bbd->rng);
273 bbd->wanted_co[2] = BLI_rng_get_float(bbd->rng);
274 }
275 else {
276 copy_v3_v3(bbd->wanted_co, col.pce.nor);
277 }
278
279 mul_v3_fl(bbd->wanted_co, (1.0f - t) * val->personal_space * pa->size);
280
281 bbd->wanted_speed = sqrtf(t) * len_v3(pa->prev_state.vel);
282 bbd->wanted_speed = std::max(bbd->wanted_speed, val->min_speed);
283
284 return true;
285 }
286 }
287
288 /* Check boids in their own system. */
289 if (acbr->options & BRULE_ACOLL_WITH_BOIDS) {
291 bbd->sim->psys->tree,
292 pa->prev_state.co,
293 &ptn,
294 acbr->look_ahead * len_v3(pa->prev_state.vel),
296 if (neighbors > 1) {
297 for (n = 1; n < neighbors; n++) {
298 copy_v3_v3(co1, pa->prev_state.co);
299 copy_v3_v3(vel1, pa->prev_state.vel);
300 copy_v3_v3(co2, (bbd->sim->psys->particles + ptn[n].index)->prev_state.co);
301 copy_v3_v3(vel2, (bbd->sim->psys->particles + ptn[n].index)->prev_state.vel);
302
303 sub_v3_v3v3(loc, co1, co2);
304
305 sub_v3_v3v3(vec, vel1, vel2);
306
307 inp = dot_v3v3(vec, vec);
308
309 /* velocities not parallel */
310 if (inp != 0.0f) {
311 t = -dot_v3v3(loc, vec) / inp;
312 /* cpa is not too far in the future so investigate further */
313 if (t > 0.0f && t < t_min) {
314 madd_v3_v3fl(co1, vel1, t);
315 madd_v3_v3fl(co2, vel2, t);
316
317 sub_v3_v3v3(vec, co2, co1);
318
319 len = normalize_v3(vec);
320
321 /* distance of cpa is close enough */
322 if (len < 2.0f * val->personal_space * pa->size) {
323 t_min = t;
324
325 mul_v3_fl(vec, len_v3(vel1));
326 mul_v3_fl(vec, (2.0f - t) / 2.0f);
327 sub_v3_v3v3(bbd->wanted_co, vel1, vec);
328 bbd->wanted_speed = len_v3(bbd->wanted_co);
329 ret = true;
330 }
331 }
332 }
333 }
334 }
335 }
336 MEM_SAFE_DELETE(ptn);
337
338 /* check boids in other systems */
339 for (ParticleTarget &pt : bbd->sim->psys->targets) {
340 ParticleSystem *epsys = psys_get_target_system(bbd->sim->ob, &pt);
341
342 if (epsys) {
343 BLI_assert(epsys->tree != nullptr);
345 epsys->tree,
346 pa->prev_state.co,
347 &ptn,
348 acbr->look_ahead * len_v3(pa->prev_state.vel),
350
351 if (neighbors > 0) {
352 for (n = 0; n < neighbors; n++) {
353 copy_v3_v3(co1, pa->prev_state.co);
354 copy_v3_v3(vel1, pa->prev_state.vel);
355 copy_v3_v3(co2, (epsys->particles + ptn[n].index)->prev_state.co);
356 copy_v3_v3(vel2, (epsys->particles + ptn[n].index)->prev_state.vel);
357
358 sub_v3_v3v3(loc, co1, co2);
359
360 sub_v3_v3v3(vec, vel1, vel2);
361
362 inp = dot_v3v3(vec, vec);
363
364 /* velocities not parallel */
365 if (inp != 0.0f) {
366 t = -dot_v3v3(loc, vec) / inp;
367 /* cpa is not too far in the future so investigate further */
368 if (t > 0.0f && t < t_min) {
369 madd_v3_v3fl(co1, vel1, t);
370 madd_v3_v3fl(co2, vel2, t);
371
372 sub_v3_v3v3(vec, co2, co1);
373
374 len = normalize_v3(vec);
375
376 /* distance of cpa is close enough */
377 if (len < 2.0f * val->personal_space * pa->size) {
378 t_min = t;
379
380 mul_v3_fl(vec, len_v3(vel1));
381 mul_v3_fl(vec, (2.0f - t) / 2.0f);
382 sub_v3_v3v3(bbd->wanted_co, vel1, vec);
383 bbd->wanted_speed = len_v3(bbd->wanted_co);
384 ret = true;
385 }
386 }
387 }
388 }
389 }
390
391 MEM_SAFE_DELETE(ptn);
392 }
393 }
394
395 if (ptn && nearest == 0) {
396 MEM_delete(ptn);
397 }
398
399 return ret;
400}
401static bool rule_separate(BoidRule * /*rule*/,
402 BoidBrainData *bbd,
403 BoidValues *val,
404 ParticleData *pa)
405{
406 KDTreeNearest<float3> *ptn = nullptr;
407 float len = 2.0f * val->personal_space * pa->size + 1.0f;
408 float vec[3] = {0.0f, 0.0f, 0.0f};
409 int neighbors = kdtree_range_search<float3>(
410 bbd->sim->psys->tree, pa->prev_state.co, &ptn, 2.0f * val->personal_space * pa->size);
411 bool ret = false;
412
413 if (neighbors > 1 && ptn[1].dist != 0.0f) {
414 sub_v3_v3v3(vec, pa->prev_state.co, bbd->sim->psys->particles[ptn[1].index].state.co);
415 mul_v3_fl(vec, (2.0f * val->personal_space * pa->size - ptn[1].dist) / ptn[1].dist);
416 add_v3_v3(bbd->wanted_co, vec);
417 bbd->wanted_speed = val->max_speed;
418 len = ptn[1].dist;
419 ret = true;
420 }
421 MEM_SAFE_DELETE(ptn);
422
423 /* check other boid systems */
424 for (ParticleTarget &pt : bbd->sim->psys->targets) {
425 ParticleSystem *epsys = psys_get_target_system(bbd->sim->ob, &pt);
426
427 if (epsys) {
428 neighbors = kdtree_range_search<float3>(
429 epsys->tree, pa->prev_state.co, &ptn, 2.0f * val->personal_space * pa->size);
430
431 if (neighbors > 0 && ptn[0].dist < len) {
432 sub_v3_v3v3(vec, pa->prev_state.co, ptn[0].co);
433 mul_v3_fl(vec, (2.0f * val->personal_space * pa->size - ptn[0].dist) / ptn[1].dist);
434 add_v3_v3(bbd->wanted_co, vec);
435 bbd->wanted_speed = val->max_speed;
436 len = ptn[0].dist;
437 ret = true;
438 }
439
440 MEM_SAFE_DELETE(ptn);
441 }
442 }
443 return ret;
444}
445static bool rule_flock(BoidRule * /*rule*/,
446 BoidBrainData *bbd,
447 BoidValues * /*val*/,
448 ParticleData *pa)
449{
450 KDTreeNearest<float3> ptn[11];
451 float vec[3] = {0.0f, 0.0f, 0.0f}, loc[3] = {0.0f, 0.0f, 0.0f};
453 bbd->sim->psys->tree,
454 pa->state.co,
455 ptn,
456 ARRAY_SIZE(ptn),
458 int n;
459 bool ret = false;
460
461 if (neighbors > 1) {
462 for (n = 1; n < neighbors; n++) {
463 add_v3_v3(loc, bbd->sim->psys->particles[ptn[n].index].prev_state.co);
464 add_v3_v3(vec, bbd->sim->psys->particles[ptn[n].index].prev_state.vel);
465 }
466
467 mul_v3_fl(loc, 1.0f / (float(neighbors) - 1.0f));
468 mul_v3_fl(vec, 1.0f / (float(neighbors) - 1.0f));
469
470 sub_v3_v3(loc, pa->prev_state.co);
471 sub_v3_v3(vec, pa->prev_state.vel);
472
473 add_v3_v3(bbd->wanted_co, vec);
474 add_v3_v3(bbd->wanted_co, loc);
475 bbd->wanted_speed = len_v3(bbd->wanted_co);
476
477 ret = true;
478 }
479 return ret;
480}
481static bool rule_follow_leader(BoidRule *rule,
482 BoidBrainData *bbd,
483 BoidValues *val,
484 ParticleData *pa)
485{
486 BoidRuleFollowLeader *flbr = reinterpret_cast<BoidRuleFollowLeader *>(rule);
487 float vec[3] = {0.0f, 0.0f, 0.0f}, loc[3] = {0.0f, 0.0f, 0.0f};
488 float mul, len;
489 const int n = (flbr->queue_size <= 1) ? bbd->sim->psys->totpart : flbr->queue_size;
491 const int p = int(pa - bbd->sim->psys->particles);
492 int i;
493 bool ret = false;
494
495 if (flbr->ob) {
496 float vec2[3], t;
497
498 /* first check we're not blocking the leader */
499 sub_v3_v3v3(vec, flbr->loc, flbr->oloc);
500 mul_v3_fl(vec, 1.0f / bbd->timestep);
501
502 sub_v3_v3v3(loc, pa->prev_state.co, flbr->oloc);
503
504 mul = dot_v3v3(vec, vec);
505
506 /* leader is not moving */
507 if (mul < 0.01f) {
508 len = len_v3(loc);
509 /* too close to leader */
510 if (len < 2.0f * val->personal_space * pa->size) {
511 copy_v3_v3(bbd->wanted_co, loc);
512 bbd->wanted_speed = val->max_speed;
513 return true;
514 }
515 }
516 else {
517 t = dot_v3v3(loc, vec) / mul;
518
519 /* possible blocking of leader in near future */
520 if (t > 0.0f && t < 3.0f) {
521 copy_v3_v3(vec2, vec);
522 mul_v3_fl(vec2, t);
523
524 sub_v3_v3v3(vec2, loc, vec2);
525
526 len = len_v3(vec2);
527
528 if (len < 2.0f * val->personal_space * pa->size) {
529 copy_v3_v3(bbd->wanted_co, vec2);
530 bbd->wanted_speed = val->max_speed * (3.0f - t) / 3.0f;
531 return true;
532 }
533 }
534 }
535
536 /* not blocking so try to follow leader */
537 if (p && flbr->options & BRULE_LEADER_IN_LINE) {
538 copy_v3_v3(vec, bbd->sim->psys->particles[p - 1].prev_state.vel);
539 copy_v3_v3(loc, bbd->sim->psys->particles[p - 1].prev_state.co);
540 }
541 else {
542 copy_v3_v3(loc, flbr->oloc);
543 sub_v3_v3v3(vec, flbr->loc, flbr->oloc);
544 mul_v3_fl(vec, 1.0f / bbd->timestep);
545 }
546
547 /* fac is seconds behind leader */
548 madd_v3_v3fl(loc, vec, -flbr->distance);
549
550 sub_v3_v3v3(bbd->wanted_co, loc, pa->prev_state.co);
551 bbd->wanted_speed = len_v3(bbd->wanted_co);
552
553 ret = true;
554 }
555 else if (p % n) {
556 float vec2[3], t, t_min = 3.0f;
557
558 /* first check we're not blocking any leaders */
559 for (i = 0; i < bbd->sim->psys->totpart; i += n) {
560 copy_v3_v3(vec, bbd->sim->psys->particles[i].prev_state.vel);
561
562 sub_v3_v3v3(loc, pa->prev_state.co, bbd->sim->psys->particles[i].prev_state.co);
563
564 mul = dot_v3v3(vec, vec);
565
566 /* leader is not moving */
567 if (mul < 0.01f) {
568 len = len_v3(loc);
569 /* too close to leader */
570 if (len < 2.0f * val->personal_space * pa->size) {
571 copy_v3_v3(bbd->wanted_co, loc);
572 bbd->wanted_speed = val->max_speed;
573 return true;
574 }
575 }
576 else {
577 t = dot_v3v3(loc, vec) / mul;
578
579 /* possible blocking of leader in near future */
580 if (t > 0.0f && t < t_min) {
581 copy_v3_v3(vec2, vec);
582 mul_v3_fl(vec2, t);
583
584 sub_v3_v3v3(vec2, loc, vec2);
585
586 len = len_v3(vec2);
587
588 if (len < 2.0f * val->personal_space * pa->size) {
589 t_min = t;
590 copy_v3_v3(bbd->wanted_co, loc);
591 bbd->wanted_speed = val->max_speed * (3.0f - t) / 3.0f;
592 ret = true;
593 }
594 }
595 }
596 }
597
598 if (ret) {
599 return true;
600 }
601
602 /* not blocking so try to follow leader */
603 if (flbr->options & BRULE_LEADER_IN_LINE) {
604 copy_v3_v3(vec, bbd->sim->psys->particles[p - 1].prev_state.vel);
605 copy_v3_v3(loc, bbd->sim->psys->particles[p - 1].prev_state.co);
606 }
607 else {
608 copy_v3_v3(vec, bbd->sim->psys->particles[p - p % n].prev_state.vel);
609 copy_v3_v3(loc, bbd->sim->psys->particles[p - p % n].prev_state.co);
610 }
611
612 /* fac is seconds behind leader */
613 madd_v3_v3fl(loc, vec, -flbr->distance);
614
615 sub_v3_v3v3(bbd->wanted_co, loc, pa->prev_state.co);
616 bbd->wanted_speed = len_v3(bbd->wanted_co);
617
618 ret = true;
619 }
620
621 return ret;
622}
623static bool rule_average_speed(BoidRule *rule,
624 BoidBrainData *bbd,
625 BoidValues *val,
626 ParticleData *pa)
627{
628 BoidParticle *bpa = pa->boid;
629 BoidRuleAverageSpeed *asbr = reinterpret_cast<BoidRuleAverageSpeed *>(rule);
630 float vec[3] = {0.0f, 0.0f, 0.0f};
631
632 if (asbr->wander > 0.0f) {
633 /* abuse pa->r_ave for wandering */
634 bpa->wander[0] += asbr->wander * (-1.0f + 2.0f * BLI_rng_get_float(bbd->rng));
635 bpa->wander[1] += asbr->wander * (-1.0f + 2.0f * BLI_rng_get_float(bbd->rng));
636 bpa->wander[2] += asbr->wander * (-1.0f + 2.0f * BLI_rng_get_float(bbd->rng));
637
638 normalize_v3(bpa->wander);
639
640 copy_v3_v3(vec, bpa->wander);
641
642 mul_qt_v3(pa->prev_state.rot, vec);
643
645
646 mul_v3_fl(bbd->wanted_co, 1.1f);
647
648 add_v3_v3(bbd->wanted_co, vec);
649
650 /* leveling */
651 if (asbr->level > 0.0f && psys_uses_gravity(bbd->sim)) {
653 mul_v3_fl(vec, asbr->level);
654 sub_v3_v3(bbd->wanted_co, vec);
655 }
656 }
657 else {
659
660 /* may happen at birth */
661 if (dot_v2v2(bbd->wanted_co, bbd->wanted_co) == 0.0f) {
662 bbd->wanted_co[0] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
663 bbd->wanted_co[1] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
664 bbd->wanted_co[2] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
665 }
666
667 /* leveling */
668 if (asbr->level > 0.0f && psys_uses_gravity(bbd->sim)) {
670 mul_v3_fl(vec, asbr->level);
671 sub_v3_v3(bbd->wanted_co, vec);
672 }
673 }
674 bbd->wanted_speed = asbr->speed * val->max_speed;
675
676 return true;
677}
678static bool rule_fight(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
679{
680 BoidRuleFight *fbr = reinterpret_cast<BoidRuleFight *>(rule);
681 KDTreeNearest<float3> *ptn = nullptr;
682 ParticleData *epars;
683 ParticleData *enemy_pa = nullptr;
684 BoidParticle *bpa;
685 /* friends & enemies */
686 float closest_enemy[3] = {0.0f, 0.0f, 0.0f};
687 float closest_dist = fbr->distance + 1.0f;
688 float f_strength = 0.0f, e_strength = 0.0f;
689 float health = 0.0f;
690 int n;
691 bool ret = false;
692
693 /* calculate its own group strength */
694 int neighbors = kdtree_range_search<float3>(
695 bbd->sim->psys->tree, pa->prev_state.co, &ptn, fbr->distance);
696 for (n = 0; n < neighbors; n++) {
697 bpa = bbd->sim->psys->particles[ptn[n].index].boid;
698 health += bpa->data.health;
699 }
700
701 f_strength += bbd->part->boids->strength * health;
702
703 MEM_SAFE_DELETE(ptn);
704
705 /* add other friendlies and calculate enemy strength and find closest enemy */
706 for (ParticleTarget &pt : bbd->sim->psys->targets) {
707 ParticleSystem *epsys = psys_get_target_system(bbd->sim->ob, &pt);
708 if (epsys && epsys->part->boids) {
709 epars = epsys->particles;
710
711 neighbors = kdtree_range_search<float3>(epsys->tree, pa->prev_state.co, &ptn, fbr->distance);
712
713 health = 0.0f;
714
715 for (n = 0; n < neighbors; n++) {
716 bpa = epars[ptn[n].index].boid;
717 health += bpa->data.health;
718
719 if (n == 0 && pt.mode == PTARGET_MODE_ENEMY && ptn[n].dist < closest_dist) {
720 copy_v3_v3(closest_enemy, ptn[n].co);
721 closest_dist = ptn[n].dist;
722 enemy_pa = epars + ptn[n].index;
723 }
724 }
725 if (pt.mode == PTARGET_MODE_ENEMY) {
726 e_strength += epsys->part->boids->strength * health;
727 }
728 else if (pt.mode == PTARGET_MODE_FRIEND) {
729 f_strength += epsys->part->boids->strength * health;
730 }
731
732 MEM_SAFE_DELETE(ptn);
733 }
734 }
735 /* decide action if enemy presence found */
736 if (e_strength > 0.0f) {
737 sub_v3_v3v3(bbd->wanted_co, closest_enemy, pa->prev_state.co);
738
739 /* attack if in range */
740 if (closest_dist <= bbd->part->boids->range + pa->size + enemy_pa->size) {
741 float damage = BLI_rng_get_float(bbd->rng);
742 float enemy_dir[3];
743
744 normalize_v3_v3(enemy_dir, bbd->wanted_co);
745
746 /* fight mode */
747 bbd->wanted_speed = 0.0f;
748
749 /* must face enemy to fight */
750 if (dot_v3v3(pa->prev_state.ave, enemy_dir) > 0.5f) {
751 bpa = enemy_pa->boid;
752 bpa->data.health -= bbd->part->boids->strength * bbd->timestep *
753 ((1.0f - bbd->part->boids->accuracy) * damage +
754 bbd->part->boids->accuracy);
755 }
756 }
757 else {
758 /* approach mode */
759 bbd->wanted_speed = val->max_speed;
760 }
761
762 /* check if boid doesn't want to fight */
763 bpa = pa->boid;
764 if (bpa->data.health / bbd->part->boids->health * bbd->part->boids->aggression <
765 e_strength / f_strength)
766 {
767 /* decide to flee */
768 if (closest_dist < fbr->flee_distance * fbr->distance) {
769 negate_v3(bbd->wanted_co);
770 bbd->wanted_speed = val->max_speed;
771 }
772 else { /* wait for better odds */
773 bbd->wanted_speed = 0.0f;
774 }
775 }
776
777 ret = true;
778 }
779
780 return ret;
781}
782
783using boid_rule_cb = bool (*)(BoidRule *rule,
785 BoidValues *val,
786 ParticleData *pa);
787
789 rule_none,
798#if 0
799 rule_help,
800 rule_protect,
801 rule_hide,
802 rule_follow_path,
803 rule_follow_wall,
804#endif
805};
806
808{
809 BoidParticle *bpa = pa->boid;
810
812 val->max_speed = boids->land_max_speed * bpa->data.health / boids->health;
813 val->max_acc = boids->land_max_acc * val->max_speed;
814 val->max_ave = boids->land_max_ave * float(M_PI) * bpa->data.health / boids->health;
815 val->min_speed = 0.0f; /* no minimum speed on land */
817 val->jump_speed = boids->land_jump_speed * bpa->data.health / boids->health;
818 }
819 else {
820 val->max_speed = boids->air_max_speed * bpa->data.health / boids->health;
821 val->max_acc = boids->air_max_acc * val->max_speed;
822 val->max_ave = boids->air_max_ave * float(M_PI) * bpa->data.health / boids->health;
823 val->min_speed = boids->air_min_speed * boids->air_max_speed;
825 val->jump_speed = 0.0f; /* no jumping in air */
826 }
827}
828
830 ParticleData *pa,
831 float ground_co[3],
832 float ground_nor[3])
833{
834 const int raycast_flag = BVH_RAYCAST_DEFAULT & ~BVH_RAYCAST_WATERTIGHT;
835 BoidParticle *bpa = pa->boid;
836
837 if (bpa->data.mode == eBoidMode_Climbing) {
838 SurfaceModifierData *surmd = nullptr;
839 float x[3], v[3];
840
841 surmd = reinterpret_cast<SurfaceModifierData *>(
843
844 /* take surface velocity into account */
845 closest_point_on_surface(surmd, pa->state.co, x, nullptr, v);
846 add_v3_v3(x, v);
847
848 /* get actual position on surface */
849 closest_point_on_surface(surmd, x, ground_co, ground_nor, nullptr);
850
851 return bpa->ground;
852 }
853
854 const float zvec[3] = {0.0f, 0.0f, 2000.0f};
856 BVHTreeRayHit hit;
857 float radius = 0.0f, t, ray_dir[3];
858
859 if (!bbd->sim->colliders) {
860 return nullptr;
861 }
862
863 memset(&col, 0, sizeof(ParticleCollision));
864
865 /* first try to find below boid */
866 copy_v3_v3(col.co1, pa->state.co);
867 sub_v3_v3v3(col.co2, pa->state.co, zvec);
868 sub_v3_v3v3(ray_dir, col.co2, col.co1);
869 col.f = 0.0f;
870 hit.index = -1;
871 hit.dist = col.original_ray_length = normalize_v3(ray_dir);
872 col.pce.inside = 0;
873
874 for (ColliderCache &coll : *bbd->sim->colliders) {
875 col.current = coll.ob;
876 col.md = coll.collmd;
877 col.fac1 = col.fac2 = 0.0f;
878
879 if (col.md && col.md->bvhtree) {
881 col.co1,
882 ray_dir,
883 radius,
884 &hit,
886 &col,
887 raycast_flag);
888 }
889 }
890 /* then use that object */
891 if (hit.index >= 0) {
892 t = hit.dist / col.original_ray_length;
893 interp_v3_v3v3(ground_co, col.co1, col.co2, t);
894 normalize_v3_v3(ground_nor, col.pce.nor);
895 return col.hit;
896 }
897
898 /* couldn't find below, so find upmost deflector object */
899 add_v3_v3v3(col.co1, pa->state.co, zvec);
900 sub_v3_v3v3(col.co2, pa->state.co, zvec);
901 sub_v3_v3(col.co2, zvec);
902 sub_v3_v3v3(ray_dir, col.co2, col.co1);
903 col.f = 0.0f;
904 hit.index = -1;
905 hit.dist = col.original_ray_length = normalize_v3(ray_dir);
906
907 for (ColliderCache &coll : *bbd->sim->colliders) {
908 col.current = coll.ob;
909 col.md = coll.collmd;
910
911 if (col.md && col.md->bvhtree) {
913 col.co1,
914 ray_dir,
915 radius,
916 &hit,
918 &col,
919 raycast_flag);
920 }
921 }
922 /* then use that object */
923 if (hit.index >= 0) {
924 t = hit.dist / col.original_ray_length;
925 interp_v3_v3v3(ground_co, col.co1, col.co2, t);
926 normalize_v3_v3(ground_nor, col.pce.nor);
927 return col.hit;
928 }
929
930 /* default to z=0 */
931 copy_v3_v3(ground_co, pa->state.co);
932 ground_co[2] = 0;
933 ground_nor[0] = ground_nor[1] = 0.0f;
934 ground_nor[2] = 1.0f;
935 return nullptr;
936}
937static bool boid_rule_applies(ParticleData *pa, BoidSettings * /*boids*/, BoidRule *rule)
938{
939 BoidParticle *bpa = pa->boid;
940
941 if (rule == nullptr) {
942 return false;
943 }
944
946 {
947 return true;
948 }
949
950 if (bpa->data.mode == eBoidMode_InAir && rule->flag & BOIDRULE_IN_AIR) {
951 return true;
952 }
953
954 return false;
955}
957{
958 for (BoidState &state : part->boids->states) {
959 for (BoidRule &rule : state.rules) {
960 if (rule.type == eBoidRuleType_FollowLeader) {
961 BoidRuleFollowLeader *flbr = reinterpret_cast<BoidRuleFollowLeader *>(&rule);
962
963 if (flbr->ob && flbr->cfra != cfra) {
964 /* save object locations for velocity calculations */
965 copy_v3_v3(flbr->oloc, flbr->loc);
966 copy_v3_v3(flbr->loc, flbr->ob->object_to_world().location());
967 flbr->cfra = cfra;
968 }
969 }
970 }
971 }
972}
973static void boid_climb(BoidSettings *boids,
974 ParticleData *pa,
975 float *surface_co,
976 float *surface_nor)
977{
978 BoidParticle *bpa = pa->boid;
979 float nor[3], vel[3];
980 copy_v3_v3(nor, surface_nor);
981
982 /* gather apparent gravity */
983 madd_v3_v3fl(bpa->gravity, surface_nor, -1.0f);
984 normalize_v3(bpa->gravity);
985
986 /* raise boid it's size from surface */
987 mul_v3_fl(nor, pa->size * boids->height);
988 add_v3_v3v3(pa->state.co, surface_co, nor);
989
990 /* remove normal component from velocity */
991 project_v3_v3v3(vel, pa->state.vel, surface_nor);
992 sub_v3_v3v3(pa->state.vel, pa->state.vel, vel);
993}
994static float boid_goal_signed_dist(float *boid_co, float *goal_co, float *goal_nor)
995{
996 float vec[3];
997
998 sub_v3_v3v3(vec, boid_co, goal_co);
999
1000 return dot_v3v3(vec, goal_nor);
1001}
1002/* wanted_co is relative to boid location */
1004 BoidBrainData *bbd, BoidRule *rule, BoidValues *val, ParticleData *pa, float fuzziness)
1005{
1006 if (rule == nullptr) {
1007 return false;
1008 }
1009
1010 if (!boid_rule_applies(pa, bbd->part->boids, rule)) {
1011 return false;
1012 }
1013
1014 if (!boid_rules[rule->type](rule, bbd, val, pa)) {
1015 return false;
1016 }
1017
1018 if (fuzziness < 0.0f || compare_len_v3v3(bbd->wanted_co,
1019 pa->prev_state.vel,
1020 fuzziness * len_v3(pa->prev_state.vel)) == 0)
1021 {
1022 return true;
1023 }
1024 return false;
1025}
1027{
1028 BoidState *state = boids->states.first();
1029 BoidParticle *bpa = pa->boid;
1030
1031 for (; state; state = state->next) {
1032 if (state->id == bpa->data.state_id) {
1033 return state;
1034 }
1035 }
1036
1037 /* for some reason particle isn't at a valid state */
1038 state = boids->states.first();
1039 if (state) {
1040 bpa->data.state_id = state->id;
1041 }
1042
1043 return state;
1044}
1045
1046#if 0 /* TODO */
1047static int boid_condition_is_true(BoidCondition *cond)
1048{
1049 return 0;
1050}
1051#endif
1052
1054{
1055 BoidRule *rule;
1056 BoidSettings *boids = bbd->part->boids;
1057 BoidValues val;
1058 BoidState *state = get_boid_state(boids, pa);
1059 BoidParticle *bpa = pa->boid;
1060 ParticleSystem *psys = bbd->sim->psys;
1061 int rand;
1062
1063 if (bpa->data.health <= 0.0f) {
1064 pa->alive = PARS_DYING;
1065 pa->dietime = bbd->cfra;
1066 return;
1067 }
1068
1069/* Planned for near future. */
1070#if 0
1071 BoidCondition *cond = state->conditions.first();
1072 for (; cond; cond = cond->next) {
1073 if (boid_condition_is_true(cond)) {
1074 pa->boid->state_id = cond->state_id;
1075 state = get_boid_state(boids, pa);
1076 break; /* only first true condition is used */
1077 }
1078 }
1079#endif
1080
1081 zero_v3(bbd->wanted_co);
1082 bbd->wanted_speed = 0.0f;
1083
1084 /* create random seed for every particle & frame */
1085 rand = int(psys_frand(psys, psys->seed + p) * 1000);
1086 rand = int(psys_frand(psys, int(bbd->cfra) + rand) * 1000);
1087
1088 set_boid_values(&val, bbd->part->boids, pa);
1089
1090 /* go through rules */
1091 switch (state->ruleset_type) {
1093 for (BoidRule &rule : state->rules) {
1094 if (apply_boid_rule(bbd, &rule, &val, pa, state->rule_fuzziness)) {
1095 break; /* only first nonzero rule that comes through fuzzy rule is applied */
1096 }
1097 }
1098 break;
1099 }
1101 /* use random rule for each particle (always same for same particle though) */
1102 const int n = state->rules.count();
1103 if (n) {
1104 rule = static_cast<BoidRule *>(BLI_findlink(&state->rules, rand % n));
1105 apply_boid_rule(bbd, rule, &val, pa, -1.0);
1106 }
1107 break;
1108 }
1110 float wanted_co[3] = {0.0f, 0.0f, 0.0f}, wanted_speed = 0.0f;
1111 int n = 0;
1112 for (BoidRule &rule : state->rules) {
1113 if (apply_boid_rule(bbd, &rule, &val, pa, -1.0f)) {
1114 add_v3_v3(wanted_co, bbd->wanted_co);
1115 wanted_speed += bbd->wanted_speed;
1116 n++;
1117 zero_v3(bbd->wanted_co);
1118 bbd->wanted_speed = 0.0f;
1119 }
1120 }
1121
1122 if (n > 1) {
1123 mul_v3_fl(wanted_co, 1.0f / float(n));
1124 wanted_speed /= float(n);
1125 }
1126
1127 copy_v3_v3(bbd->wanted_co, wanted_co);
1128 bbd->wanted_speed = wanted_speed;
1129 break;
1130 }
1131 }
1132
1133 /* decide on jumping & liftoff */
1134 if (bpa->data.mode == eBoidMode_OnLand) {
1135 /* Fuzziness makes boids capable of misjudgment. */
1136 float mul = 1.0f + state->rule_fuzziness;
1137
1138 if (boids->options & BOID_ALLOW_FLIGHT && bbd->wanted_co[2] > 0.0f) {
1139 float cvel[3], dir[3];
1140
1141 copy_v3_v3(dir, pa->prev_state.ave);
1142 normalize_v2(dir);
1143
1144 copy_v3_v3(cvel, bbd->wanted_co);
1145 normalize_v2(cvel);
1146
1147 if (dot_v2v2(cvel, dir) > 0.95f / mul) {
1149 }
1150 }
1151 else if (val.jump_speed > 0.0f) {
1152 float jump_v[3];
1153 int jump = 0;
1154
1155 /* jump to get to a location */
1156 if (bbd->wanted_co[2] > 0.0f) {
1157 float cvel[3], dir[3];
1158 float z_v, ground_v, cur_v;
1159 float len;
1160
1161 copy_v3_v3(dir, pa->prev_state.ave);
1162 normalize_v2(dir);
1163
1164 copy_v3_v3(cvel, bbd->wanted_co);
1165 normalize_v2(cvel);
1166
1167 len = len_v2(pa->prev_state.vel);
1168
1169 /* first of all, are we going in a suitable direction? */
1170 /* or at a suitably slow speed */
1171 if (dot_v2v2(cvel, dir) > 0.95f / mul || len <= state->rule_fuzziness) {
1172 /* try to reach goal at highest point of the parabolic path */
1173 cur_v = len_v2(pa->prev_state.vel);
1174 z_v = safe_sqrtf(-2.0f * bbd->sim->scene->physics_settings.gravity[2] *
1175 bbd->wanted_co[2]);
1176 ground_v = len_v2(bbd->wanted_co) *
1177 safe_sqrtf(-0.5f * bbd->sim->scene->physics_settings.gravity[2] /
1178 bbd->wanted_co[2]);
1179
1180 len = safe_sqrtf((ground_v - cur_v) * (ground_v - cur_v) + z_v * z_v);
1181
1182 if (len < val.jump_speed * mul || bbd->part->boids->options & BOID_ALLOW_FLIGHT) {
1183 jump = 1;
1184
1185 len = std::min(len, val.jump_speed);
1186
1187 copy_v3_v3(jump_v, dir);
1188 jump_v[2] = z_v;
1189 mul_v3_fl(jump_v, ground_v);
1190
1191 normalize_v3(jump_v);
1192 mul_v3_fl(jump_v, len);
1193 add_v2_v2v2(jump_v, jump_v, pa->prev_state.vel);
1194 }
1195 }
1196 }
1197
1198 /* jump to go faster */
1199 if (jump == 0 && val.jump_speed > val.max_speed && bbd->wanted_speed > val.max_speed) {
1200 /* pass */
1201 }
1202
1203 if (jump) {
1204 copy_v3_v3(pa->prev_state.vel, jump_v);
1206 }
1207 }
1208 }
1209}
1211{
1212 BoidSettings *boids = bbd->part->boids;
1213 BoidParticle *bpa = pa->boid;
1214 BoidValues val;
1215 EffectedPoint epoint;
1216 float acc[3] = {0.0f, 0.0f, 0.0f}, tan_acc[3], nor_acc[3];
1217 float dvec[3], bvec[3];
1218 float new_dir[3], new_speed;
1219 float old_dir[3], old_speed;
1220 float wanted_dir[3];
1221 float q[4], mat[3][3]; /* rotation */
1222 float ground_co[3] = {0.0f, 0.0f, 0.0f}, ground_nor[3] = {0.0f, 0.0f, 1.0f};
1223 float force[3] = {0.0f, 0.0f, 0.0f};
1224 float pa_mass = bbd->part->mass, dtime = bbd->dfra * bbd->timestep;
1225
1226 set_boid_values(&val, boids, pa);
1227
1228 /* make sure there's something in new velocity, location & rotation */
1229 copy_particle_key(&pa->state, &pa->prev_state, 0);
1230
1231 if (bbd->part->flag & PART_SIZEMASS) {
1232 pa_mass *= pa->size;
1233 }
1234
1235 /* if boids can't fly they fall to the ground */
1236 if ((boids->options & BOID_ALLOW_FLIGHT) == 0 &&
1238 psys_uses_gravity(bbd->sim))
1239 {
1241 }
1242
1243 if (bpa->data.mode == eBoidMode_Falling) {
1244 /* Falling boids are only effected by gravity. */
1245 acc[2] = bbd->sim->scene->physics_settings.gravity[2];
1246 }
1247 else {
1248 /* figure out acceleration */
1249 float landing_level = 2.0f;
1250 float level = landing_level + 1.0f;
1251 float new_vel[3];
1252
1253 if (bpa->data.mode == eBoidMode_Liftoff) {
1254 bpa->data.mode = eBoidMode_InAir;
1255 bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
1256 }
1257 else if (bpa->data.mode == eBoidMode_InAir && boids->options & BOID_ALLOW_LAND) {
1258 /* auto-leveling & landing if close to ground */
1259
1260 bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
1261
1262 /* level = how many particle sizes above ground */
1263 level = (pa->prev_state.co[2] - ground_co[2]) / (2.0f * pa->size) - 0.5f;
1264
1265 landing_level = -boids->landing_smoothness * pa->prev_state.vel[2] * pa_mass;
1266
1267 if (pa->prev_state.vel[2] < 0.0f) {
1268 if (level < 1.0f) {
1269 bbd->wanted_co[0] = bbd->wanted_co[1] = bbd->wanted_co[2] = 0.0f;
1270 bbd->wanted_speed = 0.0f;
1272 }
1273 else if (level < landing_level) {
1274 bbd->wanted_speed *= (level - 1.0f) / landing_level;
1275 bbd->wanted_co[2] *= (level - 1.0f) / landing_level;
1276 }
1277 }
1278 }
1279
1280 copy_v3_v3(old_dir, pa->prev_state.ave);
1281 new_speed = normalize_v3_v3(wanted_dir, bbd->wanted_co);
1282
1283 /* first check if we have valid direction we want to go towards */
1284 if (new_speed == 0.0f) {
1285 copy_v3_v3(new_dir, old_dir);
1286 }
1287 else {
1288 float old_dir2[2], wanted_dir2[2], nor[3], angle;
1289 copy_v2_v2(old_dir2, old_dir);
1290 normalize_v2(old_dir2);
1291 copy_v2_v2(wanted_dir2, wanted_dir);
1292 normalize_v2(wanted_dir2);
1293
1294 /* choose random direction to turn if wanted velocity */
1295 /* is directly behind regardless of z-coordinate */
1296 if (dot_v2v2(old_dir2, wanted_dir2) < -0.99f) {
1297 wanted_dir[0] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
1298 wanted_dir[1] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
1299 wanted_dir[2] = 2.0f * (0.5f - BLI_rng_get_float(bbd->rng));
1300 normalize_v3(wanted_dir);
1301 }
1302
1303 /* constrain direction with maximum angular velocity */
1304 angle = safe_acosf(dot_v3v3(old_dir, wanted_dir));
1305 angle = min_ff(angle, val.max_ave);
1306
1307 cross_v3_v3v3(nor, old_dir, wanted_dir);
1308 axis_angle_to_quat(q, nor, angle);
1309 copy_v3_v3(new_dir, old_dir);
1310 mul_qt_v3(q, new_dir);
1311 normalize_v3(new_dir);
1312
1313 /* save direction in case resulting velocity too small */
1314 axis_angle_to_quat(q, nor, angle * dtime);
1315 copy_v3_v3(pa->state.ave, old_dir);
1316 mul_qt_v3(q, pa->state.ave);
1317 normalize_v3(pa->state.ave);
1318 }
1319
1320 /* constrain speed with maximum acceleration */
1321 old_speed = len_v3(pa->prev_state.vel);
1322
1323 if (bbd->wanted_speed < old_speed) {
1324 new_speed = std::max(bbd->wanted_speed, old_speed - val.max_acc);
1325 }
1326 else {
1327 new_speed = std::min(bbd->wanted_speed, old_speed + val.max_acc);
1328 }
1329
1330 /* combine direction and speed */
1331 copy_v3_v3(new_vel, new_dir);
1332 mul_v3_fl(new_vel, new_speed);
1333
1334 /* maintain minimum flying velocity if not landing */
1335 if (level >= landing_level) {
1336 float len2 = dot_v2v2(new_vel, new_vel);
1337 float root;
1338
1339 len2 = std::max(len2, val.min_speed * val.min_speed);
1340 root = safe_sqrtf(new_speed * new_speed - len2);
1341
1342 new_vel[2] = new_vel[2] < 0.0f ? -root : root;
1343
1344 normalize_v2(new_vel);
1345 mul_v2_fl(new_vel, safe_sqrtf(len2));
1346 }
1347
1348 /* finally constrain speed to max speed */
1349 new_speed = normalize_v3(new_vel);
1350 mul_v3_fl(new_vel, std::min(new_speed, val.max_speed));
1351
1352 /* get acceleration from difference of velocities */
1353 sub_v3_v3v3(acc, new_vel, pa->prev_state.vel);
1354
1355 /* break acceleration to components */
1356 project_v3_v3v3(tan_acc, acc, pa->prev_state.ave);
1357 sub_v3_v3v3(nor_acc, acc, tan_acc);
1358 }
1359
1360 /* account for effectors */
1361 pd_point_from_particle(bbd->sim, pa, &pa->state, &epoint);
1363 bbd->sim->colliders,
1364 bbd->part->effector_weights,
1365 &epoint,
1366 force,
1367 nullptr,
1368 nullptr);
1369
1371 float length = normalize_v3(force);
1372
1373 length = std::max(0.0f, length - boids->land_stick_force);
1374
1375 mul_v3_fl(force, length);
1376 }
1377
1378 add_v3_v3(acc, force);
1379
1380 /* store smoothed acceleration for nice banking etc. */
1381 madd_v3_v3fl(bpa->data.acc, acc, dtime);
1382 mul_v3_fl(bpa->data.acc, 1.0f / (1.0f + dtime));
1383
1384 /* integrate new location & velocity */
1385
1386 /* by regarding the acceleration as a force at this stage we
1387 * can get better control although it's a bit unphysical */
1388 mul_v3_fl(acc, 1.0f / pa_mass);
1389
1390 copy_v3_v3(dvec, acc);
1391 mul_v3_fl(dvec, dtime * dtime * 0.5f);
1392
1393 copy_v3_v3(bvec, pa->prev_state.vel);
1394 mul_v3_fl(bvec, dtime);
1395 add_v3_v3(dvec, bvec);
1396 add_v3_v3(pa->state.co, dvec);
1397
1398 madd_v3_v3fl(pa->state.vel, acc, dtime);
1399
1400 // if (bpa->data.mode != eBoidMode_InAir)
1401 bpa->ground = boid_find_ground(bbd, pa, ground_co, ground_nor);
1402
1403 /* change modes, constrain movement & keep track of down vector */
1404 switch (bpa->data.mode) {
1405 case eBoidMode_Liftoff:
1406 break;
1407 case eBoidMode_InAir: {
1408 float grav[3];
1409
1410 grav[0] = 0.0f;
1411 grav[1] = 0.0f;
1412 grav[2] = bbd->sim->scene->physics_settings.gravity[2] < 0.0f ? -1.0f : 0.0f;
1413
1414 /* don't take forward acceleration into account (better banking) */
1415 if (dot_v3v3(bpa->data.acc, pa->state.vel) > 0.0f) {
1416 project_v3_v3v3(dvec, bpa->data.acc, pa->state.vel);
1417 sub_v3_v3v3(dvec, bpa->data.acc, dvec);
1418 }
1419 else {
1420 copy_v3_v3(dvec, bpa->data.acc);
1421 }
1422
1423 /* gather apparent gravity */
1424 madd_v3_v3v3fl(bpa->gravity, grav, dvec, -boids->banking);
1425 normalize_v3(bpa->gravity);
1426
1427 /* stick boid on goal when close enough */
1428 if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <=
1429 pa->size * boids->height)
1430 {
1432 bpa->ground = bbd->goal_ob;
1433 boid_find_ground(bbd, pa, ground_co, ground_nor);
1434 boid_climb(boids, pa, ground_co, ground_nor);
1435 }
1436 else if (pa->state.co[2] <= ground_co[2] + pa->size * boids->height) {
1437 /* land boid when below ground */
1438 if (boids->options & BOID_ALLOW_LAND) {
1439 pa->state.co[2] = ground_co[2] + pa->size * boids->height;
1440 pa->state.vel[2] = 0.0f;
1441 bpa->data.mode = eBoidMode_OnLand;
1442 }
1443 /* fly above ground */
1444 else if (bpa->ground) {
1445 pa->state.co[2] = ground_co[2] + pa->size * boids->height;
1446 pa->state.vel[2] = 0.0f;
1447 }
1448 }
1449 break;
1450 }
1451 case eBoidMode_Falling: {
1452 float grav[3];
1453
1454 grav[0] = 0.0f;
1455 grav[1] = 0.0f;
1456 grav[2] = bbd->sim->scene->physics_settings.gravity[2] < 0.0f ? -1.0f : 0.0f;
1457
1458 /* gather apparent gravity */
1459 madd_v3_v3fl(bpa->gravity, grav, dtime);
1460 normalize_v3(bpa->gravity);
1461
1462 if (boids->options & BOID_ALLOW_LAND) {
1463 /* stick boid on goal when close enough */
1464 if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <=
1465 pa->size * boids->height)
1466 {
1468 bpa->ground = bbd->goal_ob;
1469 boid_find_ground(bbd, pa, ground_co, ground_nor);
1470 boid_climb(boids, pa, ground_co, ground_nor);
1471 }
1472 /* land boid when really near ground */
1473 else if (pa->state.co[2] <= ground_co[2] + 1.01f * pa->size * boids->height) {
1474 pa->state.co[2] = ground_co[2] + pa->size * boids->height;
1475 pa->state.vel[2] = 0.0f;
1476 bpa->data.mode = eBoidMode_OnLand;
1477 }
1478 /* if we're falling, can fly and want to go upwards lets fly */
1479 else if (boids->options & BOID_ALLOW_FLIGHT && bbd->wanted_co[2] > 0.0f) {
1480 bpa->data.mode = eBoidMode_InAir;
1481 }
1482 }
1483 else {
1484 bpa->data.mode = eBoidMode_InAir;
1485 }
1486 break;
1487 }
1488 case eBoidMode_Climbing: {
1489 boid_climb(boids, pa, ground_co, ground_nor);
1490#if 0
1491 float nor[3];
1492 copy_v3_v3(nor, ground_nor);
1493
1494 /* Gather apparent gravity to r_ve. */
1495 madd_v3_v3fl(pa->r_ve, ground_nor, -1.0);
1496 normalize_v3(pa->r_ve);
1497
1498 /* Raise boid it's size from surface. */
1499 mul_v3_fl(nor, pa->size * boids->height);
1500 add_v3_v3v3(pa->state.co, ground_co, nor);
1501
1502 /* Remove normal component from velocity. */
1503 project_v3_v3v3(v, pa->state.vel, ground_nor);
1504 sub_v3_v3v3(pa->state.vel, pa->state.vel, v);
1505#endif
1506 break;
1507 }
1508 case eBoidMode_OnLand: {
1509 /* stick boid on goal when close enough */
1510 if (bbd->goal_ob && boid_goal_signed_dist(pa->state.co, bbd->goal_co, bbd->goal_nor) <=
1511 pa->size * boids->height)
1512 {
1514 bpa->ground = bbd->goal_ob;
1515 boid_find_ground(bbd, pa, ground_co, ground_nor);
1516 boid_climb(boids, pa, ground_co, ground_nor);
1517 }
1518 /* ground is too far away so boid falls */
1519 else if (pa->state.co[2] - ground_co[2] > 1.1f * pa->size * boids->height) {
1521 }
1522 else {
1523 /* constrain to surface */
1524 pa->state.co[2] = ground_co[2] + pa->size * boids->height;
1525 pa->state.vel[2] = 0.0f;
1526 }
1527
1528 if (boids->banking > 0.0f) {
1529 float grav[3];
1530 /* Don't take gravity's strength in to account, */
1531 /* otherwise amount of banking is hard to control. */
1532 negate_v3_v3(grav, ground_nor);
1533
1534 project_v3_v3v3(dvec, bpa->data.acc, pa->state.vel);
1535 sub_v3_v3v3(dvec, bpa->data.acc, dvec);
1536
1537 /* gather apparent gravity */
1538 madd_v3_v3v3fl(bpa->gravity, grav, dvec, -boids->banking);
1539 normalize_v3(bpa->gravity);
1540 }
1541 else {
1542 /* gather negative surface normal */
1543 madd_v3_v3fl(bpa->gravity, ground_nor, -1.0f);
1544 normalize_v3(bpa->gravity);
1545 }
1546 break;
1547 }
1548 }
1549
1550 /* save direction to state.ave unless the boid is falling */
1551 /* (boids can't effect their direction when falling) */
1552 if (bpa->data.mode != eBoidMode_Falling && len_v3(pa->state.vel) > 0.1f * pa->size) {
1553 copy_v3_v3(pa->state.ave, pa->state.vel);
1554 pa->state.ave[2] *= bbd->part->boids->pitch;
1555 normalize_v3(pa->state.ave);
1556 }
1557
1558 /* apply damping */
1560 mul_v3_fl(pa->state.vel, 1.0f - 0.2f * bbd->part->dampfac);
1561 }
1562
1563 /* calculate rotation matrix based on forward & down vectors */
1564 if (bpa->data.mode == eBoidMode_InAir) {
1565 copy_v3_v3(mat[0], pa->state.ave);
1566
1567 project_v3_v3v3(dvec, bpa->gravity, pa->state.ave);
1568 sub_v3_v3v3(mat[2], bpa->gravity, dvec);
1569 normalize_v3(mat[2]);
1570 }
1571 else {
1572 project_v3_v3v3(dvec, pa->state.ave, bpa->gravity);
1573 sub_v3_v3v3(mat[0], pa->state.ave, dvec);
1574 normalize_v3(mat[0]);
1575
1576 copy_v3_v3(mat[2], bpa->gravity);
1577 }
1578 negate_v3(mat[2]);
1579 cross_v3_v3v3(mat[1], mat[2], mat[0]);
1580
1581 /* apply rotation */
1582 mat3_to_quat_legacy(q, mat);
1583 copy_qt_qt(pa->state.rot, q);
1584}
1585
1587{
1588 BoidRule *rule = nullptr;
1589 if (type <= eBoidRuleType_None) {
1590 return nullptr;
1591 }
1592
1593 switch (type) {
1594 case eBoidRuleType_Goal:
1595 case eBoidRuleType_Avoid: {
1596 BoidRuleGoalAvoid *rule_goal = MEM_new<BoidRuleGoalAvoid>("BoidRuleGoalAvoid");
1597 rule = reinterpret_cast<BoidRule *>(rule_goal);
1598 break;
1599 }
1601 BoidRuleAvoidCollision *rule_avoid = MEM_new<BoidRuleAvoidCollision>(
1602 "BoidRuleAvoidCollision");
1603 rule_avoid->look_ahead = 2.0f;
1604 rule = reinterpret_cast<BoidRule *>(rule_avoid);
1605 break;
1606 }
1608 BoidRuleFollowLeader *rule_follow = MEM_new<BoidRuleFollowLeader>("BoidRuleFollowLeader");
1609 rule_follow->distance = 1.0f;
1610 rule = reinterpret_cast<BoidRule *>(rule_follow);
1611 break;
1612 }
1614 BoidRuleAverageSpeed *rule_avgspeed = MEM_new<BoidRuleAverageSpeed>("BoidRuleAverageSpeed");
1615 rule_avgspeed->speed = 0.5f;
1616 rule = reinterpret_cast<BoidRule *>(rule_avgspeed);
1617 break;
1618 }
1619 case eBoidRuleType_Fight: {
1620 BoidRuleFight *rule_fight = MEM_new<BoidRuleFight>("BoidRuleFight");
1621 rule_fight->distance = 100.0f;
1622 rule_fight->flee_distance = 100.0f;
1623 rule = reinterpret_cast<BoidRule *>(rule_fight);
1624 break;
1625 }
1626 default:
1627 rule = MEM_new<BoidRule>("BoidRule");
1628 break;
1629 }
1630
1631 rule->type = type;
1633 STRNCPY_UTF8(rule->name, DATA_(rna_enum_boidrule_type_items[int(type) - 1].name));
1634
1635 return rule;
1636}
1638{
1639 boids->air_max_speed = 10.0f;
1640 boids->air_max_acc = 0.5f;
1641 boids->air_max_ave = 0.5f;
1642 boids->air_personal_space = 1.0f;
1643
1644 boids->land_max_speed = 5.0f;
1645 boids->land_max_acc = 0.5f;
1646 boids->land_max_ave = 0.5f;
1647 boids->land_personal_space = 1.0f;
1648
1649 boids->options = BOID_ALLOW_FLIGHT;
1650
1651 boids->landing_smoothness = 3.0f;
1652 boids->banking = 1.0f;
1653 boids->pitch = 1.0f;
1654 boids->height = 1.0f;
1655
1656 boids->health = 1.0f;
1657 boids->accuracy = 1.0f;
1658 boids->aggression = 2.0f;
1659 boids->range = 1.0f;
1660 boids->strength = 0.1f;
1661}
1662
1664{
1665 BoidState *state = MEM_new<BoidState>("BoidState");
1666
1667 state->id = boids->last_state_id++;
1668 if (state->id) {
1669 SNPRINTF_UTF8(state->name, "State %i", state->id);
1670 }
1671 else {
1672 STRNCPY_UTF8(state->name, "State");
1673 }
1674
1675 state->rule_fuzziness = 0.5;
1676 state->volume = 1.0f;
1677 state->channels |= ~0;
1678
1679 return state;
1680}
1681
1683{
1684 BoidState *staten = MEM_dupalloc(state);
1685
1686 BLI_duplicatelist(&staten->rules, &state->rules);
1687 BLI_duplicatelist(&staten->conditions, &state->conditions);
1688 BLI_duplicatelist(&staten->actions, &state->actions);
1689
1690 staten->id = boids->last_state_id++;
1691
1692 return staten;
1693}
1695{
1696 if (boids) {
1697 BoidState *state = boids->states.first();
1698
1699 for (; state; state = state->next) {
1700 state->rules.free_no_destruct();
1701 BLI_freelistN(&state->conditions);
1702 BLI_freelistN(&state->actions);
1703 }
1704
1705 boids->states.free_no_destruct();
1706
1707 MEM_delete(boids);
1708 }
1709}
1711{
1712 BoidSettings *nboids = nullptr;
1713
1714 if (boids) {
1716 BoidState *nstate;
1717
1718 nboids = MEM_dupalloc(boids);
1719
1720 BLI_duplicatelist(&nboids->states, &boids->states);
1721
1722 state = boids->states.first();
1723 nstate = nboids->states.first();
1724 for (; state; state = state->next, nstate = nstate->next) {
1725 BLI_duplicatelist(&nstate->rules, &state->rules);
1726 BLI_duplicatelist(&nstate->conditions, &state->conditions);
1727 BLI_duplicatelist(&nstate->actions, &state->actions);
1728 }
1729 }
1730
1731 return nboids;
1732}
1734{
1735 BoidState *state = boids->states.first();
1736
1737 for (; state; state = state->next) {
1738 if (state->flag & BOIDSTATE_CURRENT) {
1739 break;
1740 }
1741 }
1742
1743 return state;
1744}
1745
1746} // namespace blender
#define BVH_RAYCAST_DEFAULT
A KD-tree for nearest neighbor search.
#define M_PI
Random number functions.
#define SNPRINTF_UTF8(dst, format,...)
#define STRNCPY_UTF8(dst, src)
#define DATA_(msgid)
#define BOIDSTATE_CURRENT
#define BRULE_LEADER_IN_LINE
Read Blender memory allocation and freeing.
#define ARRAY_HAS_ITEM(arr_item, arr_start, arr_len)
#define ELEM(...)
void jump(const btVector3 &v=btVector3(0, 0, 0))
SIMD_FORCE_INLINE btScalar angle(const btVector3 &v) const
Return the angle between this and another vector.
Definition btVector3.h:356
#define powf(x, y)
float length(VecOp< float, D >) RET
const int state
ccl_device_inline dual1 len(const ccl_private dual< T > &a)
Definition math_dual.h:263
BMesh Iterators.
MINLINE float min_ff(float a, float b)
MINLINE void madd_v3_v3v3fl(float r[3], const float a[3], const float b[3], float f)
int kdtree_find_nearest_n_with_len_squared_cb(const KDTree< CoordT > *tree, const CoordT &co, KDTreeNearest< CoordT > r_nearest[], const uint nearest_len_capacity, Func &&len_sq_fn)
BLI_assert(slot->slot_subtype.map==BMO_OP_SLOT_SUBTYPE_MAP_FLT)
MINLINE void negate_v3_v3(float r[3], const float a[3])
static bool rule_none(BoidRule *, BoidBrainData *, BoidValues *, ParticleData *)
Definition boids.cc:67
static bool rule_average_speed(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:623
struct ParticleSystem * psys_get_target_system(struct Object *ob, struct ParticleTarget *pt)
MINLINE float safe_sqrtf(float a)
MINLINE void copy_v3_v3(float r[3], const float a[3])
MINLINE void add_v2_v2v2(float r[2], const float a[2], const float b[2])
MINLINE void add_v3_v3v3(float r[3], const float a[3], const float b[3])
MINLINE void mul_v2_fl(float r[2], float f)
void void void void void void BLI_duplicatelist(ListBase *dst, const ListBase *src) ATTR_NONNULL(1
Definition listbase.cc:834
MINLINE void copy_v2_v2(float r[2], const float a[2])
struct BoidState * boid_duplicate_state(struct BoidSettings *boids, struct BoidState *state)
Definition boids.cc:1682
int kdtree_range_search_with_len_squared_cb(const KDTree< CoordT > *tree, const CoordT &co, KDTreeNearest< CoordT > **r_nearest, const typename KDTree< CoordT >::ValueType range, Func &&len_sq_fn)
int BLI_bvhtree_ray_cast_ex(const BVHTree *tree, const float co[3], const float dir[3], float radius, BVHTreeRayHit *hit, BVHTree_RayCastCallback callback, void *userdata, int flag)
static float boid_goal_signed_dist(float *boid_co, float *goal_co, float *goal_nor)
Definition boids.cc:994
void boid_brain(BoidBrainData *bbd, int p, struct ParticleData *pa)
Definition boids.cc:1053
MINLINE float safe_acosf(float a)
void pd_point_from_particle(struct ParticleSimulationData *sim, struct ParticleData *pa, struct ParticleKey *state, struct EffectedPoint *point)
Definition effect.cc:388
void axis_angle_to_quat(float r[4], const float axis[3], float angle)
void BKE_effectors_apply(ListBaseT< EffectorCache > *effectors, ListBaseT< ColliderCache > *colliders, struct EffectorWeights *weights, struct EffectedPoint *point, float *force, float *wind_force, float *impulse)
Definition effect.cc:1134
MINLINE float normalize_v2(float n[2])
static Object * boid_find_ground(BoidBrainData *bbd, ParticleData *pa, float ground_co[3], float ground_nor[3])
Definition boids.cc:829
ATTR_WARN_UNUSED_RESULT const BMVert * v
@ BOID_ALLOW_FLIGHT
void boids_precalc_rules(struct ParticleSettings *part, float cfra)
Definition boids.cc:956
static bool rule_separate(BoidRule *, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:401
void boid_default_settings(struct BoidSettings *boids)
Definition boids.cc:1637
MINLINE void mul_v3_fl(float r[3], float f)
static auto len_squared_v3v3_with_normal_bias_fn(const float3 &normal)
Definition boids.cc:41
static void set_boid_values(BoidValues *val, BoidSettings *boids, ParticleData *pa)
Definition boids.cc:807
float effector_falloff(struct EffectorCache *eff, struct EffectorData *efd, struct EffectedPoint *point, struct EffectorWeights *weights)
Definition effect.cc:596
void project_v3_v3v3(float out[3], const float p[3], const float v_proj[3])
static bool rule_goal_avoid(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:75
MINLINE void sub_v3_v3(float r[3], const float a[3])
static bool boid_rule_applies(ParticleData *pa, BoidSettings *, BoidRule *rule)
Definition boids.cc:937
void mul_qt_v3(const float q[4], float r[3])
MINLINE void madd_v3_v3fl(float r[3], const float a[3], float f)
void * BLI_findlink(const ListBase *listbase, int number) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition listbase.cc:541
static bool rule_avoid_collision(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:211
struct BoidSettings * boid_copy_settings(const struct BoidSettings *boids)
void void BLI_freelistN(ListBase *listbase) ATTR_NONNULL(1)
Definition listbase.cc:504
MINLINE void cross_v3_v3v3(float r[3], const float a[3], const float b[3])
void copy_qt_qt(float q[4], const float a[4])
BMesh const char void * data
struct BoidRule * boid_new_rule(eBoidRuleType type)
Definition boids.cc:1586
static boid_rule_cb boid_rules[]
Definition boids.cc:788
static bool apply_boid_rule(BoidBrainData *bbd, BoidRule *rule, BoidValues *val, ParticleData *pa, float fuzziness)
Definition boids.cc:1003
bool get_effector_data(struct EffectorCache *eff, struct EffectorData *efd, struct EffectedPoint *point, int real_velocity)
Definition effect.cc:697
void BKE_psys_collision_neartest_cb(void *userdata, int index, const struct BVHTreeRay *ray, struct BVHTreeRayHit *hit)
void mat3_to_quat_legacy(float q[4], const float wmat[3][3])
@ BRULE_ACOLL_WITH_BOIDS
@ BRULE_ACOLL_WITH_DEFLECTORS
constexpr size_t ARRAY_SIZE(const T(&arg)[N]) noexcept
MINLINE void negate_v3(float r[3])
void interp_v3_v3v3(float r[3], const float a[3], const float b[3], float t)
static BoidState * get_boid_state(BoidSettings *boids, ParticleData *pa)
Definition boids.cc:1026
const EnumPropertyItem rna_enum_boidrule_type_items[]
Definition rna_boid.cc:24
MINLINE float len_v3(const float a[3]) ATTR_WARN_UNUSED_RESULT
static bool rule_follow_leader(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:481
MINLINE void zero_v3(float r[3])
MINLINE float dot_v2v2(const float a[2], const float b[2]) ATTR_WARN_UNUSED_RESULT
@ BVH_RAYCAST_WATERTIGHT
float BLI_rng_get_float(struct RNG *rng) ATTR_WARN_UNUSED_RESULT ATTR_NONNULL(1)
Definition rand.cc:90
MINLINE float normalize_v3_v3(float r[3], const float a[3])
@ BRULE_GOAL_AVOID_PREDICT
MINLINE float normalize_v3(float n[3])
ModifierData * BKE_modifiers_findby_type(const Object *ob, ModifierType type)
MINLINE void add_v3_v3(float r[3], const float a[3])
MINLINE void sub_v3_v3v3(float r[3], const float a[3], const float b[3])
void boid_free_settings(struct BoidSettings *boids)
Definition boids.cc:1694
static bool rule_flock(BoidRule *, BoidBrainData *bbd, BoidValues *, ParticleData *pa)
Definition boids.cc:445
struct BoidState * boid_new_state(struct BoidSettings *boids)
Definition boids.cc:1663
MINLINE float len_squared_v3(const float v[3]) ATTR_WARN_UNUSED_RESULT
int kdtree_range_search(const KDTree< CoordT > *tree, const CoordT &co, KDTreeNearest< CoordT > **r_nearest, typename KDTree< CoordT >::ValueType range)
void boid_body(BoidBrainData *bbd, struct ParticleData *pa)
Definition boids.cc:1210
bool closest_point_on_surface(struct SurfaceModifierData *surmd, const float co[3], float surface_co[3], float surface_nor[3], float surface_vel[3])
Definition effect.cc:645
struct BoidState * boid_get_current_state(struct BoidSettings *boids)
Definition boids.cc:1733
MINLINE float len_v2(const float v[2]) ATTR_WARN_UNUSED_RESULT
VecBase< float, 3 > float3
BLI_INLINE float psys_frand(ParticleSystem *psys, unsigned int seed)
static bool rule_fight(BoidRule *rule, BoidBrainData *bbd, BoidValues *val, ParticleData *pa)
Definition boids.cc:678
int psys_uses_gravity(struct ParticleSimulationData *sim)
Definition particle.cc:858
@ eBoidRulesetType_Random
@ eBoidRulesetType_Fuzzy
@ eBoidRulesetType_Average
static void boid_climb(BoidSettings *boids, ParticleData *pa, float *surface_co, float *surface_nor)
Definition boids.cc:973
MINLINE float dot_v3v3(const float a[3], const float b[3]) ATTR_WARN_UNUSED_RESULT
@ eBoidRuleType_AverageSpeed
@ eBoidRuleType_Avoid
@ eBoidRuleType_Fight
@ eBoidRuleType_Goal
@ eBoidRuleType_None
@ eBoidRuleType_FollowLeader
@ eBoidRuleType_AvoidCollision
@ eBoidMode_Climbing
@ eBoidMode_Falling
@ eBoidMode_Liftoff
void copy_particle_key(struct ParticleKey *to, struct ParticleKey *from, int time)
Definition particle.cc:3778
MINLINE bool compare_len_v3v3(const float v1[3], const float v2[3], float limit) ATTR_WARN_UNUSED_RESULT
bool(*)(BoidRule *rule, BoidBrainData *data, BoidValues *val, ParticleData *pa) boid_rule_cb
Definition boids.cc:783
#define sqrtf
KERNEL_FEATURE_LIGHT_PASSES KERNEL_FEATURE_PATH_GUIDING float
struct Object * goal_ob
Definition BKE_boids.h:30
struct ParticleSimulationData * sim
Definition BKE_boids.h:24
struct ParticleSettings * part
Definition BKE_boids.h:25
eBoidRuleAvoidCollision_Option options
eBoidRuleGoalAvoid_Option options
eBoidRuleGoalAvoid_Option options
eBoidRule_Flag flag
eBoidRuleType type
ListBaseT< BoidState > states
ListBaseT< BoidRule > rules
struct BoidState * next
float personal_space
Definition boids.cc:61
struct CollisionModifierData * collmd
struct Object * ob
Definition BKE_effect.h:76
struct Scene * scene
Definition BKE_effect.h:75
struct PartDeflect * pd
Definition BKE_effect.h:80
struct Depsgraph * depsgraph
Definition BKE_effect.h:74
ParticleCollisionElement pce
struct CollisionModifierData * md
eParticle_AliveState alive
struct BoidSettings * boids
struct EffectorWeights * effector_weights
ListBaseT< ColliderCache > * colliders
struct ParticleSystem * psys
ListBaseT< ParticleTarget > targets
struct ListBaseT< struct EffectorCache > * effectors
eParticleTarget_Mode mode
struct PhysicsSettings physics_settings