5#ifndef PARTICLE_SYSTEM_H
6#define PARTICLE_SYSTEM_H
12#include <etl/bitset.h>
13#include <initializer_list>
15#include "src/system/ext/random8.h"
23using LampTy = hardware::LampTy;
40 isOccupiedSpaces.reset();
51 particuleCount = std::min<uint16_t>(ParticleSystem::maxParticuleCount, _particleCount);
59 template<
typename PositionGeneratorFunction>
63 static_assert(std::is_invocable_r_v<int16_t, PositionGeneratorFunction, size_t>);
65 isOccupiedSpaces.reset();
68 for (
size_t i = 0; i < particuleCount; ++i)
79 template<
typename PositionGeneratorFunction>
82 static_assert(std::is_invocable_r_v<int16_t, PositionGeneratorFunction, size_t>);
84 const auto colorGeneratorFunction = [](
const size_t) -> uint32_t {
96 template<
typename PositionGeneratorFunction,
typename ColorGeneratorFunction>
98 const PositionGeneratorFunction& positionGeneratorFunction,
99 const ColorGeneratorFunction& colorGeneratorFunction)
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>);
104 for (
size_t i = 0; i < particuleCount and maxParticlesToPop > 0; ++i)
111 spawn_particule(i, positionGeneratorFunction, colorGeneratorFunction(i));
115 return maxParticlesToPop > 0;
125 const float deltaTime_s,
126 const bool shouldContrain =
true)
128 for (
size_t i = 0; i < particuleCount; ++i)
131 if (not isAllocated[i])
149 const float deltaTime_s,
150 const bool shouldContrain =
true,
151 const float viscosity = sandViscosity)
156 const uint8_t flowReach = 1 +
static_cast<uint8_t
>((1.0f - viscosity) * maxFlowReach + 0.5f);
158 for (
size_t i = 0; i < particuleCount; ++i)
161 if (not isAllocated[i])
165 if (isResting[i] and ((i + frameIndex) % restingUpdatePeriod) != 0)
168 const utils::vec2d& drive = particules[i].update_speed(accelerationCartesian, deltaTime_s);
169 move_with_collisions(i, accelerationCartesian, drive, deltaTime_s, shouldContrain, flowReach);
179 template<
typename ShouldDepopFunction> uint16_t
depop_particules(
const ShouldDepopFunction& shouldDepopFunction)
181 static_assert(std::is_invocable_r_v<bool, ShouldDepopFunction, Particle const&>);
183 uint16_t particleCount = 0;
184 for (
size_t i = 0; i < particuleCount; ++i)
187 if (not isAllocated[i])
190 const auto& parti = particules[i];
191 if (shouldDepopFunction(parti))
193 isAllocated[i] =
false;
194 if (parti._savedLampIndex >= 0 && parti._savedLampIndex < isOccupiedSpaces.size())
195 isOccupiedSpaces[parti._savedLampIndex] =
false;
202 return particleCount;
209 template<
typename ShouldDepopFunction>
212 static_assert(std::is_invocable_r_v<bool, ShouldDepopFunction, size_t, Particle const&>);
214 uint16_t remaining = 0;
215 for (
size_t i = 0; i < particuleCount; ++i)
217 if (not isAllocated[i])
220 const auto& parti = particules[i];
221 if (shouldDepopFunction(i, parti))
223 isAllocated[i] =
false;
224 if (parti._savedLampIndex >= 0 && parti._savedLampIndex < isOccupiedSpaces.size())
225 isOccupiedSpaces[parti._savedLampIndex] =
false;
240 template<
typename SampleColorFunction>
241 uint16_t
show(
const SampleColorFunction& sample_color,
LampTy& lamp,
const bool forceDisplay =
false)
const
243 static_assert(std::is_invocable_r_v<uint32_t, SampleColorFunction, int16_t, Particle const&>);
245 uint16_t particleCount = 0;
246 for (int16_t i = 0; i < particuleCount; ++i)
249 if (not isAllocated[i])
251 const auto& particle = particules[i];
252 const auto& index = particle._savedLampIndex;
262 return particleCount;
265 uint16_t
show(
LampTy& lamp,
const bool forceDisplay =
false)
const
268 [](int16_t,
const Particle& particle) {
269 return particle.get_color();
278 uint16_t particleCount = 0;
279 for (
size_t i = 0; i < particuleCount; ++i)
282 if (not isAllocated[i])
286 return particleCount;
293 if (pos < 0 or pos >= isOccupiedSpaces.size())
295 return isOccupiedSpaces[pos];
303 template<
typename PositiongeneratorFunction>
305 const PositiongeneratorFunction& positionGeneratorFunction,
306 const uint32_t color)
308 static_assert(std::is_invocable_r_v<int16_t, PositiongeneratorFunction, size_t>);
310 int16_t pos = positionGeneratorFunction(index);
314 pos = positionGeneratorFunction(index);
319 particules[index] =
Particle(
utils::vec3d {helixCoordinates.
x, helixCoordinates.y, helixCoordinates.z});
320 particules[index].set_color(color);
321 if (index < isAllocated.size())
323 isAllocated[index] =
true;
324 isResting[index] =
false;
326 const int16_t ledIndex = particules[index]._savedLampIndex;
327 if (ledIndex >= 0 && ledIndex < isOccupiedSpaces.size())
328 isOccupiedSpaces[ledIndex] =
true;
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;
340 void update_occupation()
342 isOccupiedSpaces.reset();
343 for (
size_t i = 0; i < particuleCount; ++i)
345 const int16_t ledIndex = particules[i]._savedLampIndex;
347 isOccupiedSpaces[ledIndex] =
true;
352 bool is_led_blocked(
const int16_t fromIndex,
const int16_t toIndex,
const bool shouldContrain)
const
355 return isOccupiedSpaces[toIndex];
361 void move_particle(
const size_t slot,
const utils::vec2d& offset_mm,
const int16_t toIndex)
363 Particle& particle = particules[slot];
364 const int16_t fromIndex = particle._savedLampIndex;
365 if (toIndex != fromIndex)
369 isOccupiedSpaces[fromIndex] =
false;
371 isOccupiedSpaces[toIndex] =
true;
373 particle.move_by(offset_mm, toIndex);
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)
393 Particle& particle = particules[slot];
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);
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))
405 move_particle(slot, step, toIndex);
406 isResting[slot] =
false;
410 particle.dampen_speed(contactDampening);
412 const bool hasFlowed =
413 drive.dot(step) > 0.0f and flow_around_obstacle(slot, acceleration, drive, shouldContrain, flowReach);
414 isResting[slot] = not hasFlowed;
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)
434 const Particle& particle = particules[slot];
435 const int16_t fromIndex = particle._savedLampIndex;
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));
443 const float firstSide = (random8() & 1) ? 1.0f : -1.0f;
444 for (uint8_t distance = 1; distance <= flowReach; ++distance)
447 if (distance == 2 and
448 is_led_blocked(fromIndex, particle.led_index_at_offset(oneLedDown.multiply(-1.0f)), shouldContrain))
451 for (
const float side: {firstSide, -firstSide})
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))
458 move_particle(slot, gapOffset, gapIndex);
468 static bool is_flow_worth_it(
const utils::vec3d& acceleration,
const int16_t fromIndex,
const int16_t toIndex)
470 const float minDrop = minFlowDropRatio *
rowHeight_mm * sqrtf(acceleration.dot(acceleration));
476 static float led_span_along(
const utils::vec2d& direction)
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;
489 uint16_t particuleCount;
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