Lamp-Da 0.1
A compact lantern project
Loading...
Searching...
No Matches
particle_system.hpp
Go to the documentation of this file.
1
5#ifndef PARTICLE_SYSTEM_H
6#define PARTICLE_SYSTEM_H
7
8#include <algorithm>
9#include <array>
10#include <cmath>
11#include <cstdint>
12#include <etl/bitset.h>
13#include <initializer_list>
14
15#include "src/system/ext/random8.h"
16
18
19#include "particle.hpp"
20
21namespace lampda::modes {
22
23using LampTy = hardware::LampTy;
24
29template<size_t MaxParticuleCount> class ParticleSystem
30{
31public:
32 ParticleSystem() : particuleCount(0) { reset(); }
33 ParticleSystem(const ParticleSystem&) = delete;
34
38 void reset()
39 {
40 isOccupiedSpaces.reset();
41 isAllocated.reset();
42 isResting.reset();
43 }
44
49 void set_max_particle_count(const uint16_t _particleCount)
50 {
51 particuleCount = std::min<uint16_t>(ParticleSystem::maxParticuleCount, _particleCount);
52 reset();
53 }
54
59 template<typename PositionGeneratorFunction>
60 void init_particules(const PositionGeneratorFunction& positionGeneratorFunction,
61 const uint32_t color = colors::HTMLColorCode::White)
62 {
63 static_assert(std::is_invocable_r_v<int16_t, PositionGeneratorFunction, size_t>);
64
65 isOccupiedSpaces.reset();
66 isAllocated.reset();
67 isResting.reset();
68 for (size_t i = 0; i < particuleCount; ++i)
69 {
70 spawn_particule(i, positionGeneratorFunction, color);
71 }
72 }
73
79 template<typename PositionGeneratorFunction>
80 bool init_deferred_particules(uint8_t maxParticlesToPop, const PositionGeneratorFunction& positionGeneratorFunction)
81 {
82 static_assert(std::is_invocable_r_v<int16_t, PositionGeneratorFunction, size_t>);
83
84 const auto colorGeneratorFunction = [](const size_t) -> uint32_t {
86 };
87 return init_deferred_particules(maxParticlesToPop, positionGeneratorFunction, colorGeneratorFunction);
88 }
89
96 template<typename PositionGeneratorFunction, typename ColorGeneratorFunction>
97 bool init_deferred_particules(uint8_t maxParticlesToPop,
98 const PositionGeneratorFunction& positionGeneratorFunction,
99 const ColorGeneratorFunction& colorGeneratorFunction)
100 {
101 static_assert(std::is_invocable_r_v<int16_t, PositionGeneratorFunction, size_t>);
102 static_assert(std::is_invocable_r_v<uint32_t, ColorGeneratorFunction, size_t>);
103
104 for (size_t i = 0; i < particuleCount and maxParticlesToPop > 0; ++i)
105 {
106 if (isAllocated[i])
107 {
108 // already allocated, do not reuse
109 continue;
110 }
111 spawn_particule(i, positionGeneratorFunction, colorGeneratorFunction(i));
112 maxParticlesToPop--;
113 }
114 // still some uncreated particles
115 return maxParticlesToPop > 0;
116 }
117
124 void iterate_no_collisions(const utils::vec3d& accelerationCartesian,
125 const float deltaTime_s,
126 const bool shouldContrain = true)
127 {
128 for (size_t i = 0; i < particuleCount; ++i)
129 {
130 // do not iterate non allocated particles
131 if (not isAllocated[i])
132 continue;
133
134 Particle& p = particules[i];
135 // apply force and constrain
136 p.apply_acceleration(accelerationCartesian, deltaTime_s, shouldContrain);
137 }
138 }
139
148 void iterate_with_collisions(const utils::vec3d& accelerationCartesian,
149 const float deltaTime_s,
150 const bool shouldContrain = true,
151 const float viscosity = sandViscosity)
152 {
153 update_occupation();
154
155 frameIndex += 1;
156 const uint8_t flowReach = 1 + static_cast<uint8_t>((1.0f - viscosity) * maxFlowReach + 0.5f);
157
158 for (size_t i = 0; i < particuleCount; ++i)
159 {
160 // do not iterate non allocated particles
161 if (not isAllocated[i])
162 continue;
163
164 // spread the resting particles over the frames. A support that disappears is seen a few frames late, at worst
165 if (isResting[i] and ((i + frameIndex) % restingUpdatePeriod) != 0)
166 continue;
167
168 const utils::vec2d& drive = particules[i].update_speed(accelerationCartesian, deltaTime_s);
169 move_with_collisions(i, accelerationCartesian, drive, deltaTime_s, shouldContrain, flowReach);
170 }
171 }
172
179 template<typename ShouldDepopFunction> uint16_t depop_particules(const ShouldDepopFunction& shouldDepopFunction)
180 {
181 static_assert(std::is_invocable_r_v<bool, ShouldDepopFunction, Particle const&>);
182
183 uint16_t particleCount = 0;
184 for (size_t i = 0; i < particuleCount; ++i)
185 {
186 // do not depop non allocated particles
187 if (not isAllocated[i])
188 continue;
189
190 const auto& parti = particules[i];
191 if (shouldDepopFunction(parti))
192 {
193 isAllocated[i] = false;
194 if (parti._savedLampIndex >= 0 && parti._savedLampIndex < isOccupiedSpaces.size())
195 isOccupiedSpaces[parti._savedLampIndex] = false;
196 }
197 else
198 {
199 particleCount += 1;
200 }
201 }
202 return particleCount;
203 }
204
209 template<typename ShouldDepopFunction>
210 uint16_t depop_particules_indexed(const ShouldDepopFunction& shouldDepopFunction)
211 {
212 static_assert(std::is_invocable_r_v<bool, ShouldDepopFunction, size_t, Particle const&>);
213
214 uint16_t remaining = 0;
215 for (size_t i = 0; i < particuleCount; ++i)
216 {
217 if (not isAllocated[i])
218 continue;
219
220 const auto& parti = particules[i];
221 if (shouldDepopFunction(i, parti))
222 {
223 isAllocated[i] = false;
224 if (parti._savedLampIndex >= 0 && parti._savedLampIndex < isOccupiedSpaces.size())
225 isOccupiedSpaces[parti._savedLampIndex] = false;
226 }
227 else
228 {
229 remaining += 1;
230 }
231 }
232 return remaining;
233 }
234
240 template<typename SampleColorFunction>
241 uint16_t show(const SampleColorFunction& sample_color, LampTy& lamp, const bool forceDisplay = false) const
242 {
243 static_assert(std::is_invocable_r_v<uint32_t, SampleColorFunction, int16_t, Particle const&>);
244
245 uint16_t particleCount = 0;
246 for (int16_t i = 0; i < particuleCount; ++i)
247 {
248 // do not show non allocated particles
249 if (not isAllocated[i])
250 continue;
251 const auto& particle = particules[i];
252 const auto& index = particle._savedLampIndex;
253 if (modes::is_led_index_valid(index))
254 {
255 if (forceDisplay)
256 lamp.mask_led_at_index(index, false);
257 lamp.setPixelColor(index, sample_color(i, particle));
258 }
259 else
260 particleCount += 1;
261 }
262 return particleCount;
263 }
264
265 uint16_t show(LampTy& lamp, const bool forceDisplay = false) const
266 {
267 return show(
268 [](int16_t, const Particle& particle) {
269 return particle.get_color();
270 },
271 lamp,
272 forceDisplay);
273 }
274
276 uint16_t get_number_of_active() const
277 {
278 uint16_t particleCount = 0;
279 for (size_t i = 0; i < particuleCount; ++i)
280 {
281 // do not show non allocated particles
282 if (not isAllocated[i])
283 continue;
284 particleCount += 1;
285 }
286 return particleCount;
287 }
288
289protected:
291 bool is_position_taken(const int16_t pos) const
292 {
293 if (pos < 0 or pos >= isOccupiedSpaces.size())
294 return false;
295 return isOccupiedSpaces[pos];
296 }
297
303 template<typename PositiongeneratorFunction>
304 void spawn_particule(const size_t index,
305 const PositiongeneratorFunction& positionGeneratorFunction,
306 const uint32_t color)
307 {
308 static_assert(std::is_invocable_r_v<int16_t, PositiongeneratorFunction, size_t>);
309
310 int16_t pos = positionGeneratorFunction(index);
311 int maxTries = 3;
312 while (ParticleSystem::is_position_taken(pos) and maxTries > 0)
313 {
314 pos = positionGeneratorFunction(index);
315 maxTries--;
316 }
317 // generate start position from user function
318 const auto& helixCoordinates = modes::strip_to_helix_unconstraint(pos);
319 particules[index] = Particle(utils::vec3d {helixCoordinates.x, helixCoordinates.y, helixCoordinates.z});
320 particules[index].set_color(color);
321 if (index < isAllocated.size())
322 {
323 isAllocated[index] = true;
324 isResting[index] = false;
325 }
326 const int16_t ledIndex = particules[index]._savedLampIndex;
327 if (ledIndex >= 0 && ledIndex < isOccupiedSpaces.size())
328 isOccupiedSpaces[ledIndex] = true;
329 }
330
331private:
332 static constexpr float sandViscosity = 0.75f;
333 static constexpr float contactDampening = 0.5f;
334 static constexpr float minFlowDropRatio = 0.25f;
335 static constexpr float maxCollisionSpeed_mmS = 1300.0f;
336 static constexpr uint8_t maxFlowReach = 12;
337 static constexpr uint8_t restingUpdatePeriod = 4;
338
340 void update_occupation()
341 {
342 isOccupiedSpaces.reset();
343 for (size_t i = 0; i < particuleCount; ++i)
344 {
345 const int16_t ledIndex = particules[i]._savedLampIndex;
346 if (isAllocated[i] and modes::is_led_index_valid(ledIndex))
347 isOccupiedSpaces[ledIndex] = true;
348 }
349 }
350
352 bool is_led_blocked(const int16_t fromIndex, const int16_t toIndex, const bool shouldContrain) const
353 {
354 if (modes::is_led_index_valid(toIndex))
355 return isOccupiedSpaces[toIndex];
356 // the strip ends act as walls. Let a particle that is out of the strip get back in
357 return shouldContrain and modes::is_led_index_valid(fromIndex);
358 }
359
361 void move_particle(const size_t slot, const utils::vec2d& offset_mm, const int16_t toIndex)
362 {
363 Particle& particle = particules[slot];
364 const int16_t fromIndex = particle._savedLampIndex;
365 if (toIndex != fromIndex)
366 {
367 // a particle sharing the old led makes it look free until the next update_occupation: this is only visual
368 if (modes::is_led_index_valid(fromIndex))
369 isOccupiedSpaces[fromIndex] = false;
370 if (modes::is_led_index_valid(toIndex))
371 isOccupiedSpaces[toIndex] = true;
372 }
373 particle.move_by(offset_mm, toIndex);
374 }
375
386 void move_with_collisions(const size_t slot,
387 const utils::vec3d& acceleration,
388 const utils::vec2d& drive,
389 const float deltaTime_s,
390 const bool shouldContrain,
391 const uint8_t flowReach)
392 {
393 Particle& particle = particules[slot];
394
395 utils::vec2d step = particle.get_surface_speed().multiply(deltaTime_s);
396 const float longestAxis_mm = std::max(fabsf(step.x), fabsf(step.y));
397 const float maxStep_mm = maxCollisionSpeed_mmS * deltaTime_s;
398 if (longestAxis_mm > maxStep_mm)
399 step = step.multiply(maxStep_mm / longestAxis_mm);
400
401 const int16_t fromIndex = particle._savedLampIndex;
402 const int16_t toIndex = particle.led_index_at_offset(step);
403 if (toIndex == fromIndex or not is_led_blocked(fromIndex, toIndex, shouldContrain))
404 {
405 move_particle(slot, step, toIndex);
406 isResting[slot] = false;
407 return;
408 }
409
410 particle.dampen_speed(contactDampening);
411 // only the acceleration can make a particle flow, or the rebounds would agitate the piles forever
412 const bool hasFlowed =
413 drive.dot(step) > 0.0f and flow_around_obstacle(slot, acceleration, drive, shouldContrain, flowReach);
414 isResting[slot] = not hasFlowed;
415 }
416
428 bool flow_around_obstacle(const size_t slot,
429 const utils::vec3d& acceleration,
430 const utils::vec2d& drive,
431 const bool shouldContrain,
432 const uint8_t flowReach)
433 {
434 const Particle& particle = particules[slot];
435 const int16_t fromIndex = particle._savedLampIndex;
436
437 const utils::vec2d& downhill = drive.multiply(1.0f / sqrtf(drive.dot(drive)));
438 const utils::vec2d& oneLedDown = downhill.multiply(led_span_along(downhill));
439 const utils::vec2d sideDirection(-downhill.y, downhill.x);
440 const utils::vec2d& oneLedAside = sideDirection.multiply(led_span_along(sideDirection));
441
442 // no side preference, or the piles would lean over time
443 const float firstSide = (random8() & 1) ? 1.0f : -1.0f;
444 for (uint8_t distance = 1; distance <= flowReach; ++distance)
445 {
446 // only the surface flows far: it spares the scans for the many particles buried in a pile
447 if (distance == 2 and
448 is_led_blocked(fromIndex, particle.led_index_at_offset(oneLedDown.multiply(-1.0f)), shouldContrain))
449 return false;
450
451 for (const float side: {firstSide, -firstSide})
452 {
453 const utils::vec2d& gapOffset = oneLedAside.multiply(side * distance).add(oneLedDown);
454 const int16_t gapIndex = particle.led_index_at_offset(gapOffset);
455 if (gapIndex != fromIndex and not is_led_blocked(fromIndex, gapIndex, shouldContrain) and
456 is_flow_worth_it(acceleration, fromIndex, gapIndex))
457 {
458 move_particle(slot, gapOffset, gapIndex);
459 return true;
460 }
461 }
462 }
463 return false;
464 }
465
468 static bool is_flow_worth_it(const utils::vec3d& acceleration, const int16_t fromIndex, const int16_t toIndex)
469 {
470 const float minDrop = minFlowDropRatio * rowHeight_mm * sqrtf(acceleration.dot(acceleration));
471 return Particle::potential_at_led(acceleration, toIndex) <
472 Particle::potential_at_led(acceleration, fromIndex) - minDrop;
473 }
474
476 static float led_span_along(const utils::vec2d& direction)
477 {
478 return fabsf(direction.x) * ledLength_mm + fabsf(direction.y) * rowHeight_mm;
479 }
480
481 static constexpr uint16_t maxParticuleCount = MaxParticuleCount;
482 std::array<Particle, maxParticuleCount> particules;
483 etl::bitset<maxParticuleCount> isAllocated;
484 etl::bitset<maxParticuleCount> isResting;
485 etl::bitset<LampTy::ledCount> isOccupiedSpaces;
486 uint8_t frameIndex = 0;
487
489 uint16_t particuleCount;
490};
491
492} // namespace lampda::modes
493
494#endif
Define a particle system ALL PARTICLE SYSTEM SHARE THE SAME PARTICLE SUBSET.
Definition: particle_system.hpp:30
void init_particules(const PositionGeneratorFunction &positionGeneratorFunction, const uint32_t color=colors::HTMLColorCode::White)
Init the particles from a initialization function.
Definition: particle_system.hpp:60
void iterate_no_collisions(const utils::vec3d &accelerationCartesian, const float deltaTime_s, const bool shouldContrain=true)
Advance the particle simulation, ignoring collisions.
Definition: particle_system.hpp:124
uint16_t get_number_of_active() const
Return the number of active particles.
Definition: particle_system.hpp:276
void iterate_with_collisions(const utils::vec3d &accelerationCartesian, const float deltaTime_s, const bool shouldContrain=true, const float viscosity=sandViscosity)
Advance the particle simulation, taking collisions in account. A led holds one particle,...
Definition: particle_system.hpp:148
uint16_t depop_particules_indexed(const ShouldDepopFunction &shouldDepopFunction)
Same as depop_particules, but the predicate also receives the particle slot index.
Definition: particle_system.hpp:210
uint16_t depop_particules(const ShouldDepopFunction &shouldDepopFunction)
Filter particles depending on condition.
Definition: particle_system.hpp:179
bool init_deferred_particules(uint8_t maxParticlesToPop, const PositionGeneratorFunction &positionGeneratorFunction, const ColorGeneratorFunction &colorGeneratorFunction)
Init the particles from a initialization function, in a timed defered way.
Definition: particle_system.hpp:97
bool init_deferred_particules(uint8_t maxParticlesToPop, const PositionGeneratorFunction &positionGeneratorFunction)
Init the particles from a initialization function, in a timed defered way.
Definition: particle_system.hpp:80
void spawn_particule(const size_t index, const PositiongeneratorFunction &positionGeneratorFunction, const uint32_t color)
Spawn a particle.
Definition: particle_system.hpp:304
void reset()
reset system to zero count
Definition: particle_system.hpp:38
bool is_position_taken(const int16_t pos) const
Return True if the position is already occupied.
Definition: particle_system.hpp:291
uint16_t show(const SampleColorFunction &sample_color, LampTy &lamp, const bool forceDisplay=false) const
Display this particle system.
Definition: particle_system.hpp:241
void set_max_particle_count(const uint16_t _particleCount)
Call when you want to change the particle count of the simulation Can be called once when starting th...
Definition: particle_system.hpp:49
Define the main led strip interaction object.
@ White
Definition: palettes.hpp:231
Contains basic interface types to implement custom user modes.
Definition: control_fixed_modes.hpp:14
hardware::LampTy LampTy
Define a particle in cylindrical space, and movement equations on the cylinder surface.
Definition: particle.hpp:22
static constexpr float rowHeight_mm
height gained by the helix in one turn
Definition: particle.hpp:34
static constexpr bool is_led_index_valid(const int16_t ledIndex)
True if the given strip index is a valid one.
Definition: lamp_type.hpp:1313
static constexpr HelixXYZTy strip_to_helix_unconstraint(const int16_t n)
convert strip index to 3D coordinates, without checks on led index. This allows to use 3D coordinates...
Definition: lamp_type.hpp:1302
static constexpr float ledLength_mm
length of a led along the strip
Definition: particle.hpp:35
Define a single particle for a particle system.
Define a particle in 3D space. it has a position and speed.
Definition: particle.hpp:44
void apply_acceleration(const utils::vec3d &accelerationCartesian_m, const float deltaTime_s, const bool shouldContrain=true)
apply a cartesian acceleration to this particulate
Definition: particle.hpp:107
static float potential_at_led(const utils::vec3d &accelerationCartesian_m, const int16_t ledIndex)
Potential energy of a led under an acceleration, consistent with the acceleration of a particle.
Definition: particle.hpp:236
Main interface between the user and the hardware of the lamp.
Definition: lamp_type.hpp:120
void LMBD_INLINE mask_led_at_index(const size_t n, const bool shouldMask)
Mark a led to be masked at the next show.
Definition: lamp_type.hpp:993
void LMBD_INLINE setPixelColor(uint16_t n, uint32_t color)
(indexable) Set the n-th LED color
Definition: lamp_type.hpp:1014
2d vector in any space
Definition: vector_math.h:15
float x
x coordinate in 2D
Definition: vector_math.h:16
3d vector in any space
Definition: vector_math.h:54