mirror of https://github.com/axmolengine/axmol.git
1518 lines
51 KiB
C++
1518 lines
51 KiB
C++
/*
|
|
* Copyright (c) 2013 Google, Inc.
|
|
*
|
|
* This software is provided 'as-is', without any express or implied
|
|
* warranty. In no event will the authors be held liable for any damages
|
|
* arising from the use of this software.
|
|
* Permission is granted to anyone to use this software for any purpose,
|
|
* including commercial applications, and to alter it and redistribute it
|
|
* freely, subject to the following restrictions:
|
|
* 1. The origin of this software must not be misrepresented; you must not
|
|
* claim that you wrote the original software. If you use this software
|
|
* in a product, an acknowledgment in the product documentation would be
|
|
* appreciated but is not required.
|
|
* 2. Altered source versions must be plainly marked as such, and must not be
|
|
* misrepresented as being the original software.
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
|
*/
|
|
#ifndef B2_PARTICLE_SYSTEM_H
|
|
#define B2_PARTICLE_SYSTEM_H
|
|
|
|
#include "b2_slab_allocator.h"
|
|
#include "b2_growable_buffer.h"
|
|
#include "b2_particle.h"
|
|
#include "b2_time_step.h"
|
|
|
|
#ifdef LIQUIDFUN_UNIT_TESTS
|
|
#include <gtest/gtest.h>
|
|
#endif // LIQUIDFUN_UNIT_TESTS
|
|
|
|
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
#include <cstring>
|
|
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
|
|
class b2World;
|
|
class b2Body;
|
|
class b2Shape;
|
|
class b2ParticleGroup;
|
|
class b2BlockAllocator;
|
|
class b2StackAllocator;
|
|
class b2QueryCallback;
|
|
class b2RayCastCallback;
|
|
class b2Fixture;
|
|
class b2ContactFilter;
|
|
class b2ContactListener;
|
|
class b2ParticlePairSet;
|
|
class FixtureParticleSet;
|
|
struct b2ParticleGroupDef;
|
|
struct b2Vec2;
|
|
struct b2AABB;
|
|
struct FindContactInput;
|
|
struct FindContactCheck;
|
|
|
|
struct b2ParticleContact
|
|
{
|
|
private:
|
|
typedef int32 b2ParticleIndex;
|
|
|
|
/// Indices of the respective particles making contact.
|
|
b2ParticleIndex indexA, indexB;
|
|
|
|
/// Weight of the contact. A value between 0.0f and 1.0f.
|
|
/// 0.0f ==> particles are just barely touching
|
|
/// 1.0f ==> particles are perfectly on top of each other
|
|
float32 weight;
|
|
|
|
/// The normalized direction from A to B.
|
|
b2Vec2 normal;
|
|
|
|
/// The logical sum of the particle behaviors that have been set.
|
|
/// See the b2ParticleFlag enum.
|
|
uint32 flags;
|
|
|
|
public:
|
|
void SetIndices(int32 a, int32 b);
|
|
void SetWeight(float32 w) { weight = w; }
|
|
void SetNormal(const b2Vec2& n) { normal = n; }
|
|
void SetFlags(uint32 f) { flags = f; }
|
|
|
|
int32 GetIndexA() const { return indexA; }
|
|
int32 GetIndexB() const { return indexB; }
|
|
float32 GetWeight() const { return weight; }
|
|
const b2Vec2& GetNormal() const { return normal; }
|
|
uint32 GetFlags() const { return flags; }
|
|
|
|
bool operator==(const b2ParticleContact& rhs) const;
|
|
bool operator!=(const b2ParticleContact& rhs) const { return !operator==(rhs); }
|
|
bool ApproximatelyEqual(const b2ParticleContact& rhs) const;
|
|
};
|
|
|
|
struct b2ParticleBodyContact
|
|
{
|
|
/// Index of the particle making contact.
|
|
int32 index;
|
|
|
|
/// The body making contact.
|
|
b2Body* body;
|
|
|
|
/// The specific fixture making contact
|
|
b2Fixture* fixture;
|
|
|
|
/// Weight of the contact. A value between 0.0f and 1.0f.
|
|
float32 weight;
|
|
|
|
/// The normalized direction from the particle to the body.
|
|
b2Vec2 normal;
|
|
|
|
/// The effective mass used in calculating force.
|
|
float32 mass;
|
|
};
|
|
|
|
/// Connection between two particles
|
|
struct b2ParticlePair
|
|
{
|
|
/// Indices of the respective particles making pair.
|
|
int32 indexA, indexB;
|
|
|
|
/// The logical sum of the particle flags. See the b2ParticleFlag enum.
|
|
uint32 flags;
|
|
|
|
/// The strength of cohesion among the particles.
|
|
float32 strength;
|
|
|
|
/// The initial distance of the particles.
|
|
float32 distance;
|
|
};
|
|
|
|
/// Connection between three particles
|
|
struct b2ParticleTriad
|
|
{
|
|
/// Indices of the respective particles making triad.
|
|
int32 indexA, indexB, indexC;
|
|
|
|
/// The logical sum of the particle flags. See the b2ParticleFlag enum.
|
|
uint32 flags;
|
|
|
|
/// The strength of cohesion among the particles.
|
|
float32 strength;
|
|
|
|
/// Values used for calculation.
|
|
b2Vec2 pa, pb, pc;
|
|
float32 ka, kb, kc, s;
|
|
};
|
|
|
|
struct b2ParticleSystemDef
|
|
{
|
|
b2ParticleSystemDef()
|
|
{
|
|
strictContactCheck = false;
|
|
density = 1.0f;
|
|
gravityScale = 1.0f;
|
|
radius = 1.0f;
|
|
maxCount = 0;
|
|
|
|
// Initialize physical coefficients to the maximum values that
|
|
// maintain numerical stability.
|
|
pressureStrength = 0.05f;
|
|
dampingStrength = 1.0f;
|
|
elasticStrength = 0.25f;
|
|
springStrength = 0.25f;
|
|
viscousStrength = 0.25f;
|
|
surfaceTensionPressureStrength = 0.2f;
|
|
surfaceTensionNormalStrength = 0.2f;
|
|
repulsiveStrength = 1.0f;
|
|
powderStrength = 0.5f;
|
|
ejectionStrength = 0.5f;
|
|
staticPressureStrength = 0.2f;
|
|
staticPressureRelaxation = 0.2f;
|
|
staticPressureIterations = 8;
|
|
colorMixingStrength = 0.5f;
|
|
destroyByAge = true;
|
|
lifetimeGranularity = 1.0f / 60.0f;
|
|
}
|
|
|
|
/// Enable strict Particle/Body contact check.
|
|
/// See SetStrictContactCheck for details.
|
|
bool strictContactCheck;
|
|
|
|
/// Set the particle density.
|
|
/// See SetDensity for details.
|
|
float32 density;
|
|
|
|
/// Change the particle gravity scale. Adjusts the effect of the global
|
|
/// gravity vector on particles. Default value is 1.0f.
|
|
float32 gravityScale;
|
|
|
|
/// Particles behave as circles with this radius. In Box2D units.
|
|
float32 radius;
|
|
|
|
/// Set the maximum number of particles.
|
|
/// By default, there is no maximum. The particle buffers can continue to
|
|
/// grow while b2World's block allocator still has memory.
|
|
/// See SetMaxParticleCount for details.
|
|
int32 maxCount;
|
|
|
|
/// Increases pressure in response to compression
|
|
/// Smaller values allow more compression
|
|
float32 pressureStrength;
|
|
|
|
/// Reduces velocity along the collision normal
|
|
/// Smaller value reduces less
|
|
float32 dampingStrength;
|
|
|
|
/// Restores shape of elastic particle groups
|
|
/// Larger values increase elastic particle velocity
|
|
float32 elasticStrength;
|
|
|
|
/// Restores length of spring particle groups
|
|
/// Larger values increase spring particle velocity
|
|
float32 springStrength;
|
|
|
|
/// Reduces relative velocity of viscous particles
|
|
/// Larger values slow down viscous particles more
|
|
float32 viscousStrength;
|
|
|
|
/// Produces pressure on tensile particles
|
|
/// 0~0.2. Larger values increase the amount of surface tension.
|
|
float32 surfaceTensionPressureStrength;
|
|
|
|
/// Smoothes outline of tensile particles
|
|
/// 0~0.2. Larger values result in rounder, smoother, water-drop-like
|
|
/// clusters of particles.
|
|
float32 surfaceTensionNormalStrength;
|
|
|
|
/// Produces additional pressure on repulsive particles
|
|
/// Larger values repulse more
|
|
/// Negative values mean attraction. The range where particles behave
|
|
/// stably is about -0.2 to 2.0.
|
|
float32 repulsiveStrength;
|
|
|
|
/// Produces repulsion between powder particles
|
|
/// Larger values repulse more
|
|
float32 powderStrength;
|
|
|
|
/// Pushes particles out of solid particle group
|
|
/// Larger values repulse more
|
|
float32 ejectionStrength;
|
|
|
|
/// Produces static pressure
|
|
/// Larger values increase the pressure on neighboring partilces
|
|
/// For a description of static pressure, see
|
|
/// http://en.wikipedia.org/wiki/Static_pressure#Static_pressure_in_fluid_dynamics
|
|
float32 staticPressureStrength;
|
|
|
|
/// Reduces instability in static pressure calculation
|
|
/// Larger values make stabilize static pressure with fewer iterations
|
|
float32 staticPressureRelaxation;
|
|
|
|
/// Computes static pressure more precisely
|
|
/// See SetStaticPressureIterations for details
|
|
int32 staticPressureIterations;
|
|
|
|
/// Determines how fast colors are mixed
|
|
/// 1.0f ==> mixed immediately
|
|
/// 0.5f ==> mixed half way each simulation step (see b2World::Step())
|
|
float32 colorMixingStrength;
|
|
|
|
/// Whether to destroy particles by age when no more particles can be
|
|
/// created. See #b2ParticleSystem::SetDestructionByAge() for
|
|
/// more information.
|
|
bool destroyByAge;
|
|
|
|
/// Granularity of particle lifetimes in seconds. By default this is
|
|
/// set to (1.0f / 60.0f) seconds. b2ParticleSystem uses a 32-bit signed
|
|
/// value to track particle lifetimes so the maximum lifetime of a
|
|
/// particle is (2^32 - 1) / (1.0f / lifetimeGranularity) seconds.
|
|
/// With the value set to 1/60 the maximum lifetime or age of a particle is
|
|
/// 2.27 years.
|
|
float32 lifetimeGranularity;
|
|
};
|
|
|
|
|
|
class b2ParticleSystem
|
|
{
|
|
public:
|
|
/// Create a particle whose properties have been defined.
|
|
/// No reference to the definition is retained.
|
|
/// A simulation step must occur before it's possible to interact with a
|
|
/// newly created particle. For example, DestroyParticleInShape() will
|
|
/// not destroy a particle until b2World::Step() has been called.
|
|
/// @warning This function is locked during callbacks.
|
|
/// @return the index of the particle.
|
|
int32 CreateParticle(const b2ParticleDef& def);
|
|
|
|
/// Retrieve a handle to the particle at the specified index.
|
|
/// Please see #b2ParticleHandle for why you might want a handle.
|
|
const b2ParticleHandle* GetParticleHandleFromIndex(const int32 index);
|
|
|
|
/// Destroy a particle.
|
|
/// The particle is removed after the next simulation step (see
|
|
/// b2World::Step()).
|
|
void DestroyParticle(int32 index)
|
|
{
|
|
DestroyParticle(index, false);
|
|
}
|
|
|
|
/// Destroy a particle.
|
|
/// The particle is removed after the next step.
|
|
/// @param Index of the particle to destroy.
|
|
/// @param Whether to call the destruction listener just before the
|
|
/// particle is destroyed.
|
|
void DestroyParticle(int32 index, bool callDestructionListener);
|
|
|
|
/// Destroy the Nth oldest particle in the system.
|
|
/// The particle is removed after the next b2World::Step().
|
|
/// @param Index of the Nth oldest particle to destroy, 0 will destroy the
|
|
/// oldest particle in the system, 1 will destroy the next oldest
|
|
/// particle etc.
|
|
/// @param Whether to call the destruction listener just before the
|
|
/// particle is destroyed.
|
|
void DestroyOldestParticle(const int32 index,
|
|
const bool callDestructionListener);
|
|
|
|
/// Destroy particles inside a shape without enabling the destruction
|
|
/// callback for destroyed particles.
|
|
/// This function is locked during callbacks.
|
|
/// For more information see
|
|
/// DestroyParticleInShape(const b2Shape&, const b2Transform&,bool).
|
|
/// @param Shape which encloses particles that should be destroyed.
|
|
/// @param Transform applied to the shape.
|
|
/// @warning This function is locked during callbacks.
|
|
/// @return Number of particles destroyed.
|
|
int32 DestroyParticlesInShape(const b2Shape& shape, const b2Transform& xf)
|
|
{
|
|
return DestroyParticlesInShape(shape, xf, false);
|
|
}
|
|
|
|
/// Destroy particles inside a shape.
|
|
/// This function is locked during callbacks.
|
|
/// In addition, this function immediately destroys particles in the shape
|
|
/// in constrast to DestroyParticle() which defers the destruction until
|
|
/// the next simulation step.
|
|
/// @param Shape which encloses particles that should be destroyed.
|
|
/// @param Transform applied to the shape.
|
|
/// @param Whether to call the world b2DestructionListener for each
|
|
/// particle destroyed.
|
|
/// @warning This function is locked during callbacks.
|
|
/// @return Number of particles destroyed.
|
|
int32 DestroyParticlesInShape(const b2Shape& shape, const b2Transform& xf,
|
|
bool callDestructionListener);
|
|
|
|
/// Create a particle group whose properties have been defined. No
|
|
/// reference to the definition is retained.
|
|
/// @warning This function is locked during callbacks.
|
|
b2ParticleGroup* CreateParticleGroup(const b2ParticleGroupDef& def);
|
|
|
|
/// Join two particle groups.
|
|
/// @param the first group. Expands to encompass the second group.
|
|
/// @param the second group. It is destroyed.
|
|
/// @warning This function is locked during callbacks.
|
|
void JoinParticleGroups(b2ParticleGroup* groupA, b2ParticleGroup* groupB);
|
|
|
|
/// Split particle group into multiple disconnected groups.
|
|
/// @param the group to be split.
|
|
/// @warning This function is locked during callbacks.
|
|
void SplitParticleGroup(b2ParticleGroup* group);
|
|
|
|
/// Get the world particle group list. With the returned group, use
|
|
/// b2ParticleGroup::GetNext to get the next group in the world list.
|
|
/// A NULL group indicates the end of the list.
|
|
/// @return the head of the world particle group list.
|
|
b2ParticleGroup* GetParticleGroupList();
|
|
const b2ParticleGroup* GetParticleGroupList() const;
|
|
|
|
/// Get the number of particle groups.
|
|
int32 GetParticleGroupCount() const;
|
|
|
|
/// Get the number of particles.
|
|
int32 GetParticleCount() const;
|
|
|
|
/// Get the maximum number of particles.
|
|
int32 GetMaxParticleCount() const;
|
|
|
|
/// Set the maximum number of particles.
|
|
/// A value of 0 means there is no maximum. The particle buffers can
|
|
/// continue to grow while b2World's block allocator still has memory.
|
|
/// Note: If you try to CreateParticle() with more than this count,
|
|
/// b2_invalidParticleIndex is returned unless
|
|
/// SetDestructionByAge() is used to enable the destruction of the
|
|
/// oldest particles in the system.
|
|
void SetMaxParticleCount(int32 count);
|
|
|
|
/// Get all existing particle flags.
|
|
uint32 GetAllParticleFlags() const;
|
|
|
|
/// Get all existing particle group flags.
|
|
uint32 GetAllGroupFlags() const;
|
|
|
|
/// Pause or unpause the particle system. When paused, b2World::Step()
|
|
/// skips over this particle system. All b2ParticleSystem function calls
|
|
/// still work.
|
|
/// @param paused is true to pause, false to un-pause.
|
|
void SetPaused(bool paused);
|
|
|
|
/// @return true if the particle system is being updated in
|
|
/// b2World::Step().
|
|
/// Initially, true, then, the last value passed into SetPaused().
|
|
bool GetPaused() const;
|
|
|
|
/// Change the particle density.
|
|
/// Particle density affects the mass of the particles, which in turn
|
|
/// affects how the particles interact with b2Bodies. Note that the density
|
|
/// does not affect how the particles interact with each other.
|
|
void SetDensity(float32 density);
|
|
|
|
/// Get the particle density.
|
|
float32 GetDensity() const;
|
|
|
|
/// Change the particle gravity scale. Adjusts the effect of the global
|
|
/// gravity vector on particles.
|
|
void SetGravityScale(float32 gravityScale);
|
|
|
|
/// Get the particle gravity scale.
|
|
float32 GetGravityScale() const;
|
|
|
|
/// Damping is used to reduce the velocity of particles. The damping
|
|
/// parameter can be larger than 1.0f but the damping effect becomes
|
|
/// sensitive to the time step when the damping parameter is large.
|
|
void SetDamping(float32 damping);
|
|
|
|
/// Get damping for particles
|
|
float32 GetDamping() const;
|
|
|
|
/// Change the number of iterations when calculating the static pressure of
|
|
/// particles. By default, 8 iterations. You can reduce the number of
|
|
/// iterations down to 1 in some situations, but this may cause
|
|
/// instabilities when many particles come together. If you see particles
|
|
/// popping away from each other like popcorn, you may have to increase the
|
|
/// number of iterations.
|
|
/// For a description of static pressure, see
|
|
/// http://en.wikipedia.org/wiki/Static_pressure#Static_pressure_in_fluid_dynamics
|
|
void SetStaticPressureIterations(int32 iterations);
|
|
|
|
/// Get the number of iterations for static pressure of particles.
|
|
int32 GetStaticPressureIterations() const;
|
|
|
|
/// Change the particle radius.
|
|
/// You should set this only once, on world start.
|
|
/// If you change the radius during execution, existing particles may
|
|
/// explode, shrink, or behave unexpectedly.
|
|
void SetRadius(float32 radius);
|
|
|
|
/// Get the particle radius.
|
|
float32 GetRadius() const;
|
|
|
|
/// Get the position of each particle
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle positions array.
|
|
b2Vec2* GetPositionBuffer();
|
|
const b2Vec2* GetPositionBuffer() const;
|
|
|
|
/// Get the velocity of each particle
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle velocities array.
|
|
b2Vec2* GetVelocityBuffer();
|
|
const b2Vec2* GetVelocityBuffer() const;
|
|
|
|
/// Get the color of each particle
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle colors array.
|
|
b2ParticleColor* GetColorBuffer();
|
|
const b2ParticleColor* GetColorBuffer() const;
|
|
|
|
/// Get the particle-group of each particle.
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle group array.
|
|
b2ParticleGroup* const* GetGroupBuffer();
|
|
const b2ParticleGroup* const* GetGroupBuffer() const;
|
|
|
|
/// Get the weight of each particle
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle positions array.
|
|
float32* GetWeightBuffer();
|
|
const float32* GetWeightBuffer() const;
|
|
|
|
/// Get the user-specified data of each particle.
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle user-data array.
|
|
void** GetUserDataBuffer();
|
|
void* const* GetUserDataBuffer() const;
|
|
|
|
/// Get the flags for each particle. See the b2ParticleFlag enum.
|
|
/// Array is length GetParticleCount()
|
|
/// @return the pointer to the head of the particle-flags array.
|
|
const uint32* GetFlagsBuffer() const;
|
|
|
|
/// Set flags for a particle. See the b2ParticleFlag enum.
|
|
void SetParticleFlags(int32 index, uint32 flags);
|
|
/// Get flags for a particle. See the b2ParticleFlag enum.
|
|
uint32 GetParticleFlags(const int32 index);
|
|
|
|
/// Set an external buffer for particle data.
|
|
/// Normally, the b2World's block allocator is used for particle data.
|
|
/// However, sometimes you may have an OpenGL or Java buffer for particle
|
|
/// data. To avoid data duplication, you may supply this external buffer.
|
|
///
|
|
/// Note that, when b2World's block allocator is used, the particle data
|
|
/// buffers can grow as required. However, when external buffers are used,
|
|
/// the maximum number of particles is clamped to the size of the smallest
|
|
/// external buffer.
|
|
///
|
|
/// @param buffer is a pointer to a block of memory.
|
|
/// @param size is the number of values in the block.
|
|
void SetFlagsBuffer(uint32* buffer, int32 capacity);
|
|
void SetPositionBuffer(b2Vec2* buffer, int32 capacity);
|
|
void SetVelocityBuffer(b2Vec2* buffer, int32 capacity);
|
|
void SetColorBuffer(b2ParticleColor* buffer, int32 capacity);
|
|
void SetUserDataBuffer(void** buffer, int32 capacity);
|
|
|
|
/// Get contacts between particles
|
|
/// Contact data can be used for many reasons, for example to trigger
|
|
/// rendering or audio effects.
|
|
const b2ParticleContact* GetContacts() const;
|
|
int32 GetContactCount() const;
|
|
|
|
/// Get contacts between particles and bodies
|
|
/// Contact data can be used for many reasons, for example to trigger
|
|
/// rendering or audio effects.
|
|
const b2ParticleBodyContact* GetBodyContacts() const;
|
|
int32 GetBodyContactCount() const;
|
|
|
|
/// Get array of particle pairs. The particles in a pair:
|
|
/// (1) are contacting,
|
|
/// (2) are in the same particle group,
|
|
/// (3) are part of a rigid particle group, or are spring, elastic,
|
|
/// or wall particles.
|
|
/// (4) have at least one particle that is a spring or barrier
|
|
/// particle (i.e. one of the types in k_pairFlags),
|
|
/// (5) have at least one particle that returns true for
|
|
/// ConnectionFilter::IsNecessary,
|
|
/// (6) are not zombie particles.
|
|
/// Essentially, this is an array of spring or barrier particles that
|
|
/// are interacting. The array is sorted by b2ParticlePair's indexA,
|
|
/// and then indexB. There are no duplicate entries.
|
|
const b2ParticlePair* GetPairs() const;
|
|
int32 GetPairCount() const;
|
|
|
|
/// Get array of particle triads. The particles in a triad:
|
|
/// (1) are in the same particle group,
|
|
/// (2) are in a Voronoi triangle together,
|
|
/// (3) are within b2_maxTriadDistance particle diameters of each
|
|
/// other,
|
|
/// (4) return true for ConnectionFilter::ShouldCreateTriad
|
|
/// (5) have at least one particle of type elastic (i.e. one of the
|
|
/// types in k_triadFlags),
|
|
/// (6) are part of a rigid particle group, or are spring, elastic,
|
|
/// or wall particles.
|
|
/// (7) are not zombie particles.
|
|
/// Essentially, this is an array of elastic particles that are
|
|
/// interacting. The array is sorted by b2ParticleTriad's indexA,
|
|
/// then indexB, then indexC. There are no duplicate entries.
|
|
const b2ParticleTriad* GetTriads() const;
|
|
int32 GetTriadCount() const;
|
|
|
|
/// Set an optional threshold for the maximum number of
|
|
/// consecutive particle iterations that a particle may contact
|
|
/// multiple bodies before it is considered a candidate for being
|
|
/// "stuck". Setting to zero or less disables.
|
|
void SetStuckThreshold(int32 iterations);
|
|
|
|
/// Get potentially stuck particles from the last step; the user must
|
|
/// decide if they are stuck or not, and if so, delete or move them
|
|
const int32* GetStuckCandidates() const;
|
|
|
|
/// Get the number of stuck particle candidates from the last step.
|
|
int32 GetStuckCandidateCount() const;
|
|
|
|
/// Compute the kinetic energy that can be lost by damping force
|
|
float32 ComputeCollisionEnergy() const;
|
|
|
|
/// Set strict Particle/Body contact check.
|
|
/// This is an option that will help ensure correct behavior if there are
|
|
/// corners in the world model where Particle/Body contact is ambiguous.
|
|
/// This option scales at n*log(n) of the number of Particle/Body contacts,
|
|
/// so it is best to only enable if it is necessary for your geometry.
|
|
/// Enable if you see strange particle behavior around b2Body
|
|
/// intersections.
|
|
void SetStrictContactCheck(bool enabled);
|
|
/// Get the status of the strict contact check.
|
|
bool GetStrictContactCheck() const;
|
|
|
|
/// Set the lifetime (in seconds) of a particle relative to the current
|
|
/// time. A lifetime of less than or equal to 0.0f results in the particle
|
|
/// living forever until it's manually destroyed by the application.
|
|
void SetParticleLifetime(const int32 index, const float32 lifetime);
|
|
/// Get the lifetime (in seconds) of a particle relative to the current
|
|
/// time. A value > 0.0f is returned if the particle is scheduled to be
|
|
/// destroyed in the future, values <= 0.0f indicate the particle has an
|
|
/// infinite lifetime.
|
|
float32 GetParticleLifetime(const int32 index);
|
|
|
|
/// Enable / disable destruction of particles in CreateParticle() when
|
|
/// no more particles can be created due to a prior call to
|
|
/// SetMaxParticleCount(). When this is enabled, the oldest particle is
|
|
/// destroyed in CreateParticle() favoring the destruction of particles
|
|
/// with a finite lifetime over particles with infinite lifetimes.
|
|
/// This feature is enabled by default when particle lifetimes are
|
|
/// tracked. Explicitly enabling this feature using this function enables
|
|
/// particle lifetime tracking.
|
|
void SetDestructionByAge(const bool enable);
|
|
/// Get whether the oldest particle will be destroyed in CreateParticle()
|
|
/// when the maximum number of particles are present in the system.
|
|
bool GetDestructionByAge() const;
|
|
|
|
/// Get the array of particle expiration times indexed by particle index.
|
|
/// GetParticleCount() items are in the returned array.
|
|
const int32* GetExpirationTimeBuffer();
|
|
/// Convert a expiration time value in returned by
|
|
/// GetExpirationTimeBuffer() to a time in seconds relative to the
|
|
/// current simulation time.
|
|
float32 ExpirationTimeToLifetime(const int32 expirationTime) const;
|
|
/// Get the array of particle indices ordered by reverse lifetime.
|
|
/// The oldest particle indexes are at the end of the array with the
|
|
/// newest at the start. Particles with infinite lifetimes
|
|
/// (i.e expiration times less than or equal to 0) are placed at the start
|
|
/// of the array.
|
|
/// ExpirationTimeToLifetime(GetExpirationTimeBuffer()[index])
|
|
/// is equivalent to GetParticleLifetime(index).
|
|
/// GetParticleCount() items are in the returned array.
|
|
const int32* GetIndexByExpirationTimeBuffer();
|
|
|
|
/// Apply an impulse to one particle. This immediately modifies the
|
|
/// velocity. Similar to b2Body::ApplyLinearImpulse.
|
|
/// @param index the particle that will be modified.
|
|
/// @param impulse the world impulse vector, usually in N-seconds or
|
|
/// kg-m/s.
|
|
void ParticleApplyLinearImpulse(int32 index, const b2Vec2& impulse);
|
|
|
|
/// Apply an impulse to all particles between 'firstIndex' and 'lastIndex'.
|
|
/// This immediately modifies the velocity. Note that the impulse is
|
|
/// applied to the total mass of all particles. So, calling
|
|
/// ParticleApplyLinearImpulse(0, impulse) and
|
|
/// ParticleApplyLinearImpulse(1, impulse) will impart twice as much
|
|
/// velocity as calling just ApplyLinearImpulse(0, 1, impulse).
|
|
/// @param firstIndex the first particle to be modified.
|
|
/// @param lastIndex the last particle to be modified.
|
|
/// @param impulse the world impulse vector, usually in N-seconds or
|
|
/// kg-m/s.
|
|
void ApplyLinearImpulse(int32 firstIndex, int32 lastIndex,
|
|
const b2Vec2& impulse);
|
|
|
|
/// Apply a force to the center of a particle.
|
|
/// @param index the particle that will be modified.
|
|
/// @param force the world force vector, usually in Newtons (N).
|
|
void ParticleApplyForce(int32 index, const b2Vec2& force);
|
|
|
|
/// Distribute a force across several particles. The particles must not be
|
|
/// wall particles. Note that the force is distributed across all the
|
|
/// particles, so calling this function for indices 0..N is not the same as
|
|
/// calling ParticleApplyForce(i, force) for i in 0..N.
|
|
/// @param firstIndex the first particle to be modified.
|
|
/// @param lastIndex the last particle to be modified.
|
|
/// @param force the world force vector, usually in Newtons (N).
|
|
void ApplyForce(int32 firstIndex, int32 lastIndex, const b2Vec2& force);
|
|
|
|
/// Get the next particle-system in the world's particle-system list.
|
|
b2ParticleSystem* GetNext();
|
|
const b2ParticleSystem* GetNext() const;
|
|
|
|
/// Query the particle system for all particles that potentially overlap
|
|
/// the provided AABB. b2QueryCallback::ShouldQueryParticleSystem is
|
|
/// ignored.
|
|
/// @param callback a user implemented callback class.
|
|
/// @param aabb the query box.
|
|
void QueryAABB(b2QueryCallback* callback, const b2AABB& aabb) const;
|
|
|
|
/// Query the particle system for all particles that potentially overlap
|
|
/// the provided shape's AABB. Calls QueryAABB internally.
|
|
/// b2QueryCallback::ShouldQueryParticleSystem is ignored.
|
|
/// @param callback a user implemented callback class.
|
|
/// @param shape the query shape
|
|
/// @param xf the transform of the AABB
|
|
void QueryShapeAABB(b2QueryCallback* callback, const b2Shape& shape,
|
|
const b2Transform& xf) const;
|
|
|
|
/// Ray-cast the particle system for all particles in the path of the ray.
|
|
/// Your callback controls whether you get the closest point, any point, or
|
|
/// n-points. The ray-cast ignores particles that contain the starting
|
|
/// point. b2RayCastCallback::ShouldQueryParticleSystem is ignored.
|
|
/// @param callback a user implemented callback class.
|
|
/// @param point1 the ray starting point
|
|
/// @param point2 the ray ending point
|
|
void RayCast(b2RayCastCallback* callback, const b2Vec2& point1,
|
|
const b2Vec2& point2) const;
|
|
|
|
/// Compute the axis-aligned bounding box for all particles contained
|
|
/// within this particle system.
|
|
/// @param aabb Returns the axis-aligned bounding box of the system.
|
|
void ComputeAABB(b2AABB* const aabb) const;
|
|
|
|
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
public:
|
|
enum b2ExceptionType
|
|
{
|
|
b2_bufferTooSmall,
|
|
b2_particleIndexOutOfBounds,
|
|
b2_numErrors,
|
|
b2_noExceptions,
|
|
};
|
|
|
|
/// Set the velocity of particle at index with direct floats.
|
|
void SetParticleVelocity(int32 index, float32 vx, float32 vy);
|
|
|
|
/// Get the x-coordinate of particle at index.
|
|
float GetParticlePositionX(int32 index) const;
|
|
|
|
/// Get the y-coordinate of particle at index.
|
|
float GetParticlePositionY(int32 index) const;
|
|
|
|
/// Copy position buffer into a specified buffer, starting from startIndex.
|
|
int CopyPositionBuffer(int startIndex, int numParticles, void* outBuf,
|
|
int size) const;
|
|
|
|
/// Copy color buffer into a specified buffer, starting from startIndex.
|
|
int CopyColorBuffer(int startIndex, int numParticles, void* outBuf,
|
|
int size) const;
|
|
|
|
/// Copy color buffer into a specified buffer, starting from startIndex.
|
|
int CopyWeightBuffer(int startIndex, int numParticles, void* outBuf,
|
|
int size) const;
|
|
|
|
private:
|
|
/// Helper function for buffer copies.
|
|
int CopyBuffer(int startIndex, int numParticles, void* inBufWithOffset,
|
|
void* outBuf, int outBufSize, int copySize) const;
|
|
|
|
/// Check if buffer copy is valid for the Get*Buffer functions that have
|
|
/// a user-supplied output buffer.
|
|
b2ExceptionType IsBufCopyValid(int startIndex, int numParticles,
|
|
int copySize, int bufSize) const;
|
|
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
|
|
private:
|
|
friend class b2World;
|
|
friend class b2ParticleGroup;
|
|
friend class b2ParticleBodyContactRemovePredicate;
|
|
friend class b2FixtureParticleQueryCallback;
|
|
#ifdef LIQUIDFUN_UNIT_TESTS
|
|
FRIEND_TEST(FunctionTests, GetParticleMass);
|
|
FRIEND_TEST(FunctionTests, AreProxyBuffersTheSame);
|
|
#endif // LIQUIDFUN_UNIT_TESTS
|
|
|
|
template <typename T>
|
|
struct UserOverridableBuffer
|
|
{
|
|
UserOverridableBuffer()
|
|
{
|
|
data = NULL;
|
|
userSuppliedCapacity = 0;
|
|
}
|
|
T* data;
|
|
int32 userSuppliedCapacity;
|
|
};
|
|
|
|
/// Used for detecting particle contacts
|
|
struct Proxy
|
|
{
|
|
int32 index;
|
|
uint32 tag;
|
|
friend inline bool operator<(const Proxy &a, const Proxy &b)
|
|
{
|
|
return a.tag < b.tag;
|
|
}
|
|
friend inline bool operator<(uint32 a, const Proxy &b)
|
|
{
|
|
return a < b.tag;
|
|
}
|
|
friend inline bool operator<(const Proxy &a, uint32 b)
|
|
{
|
|
return a.tag < b;
|
|
}
|
|
};
|
|
|
|
/// Class for filtering pairs or triads.
|
|
class ConnectionFilter
|
|
{
|
|
public:
|
|
virtual ~ConnectionFilter() {}
|
|
/// Is the particle necessary for connection?
|
|
/// A pair or a triad should contain at least one 'necessary' particle.
|
|
virtual bool IsNecessary(int32 index) const
|
|
{
|
|
B2_NOT_USED(index);
|
|
return true;
|
|
}
|
|
/// An additional condition for creating a pair.
|
|
virtual bool ShouldCreatePair(int32 a, int32 b) const
|
|
{
|
|
B2_NOT_USED(a);
|
|
B2_NOT_USED(b);
|
|
return true;
|
|
}
|
|
/// An additional condition for creating a triad.
|
|
virtual bool ShouldCreateTriad(int32 a, int32 b, int32 c) const
|
|
{
|
|
B2_NOT_USED(a);
|
|
B2_NOT_USED(b);
|
|
B2_NOT_USED(c);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
/// InsideBoundsEnumerator enumerates all particles inside the given bounds.
|
|
class InsideBoundsEnumerator
|
|
{
|
|
public:
|
|
/// Construct an enumerator with bounds of tags and a range of proxies.
|
|
InsideBoundsEnumerator(
|
|
uint32 lower, uint32 upper,
|
|
const Proxy* first, const Proxy* last);
|
|
|
|
/// Get index of the next particle. Returns b2_invalidParticleIndex if
|
|
/// there are no more particles.
|
|
int32 GetNext();
|
|
private:
|
|
/// The lower and upper bound of x component in the tag.
|
|
uint32 m_xLower, m_xUpper;
|
|
/// The lower and upper bound of y component in the tag.
|
|
uint32 m_yLower, m_yUpper;
|
|
/// The range of proxies.
|
|
const Proxy* m_first;
|
|
const Proxy* m_last;
|
|
};
|
|
|
|
/// Node of linked lists of connected particles
|
|
struct ParticleListNode
|
|
{
|
|
/// The head of the list.
|
|
ParticleListNode* list;
|
|
/// The next node in the list.
|
|
ParticleListNode* next;
|
|
/// Number of entries in the list. Valid only for the node at the head
|
|
/// of the list.
|
|
int32 count;
|
|
/// Particle index.
|
|
int32 index;
|
|
};
|
|
|
|
/// All particle types that require creating pairs
|
|
static const int32 k_pairFlags =
|
|
b2_springParticle |
|
|
b2_barrierParticle;
|
|
/// All particle types that require creating triads
|
|
static const int32 k_triadFlags =
|
|
b2_elasticParticle;
|
|
/// All particle types that do not produce dynamic pressure
|
|
static const int32 k_noPressureFlags =
|
|
b2_powderParticle |
|
|
b2_tensileParticle;
|
|
/// All particle types that apply extra damping force with bodies
|
|
static const int32 k_extraDampingFlags =
|
|
b2_staticPressureParticle;
|
|
|
|
b2ParticleSystem(const b2ParticleSystemDef* def, b2World* world);
|
|
~b2ParticleSystem();
|
|
|
|
template <typename T> void FreeBuffer(T** b, int capacity);
|
|
template <typename T> void FreeUserOverridableBuffer(
|
|
UserOverridableBuffer<T>* b);
|
|
template <typename T> T* ReallocateBuffer(T* buffer, int32 oldCapacity,
|
|
int32 newCapacity);
|
|
template <typename T> T* ReallocateBuffer(
|
|
T* buffer, int32 userSuppliedCapacity, int32 oldCapacity,
|
|
int32 newCapacity, bool deferred);
|
|
template <typename T> T* ReallocateBuffer(
|
|
UserOverridableBuffer<T>* buffer, int32 oldCapacity, int32 newCapacity,
|
|
bool deferred);
|
|
template <typename T> T* RequestBuffer(T* buffer);
|
|
|
|
/// Reallocate the handle / index map and schedule the allocation of a new
|
|
/// pool for handle allocation.
|
|
void ReallocateHandleBuffers(int32 newCapacity);
|
|
|
|
void ReallocateInternalAllocatedBuffers(int32 capacity);
|
|
int32 CreateParticleForGroup(
|
|
const b2ParticleGroupDef& groupDef,
|
|
const b2Transform& xf, const b2Vec2& position);
|
|
void CreateParticlesStrokeShapeForGroup(
|
|
const b2Shape* shape,
|
|
const b2ParticleGroupDef& groupDef, const b2Transform& xf);
|
|
void CreateParticlesFillShapeForGroup(
|
|
const b2Shape* shape,
|
|
const b2ParticleGroupDef& groupDef, const b2Transform& xf);
|
|
void CreateParticlesWithShapeForGroup(
|
|
const b2Shape* shape,
|
|
const b2ParticleGroupDef& groupDef, const b2Transform& xf);
|
|
void CreateParticlesWithShapesForGroup(
|
|
const b2Shape* const* shapes, int32 shapeCount,
|
|
const b2ParticleGroupDef& groupDef, const b2Transform& xf);
|
|
int32 CloneParticle(int32 index, b2ParticleGroup* group);
|
|
void DestroyParticleGroup(b2ParticleGroup* group);
|
|
|
|
void UpdatePairsAndTriads(
|
|
int32 firstIndex, int32 lastIndex, const ConnectionFilter& filter);
|
|
void UpdatePairsAndTriadsWithReactiveParticles();
|
|
static bool ComparePairIndices(const b2ParticlePair& a, const b2ParticlePair& b);
|
|
static bool MatchPairIndices(const b2ParticlePair& a, const b2ParticlePair& b);
|
|
static bool CompareTriadIndices(const b2ParticleTriad& a, const b2ParticleTriad& b);
|
|
static bool MatchTriadIndices(const b2ParticleTriad& a, const b2ParticleTriad& b);
|
|
|
|
static void InitializeParticleLists(
|
|
const b2ParticleGroup* group, ParticleListNode* nodeBuffer);
|
|
void MergeParticleListsInContact(
|
|
const b2ParticleGroup* group, ParticleListNode* nodeBuffer) const;
|
|
static void MergeParticleLists(
|
|
ParticleListNode* listA, ParticleListNode* listB);
|
|
static ParticleListNode* FindLongestParticleList(
|
|
const b2ParticleGroup* group, ParticleListNode* nodeBuffer);
|
|
void MergeZombieParticleListNodes(
|
|
const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
|
|
ParticleListNode* survivingList) const;
|
|
static void MergeParticleListAndNode(
|
|
ParticleListNode* list, ParticleListNode* node);
|
|
void CreateParticleGroupsFromParticleList(
|
|
const b2ParticleGroup* group, ParticleListNode* nodeBuffer,
|
|
const ParticleListNode* survivingList);
|
|
void UpdatePairsAndTriadsWithParticleList(
|
|
const b2ParticleGroup* group, const ParticleListNode* nodeBuffer);
|
|
|
|
void ComputeDepth();
|
|
|
|
InsideBoundsEnumerator GetInsideBoundsEnumerator(const b2AABB& aabb) const;
|
|
|
|
void UpdateAllParticleFlags();
|
|
void UpdateAllGroupFlags();
|
|
void AddContact(int32 a, int32 b,
|
|
b2GrowableBuffer<b2ParticleContact>& contacts) const;
|
|
void FindContacts(
|
|
b2GrowableBuffer<b2ParticleContact>& contacts) const;
|
|
static bool ProxyBufferHasIndex(
|
|
int32 index, const Proxy* const a, int count);
|
|
static int NumProxiesWithSameTag(
|
|
const Proxy* const a, const Proxy* const b, int count);
|
|
static bool AreProxyBuffersTheSame(const b2GrowableBuffer<Proxy>& a,
|
|
const b2GrowableBuffer<Proxy>& b);
|
|
void UpdateProxies(b2GrowableBuffer<Proxy>& proxies) const;
|
|
void SortProxies(b2GrowableBuffer<Proxy>& proxies) const;
|
|
void FilterContacts(b2GrowableBuffer<b2ParticleContact>& contacts);
|
|
void NotifyContactListenerPreContact(
|
|
b2ParticlePairSet* particlePairs) const;
|
|
void NotifyContactListenerPostContact(b2ParticlePairSet& particlePairs);
|
|
void UpdateContacts(bool exceptZombie);
|
|
void NotifyBodyContactListenerPreContact(
|
|
FixtureParticleSet* fixtureSet) const;
|
|
void NotifyBodyContactListenerPostContact(FixtureParticleSet& fixtureSet);
|
|
void UpdateBodyContacts();
|
|
|
|
void Solve(const b2TimeStep& step);
|
|
void SolveCollision(const b2TimeStep& step);
|
|
void LimitVelocity(const b2TimeStep& step);
|
|
void SolveGravity(const b2TimeStep& step);
|
|
void SolveBarrier(const b2TimeStep& step);
|
|
void SolveStaticPressure(const b2TimeStep& step);
|
|
void ComputeWeight();
|
|
void SolvePressure(const b2TimeStep& step);
|
|
void SolveDamping(const b2TimeStep& step);
|
|
void SolveRigidDamping();
|
|
void SolveExtraDamping();
|
|
void SolveWall();
|
|
void SolveRigid(const b2TimeStep& step);
|
|
void SolveElastic(const b2TimeStep& step);
|
|
void SolveSpring(const b2TimeStep& step);
|
|
void SolveTensile(const b2TimeStep& step);
|
|
void SolveViscous();
|
|
void SolveRepulsive(const b2TimeStep& step);
|
|
void SolvePowder(const b2TimeStep& step);
|
|
void SolveSolid(const b2TimeStep& step);
|
|
void SolveForce(const b2TimeStep& step);
|
|
void SolveColorMixing();
|
|
void SolveZombie();
|
|
/// Destroy all particles which have outlived their lifetimes set by
|
|
/// SetParticleLifetime().
|
|
void SolveLifetimes(const b2TimeStep& step);
|
|
void RotateBuffer(int32 start, int32 mid, int32 end);
|
|
|
|
float32 GetCriticalVelocity(const b2TimeStep& step) const;
|
|
float32 GetCriticalVelocitySquared(const b2TimeStep& step) const;
|
|
float32 GetCriticalPressure(const b2TimeStep& step) const;
|
|
float32 GetParticleStride() const;
|
|
float32 GetParticleMass() const;
|
|
float32 GetParticleInvMass() const;
|
|
|
|
// Get the world's contact filter if any particles with the
|
|
// b2_contactFilterParticle flag are present in the system.
|
|
b2ContactFilter* GetFixtureContactFilter() const;
|
|
|
|
// Get the world's contact filter if any particles with the
|
|
// b2_particleContactFilterParticle flag are present in the system.
|
|
b2ContactFilter* GetParticleContactFilter() const;
|
|
|
|
// Get the world's contact listener if any particles with the
|
|
// b2_fixtureContactListenerParticle flag are present in the system.
|
|
b2ContactListener* GetFixtureContactListener() const;
|
|
|
|
// Get the world's contact listener if any particles with the
|
|
// b2_particleContactListenerParticle flag are present in the system.
|
|
b2ContactListener* GetParticleContactListener() const;
|
|
|
|
template <typename T> void SetUserOverridableBuffer(
|
|
UserOverridableBuffer<T>* buffer, T* newBufferData, int32 newCapacity);
|
|
|
|
void SetGroupFlags(b2ParticleGroup* group, uint32 flags);
|
|
|
|
void RemoveSpuriousBodyContacts();
|
|
static bool BodyContactCompare(const b2ParticleBodyContact& lhs,
|
|
const b2ParticleBodyContact& rhs);
|
|
|
|
void DetectStuckParticle(int32 particle);
|
|
|
|
/// Determine whether a particle index is valid.
|
|
bool ValidateParticleIndex(const int32 index) const;
|
|
|
|
/// Get the time elapsed in b2ParticleSystemDef::lifetimeGranularity.
|
|
int32 GetQuantizedTimeElapsed() const;
|
|
/// Convert a lifetime in seconds to an expiration time.
|
|
int64 LifetimeToExpirationTime(const float32 lifetime) const;
|
|
|
|
bool ForceCanBeApplied(uint32 flags) const;
|
|
void PrepareForceBuffer();
|
|
|
|
bool IsRigidGroup(b2ParticleGroup *group) const;
|
|
b2Vec2 GetLinearVelocity(
|
|
b2ParticleGroup *group, int32 particleIndex,
|
|
const b2Vec2 &point) const;
|
|
void InitDampingParameter(
|
|
float32* invMass, float32* invInertia, float32* tangentDistance,
|
|
float32 mass, float32 inertia, const b2Vec2& center,
|
|
const b2Vec2& point, const b2Vec2& normal) const;
|
|
void InitDampingParameterWithRigidGroupOrParticle(
|
|
float32* invMass, float32* invInertia, float32* tangentDistance,
|
|
bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
|
|
const b2Vec2& point, const b2Vec2& normal) const;
|
|
float32 ComputeDampingImpulse(
|
|
float32 invMassA, float32 invInertiaA, float32 tangentDistanceA,
|
|
float32 invMassB, float32 invInertiaB, float32 tangentDistanceB,
|
|
float32 normalVelocity) const;
|
|
void ApplyDamping(
|
|
float32 invMass, float32 invInertia, float32 tangentDistance,
|
|
bool isRigidGroup, b2ParticleGroup* group, int32 particleIndex,
|
|
float32 impulse, const b2Vec2& normal);
|
|
|
|
bool m_paused;
|
|
int32 m_timestamp;
|
|
int32 m_allParticleFlags;
|
|
bool m_needsUpdateAllParticleFlags;
|
|
int32 m_allGroupFlags;
|
|
bool m_needsUpdateAllGroupFlags;
|
|
bool m_hasForce;
|
|
int32 m_iterationIndex;
|
|
float32 m_inverseDensity;
|
|
float32 m_particleDiameter;
|
|
float32 m_inverseDiameter;
|
|
float32 m_squaredDiameter;
|
|
|
|
int32 m_count;
|
|
int32 m_internalAllocatedCapacity;
|
|
/// Allocator for b2ParticleHandle instances.
|
|
b2SlabAllocator<b2ParticleHandle> m_handleAllocator;
|
|
/// Maps particle indicies to handles.
|
|
UserOverridableBuffer<b2ParticleHandle*> m_handleIndexBuffer;
|
|
UserOverridableBuffer<uint32> m_flagsBuffer;
|
|
UserOverridableBuffer<b2Vec2> m_positionBuffer;
|
|
UserOverridableBuffer<b2Vec2> m_velocityBuffer;
|
|
b2Vec2* m_forceBuffer;
|
|
/// m_weightBuffer is populated in ComputeWeight and used in
|
|
/// ComputeDepth(), SolveStaticPressure() and SolvePressure().
|
|
float32* m_weightBuffer;
|
|
/// When any particles have the flag b2_staticPressureParticle,
|
|
/// m_staticPressureBuffer is first allocated and used in
|
|
/// SolveStaticPressure() and SolvePressure(). It will be reallocated on
|
|
/// subsequent CreateParticle() calls.
|
|
float32* m_staticPressureBuffer;
|
|
/// m_accumulationBuffer is used in many functions as a temporary buffer
|
|
/// for scalar values.
|
|
float32* m_accumulationBuffer;
|
|
/// When any particles have the flag b2_tensileParticle,
|
|
/// m_accumulation2Buffer is first allocated and used in SolveTensile()
|
|
/// as a temporary buffer for vector values. It will be reallocated on
|
|
/// subsequent CreateParticle() calls.
|
|
b2Vec2* m_accumulation2Buffer;
|
|
/// When any particle groups have the flag b2_solidParticleGroup,
|
|
/// m_depthBuffer is first allocated and populated in ComputeDepth() and
|
|
/// used in SolveSolid(). It will be reallocated on subsequent
|
|
/// CreateParticle() calls.
|
|
float32* m_depthBuffer;
|
|
UserOverridableBuffer<b2ParticleColor> m_colorBuffer;
|
|
b2ParticleGroup** m_groupBuffer;
|
|
UserOverridableBuffer<void*> m_userDataBuffer;
|
|
|
|
/// Stuck particle detection parameters and record keeping
|
|
int32 m_stuckThreshold;
|
|
UserOverridableBuffer<int32> m_lastBodyContactStepBuffer;
|
|
UserOverridableBuffer<int32> m_bodyContactCountBuffer;
|
|
UserOverridableBuffer<int32> m_consecutiveContactStepsBuffer;
|
|
b2GrowableBuffer<int32> m_stuckParticleBuffer;
|
|
b2GrowableBuffer<Proxy> m_proxyBuffer;
|
|
b2GrowableBuffer<b2ParticleContact> m_contactBuffer;
|
|
b2GrowableBuffer<b2ParticleBodyContact> m_bodyContactBuffer;
|
|
b2GrowableBuffer<b2ParticlePair> m_pairBuffer;
|
|
b2GrowableBuffer<b2ParticleTriad> m_triadBuffer;
|
|
|
|
/// Time each particle should be destroyed relative to the last time
|
|
/// m_timeElapsed was initialized. Each unit of time corresponds to
|
|
/// b2ParticleSystemDef::lifetimeGranularity seconds.
|
|
UserOverridableBuffer<int32> m_expirationTimeBuffer;
|
|
/// List of particle indices sorted by expiration time.
|
|
UserOverridableBuffer<int32> m_indexByExpirationTimeBuffer;
|
|
/// Time elapsed in 32:32 fixed point. Each non-fractional unit of time
|
|
/// corresponds to b2ParticleSystemDef::lifetimeGranularity seconds.
|
|
int64 m_timeElapsed;
|
|
/// Whether the expiration time buffer has been modified and needs to be
|
|
/// resorted.
|
|
bool m_expirationTimeBufferRequiresSorting;
|
|
|
|
int32 m_groupCount;
|
|
b2ParticleGroup* m_groupList;
|
|
|
|
b2ParticleSystemDef m_def;
|
|
|
|
b2World* m_world;
|
|
b2ParticleSystem* m_prev;
|
|
b2ParticleSystem* m_next;
|
|
};
|
|
|
|
inline void b2ParticleContact::SetIndices(int32 a, int32 b)
|
|
{
|
|
b2Assert(a <= b2_maxParticleIndex && b <= b2_maxParticleIndex);
|
|
indexA = (b2ParticleIndex)a;
|
|
indexB = (b2ParticleIndex)b;
|
|
}
|
|
|
|
|
|
inline bool b2ParticleContact::operator==(
|
|
const b2ParticleContact& rhs) const
|
|
{
|
|
return indexA == rhs.indexA
|
|
&& indexB == rhs.indexB
|
|
&& flags == rhs.flags
|
|
&& weight == rhs.weight
|
|
&& normal == rhs.normal;
|
|
}
|
|
|
|
// The reciprocal sqrt function differs between SIMD and non-SIMD, but they
|
|
// should create approximately equal results.
|
|
inline bool b2ParticleContact::ApproximatelyEqual(
|
|
const b2ParticleContact& rhs) const
|
|
{
|
|
static const float MAX_WEIGHT_DIFF = 0.01f; // Weight 0 ~ 1, so about 1%
|
|
static const float MAX_NORMAL_DIFF = 0.01f; // Normal length = 1, so 1%
|
|
return indexA == rhs.indexA
|
|
&& indexB == rhs.indexB
|
|
&& flags == rhs.flags
|
|
&& b2Abs(weight - rhs.weight) < MAX_WEIGHT_DIFF
|
|
&& (normal - rhs.normal).Length() < MAX_NORMAL_DIFF;
|
|
}
|
|
|
|
inline b2ParticleGroup* b2ParticleSystem::GetParticleGroupList()
|
|
{
|
|
return m_groupList;
|
|
}
|
|
|
|
inline const b2ParticleGroup* b2ParticleSystem::GetParticleGroupList() const
|
|
{
|
|
return m_groupList;
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetParticleGroupCount() const
|
|
{
|
|
return m_groupCount;
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetParticleCount() const
|
|
{
|
|
return m_count;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetPaused(bool paused)
|
|
{
|
|
m_paused = paused;
|
|
}
|
|
|
|
inline bool b2ParticleSystem::GetPaused() const
|
|
{
|
|
return m_paused;
|
|
}
|
|
|
|
inline const b2ParticleContact* b2ParticleSystem::GetContacts() const
|
|
{
|
|
return m_contactBuffer.Data();
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetContactCount() const
|
|
{
|
|
return m_contactBuffer.GetCount();
|
|
}
|
|
|
|
inline const b2ParticleBodyContact* b2ParticleSystem::GetBodyContacts() const
|
|
{
|
|
return m_bodyContactBuffer.Data();
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetBodyContactCount() const
|
|
{
|
|
return m_bodyContactBuffer.GetCount();
|
|
}
|
|
|
|
inline const b2ParticlePair* b2ParticleSystem::GetPairs() const
|
|
{
|
|
return m_pairBuffer.Data();
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetPairCount() const
|
|
{
|
|
return m_pairBuffer.GetCount();
|
|
}
|
|
|
|
inline const b2ParticleTriad* b2ParticleSystem::GetTriads() const
|
|
{
|
|
return m_triadBuffer.Data();
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetTriadCount() const
|
|
{
|
|
return m_triadBuffer.GetCount();
|
|
}
|
|
|
|
inline b2ParticleSystem* b2ParticleSystem::GetNext()
|
|
{
|
|
return m_next;
|
|
}
|
|
|
|
inline const b2ParticleSystem* b2ParticleSystem::GetNext() const
|
|
{
|
|
return m_next;
|
|
}
|
|
|
|
inline const int32* b2ParticleSystem::GetStuckCandidates() const
|
|
{
|
|
return m_stuckParticleBuffer.Data();
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetStuckCandidateCount() const
|
|
{
|
|
return m_stuckParticleBuffer.GetCount();
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetStrictContactCheck(bool enabled)
|
|
{
|
|
m_def.strictContactCheck = enabled;
|
|
}
|
|
|
|
inline bool b2ParticleSystem::GetStrictContactCheck() const
|
|
{
|
|
return m_def.strictContactCheck;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetRadius(float32 radius)
|
|
{
|
|
m_particleDiameter = 2 * radius;
|
|
m_squaredDiameter = m_particleDiameter * m_particleDiameter;
|
|
m_inverseDiameter = 1 / m_particleDiameter;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetDensity(float32 density)
|
|
{
|
|
m_def.density = density;
|
|
m_inverseDensity = 1 / m_def.density;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetDensity() const
|
|
{
|
|
return m_def.density;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetGravityScale(float32 gravityScale)
|
|
{
|
|
m_def.gravityScale = gravityScale;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetGravityScale() const
|
|
{
|
|
return m_def.gravityScale;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetDamping(float32 damping)
|
|
{
|
|
m_def.dampingStrength = damping;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetDamping() const
|
|
{
|
|
return m_def.dampingStrength;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetStaticPressureIterations(int32 iterations)
|
|
{
|
|
m_def.staticPressureIterations = iterations;
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetStaticPressureIterations() const
|
|
{
|
|
return m_def.staticPressureIterations;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetRadius() const
|
|
{
|
|
return m_particleDiameter / 2;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetCriticalVelocity(const b2TimeStep& step) const
|
|
{
|
|
return m_particleDiameter * step.inv_dt;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetCriticalVelocitySquared(
|
|
const b2TimeStep& step) const
|
|
{
|
|
float32 velocity = GetCriticalVelocity(step);
|
|
return velocity * velocity;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetCriticalPressure(const b2TimeStep& step) const
|
|
{
|
|
return m_def.density * GetCriticalVelocitySquared(step);
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetParticleStride() const
|
|
{
|
|
return b2_particleStride * m_particleDiameter;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetParticleMass() const
|
|
{
|
|
float32 stride = GetParticleStride();
|
|
return m_def.density * stride * stride;
|
|
}
|
|
|
|
inline float32 b2ParticleSystem::GetParticleInvMass() const
|
|
{
|
|
// mass = density * stride^2, so we take the inverse of this.
|
|
float32 inverseStride = m_inverseDiameter * (1.0f / b2_particleStride);
|
|
return m_inverseDensity * inverseStride * inverseStride;
|
|
}
|
|
|
|
inline b2Vec2* b2ParticleSystem::GetPositionBuffer()
|
|
{
|
|
return m_positionBuffer.data;
|
|
}
|
|
|
|
inline b2Vec2* b2ParticleSystem::GetVelocityBuffer()
|
|
{
|
|
return m_velocityBuffer.data;
|
|
}
|
|
|
|
inline float32* b2ParticleSystem::GetWeightBuffer()
|
|
{
|
|
return m_weightBuffer;
|
|
}
|
|
|
|
inline int32 b2ParticleSystem::GetMaxParticleCount() const
|
|
{
|
|
return m_def.maxCount;
|
|
}
|
|
|
|
inline void b2ParticleSystem::SetMaxParticleCount(int32 count)
|
|
{
|
|
b2Assert(m_count <= count || count == 0);
|
|
m_def.maxCount = count;
|
|
}
|
|
|
|
inline uint32 b2ParticleSystem::GetAllParticleFlags() const
|
|
{
|
|
return m_allParticleFlags;
|
|
}
|
|
|
|
inline uint32 b2ParticleSystem::GetAllGroupFlags() const
|
|
{
|
|
return m_allGroupFlags;
|
|
}
|
|
|
|
inline const uint32* b2ParticleSystem::GetFlagsBuffer() const
|
|
{
|
|
return m_flagsBuffer.data;
|
|
}
|
|
|
|
inline const b2Vec2* b2ParticleSystem::GetPositionBuffer() const
|
|
{
|
|
return m_positionBuffer.data;
|
|
}
|
|
|
|
inline const b2Vec2* b2ParticleSystem::GetVelocityBuffer() const
|
|
{
|
|
return m_velocityBuffer.data;
|
|
}
|
|
|
|
inline const b2ParticleColor* b2ParticleSystem::GetColorBuffer() const
|
|
{
|
|
return ((b2ParticleSystem*) this)->GetColorBuffer();
|
|
}
|
|
|
|
inline const b2ParticleGroup* const* b2ParticleSystem::GetGroupBuffer() const
|
|
{
|
|
return m_groupBuffer;
|
|
}
|
|
|
|
inline const float32* b2ParticleSystem::GetWeightBuffer() const
|
|
{
|
|
return m_weightBuffer;
|
|
}
|
|
|
|
inline void* const* b2ParticleSystem::GetUserDataBuffer() const
|
|
{
|
|
return ((b2ParticleSystem*) this)->GetUserDataBuffer();
|
|
}
|
|
|
|
inline b2ParticleGroup* const* b2ParticleSystem::GetGroupBuffer()
|
|
{
|
|
return m_groupBuffer;
|
|
}
|
|
|
|
inline uint32 b2ParticleSystem::GetParticleFlags(int32 index)
|
|
{
|
|
return GetFlagsBuffer()[index];
|
|
}
|
|
|
|
inline bool b2ParticleSystem::ValidateParticleIndex(const int32 index) const
|
|
{
|
|
return index >= 0 && index < GetParticleCount() &&
|
|
index != b2_invalidParticleIndex;
|
|
}
|
|
|
|
inline bool b2ParticleSystem::GetDestructionByAge() const
|
|
{
|
|
return m_def.destroyByAge;
|
|
}
|
|
|
|
inline void b2ParticleSystem::ParticleApplyLinearImpulse(int32 index,
|
|
const b2Vec2& impulse)
|
|
{
|
|
ApplyLinearImpulse(index, index + 1, impulse);
|
|
}
|
|
|
|
|
|
// Note: These functions must go in the header so the unit tests will compile
|
|
// them. b2ParticleSystem.cpp does not compile with this #define.
|
|
#if LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
|
|
inline void b2ParticleSystem::SetParticleVelocity(int32 index,
|
|
float32 vx,
|
|
float32 vy)
|
|
{
|
|
b2Vec2& v = GetVelocityBuffer()[index];
|
|
v.x = vx;
|
|
v.y = vy;
|
|
}
|
|
|
|
inline float b2ParticleSystem::GetParticlePositionX(int32 index) const
|
|
{
|
|
return GetPositionBuffer()[index].x;
|
|
}
|
|
|
|
inline float b2ParticleSystem::GetParticlePositionY(int32 index) const
|
|
{
|
|
return GetPositionBuffer()[index].y;
|
|
}
|
|
|
|
inline int b2ParticleSystem::CopyPositionBuffer(int startIndex,
|
|
int numParticles,
|
|
void* outBuf,
|
|
int size) const
|
|
{
|
|
int copySize = numParticles * sizeof(b2Vec2);
|
|
void* inBufWithOffset = (void*) (GetPositionBuffer() + startIndex);
|
|
return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
|
|
copySize);
|
|
}
|
|
|
|
inline int b2ParticleSystem::CopyColorBuffer(int startIndex,
|
|
int numParticles,
|
|
void* outBuf,
|
|
int size) const
|
|
{
|
|
int copySize = numParticles * sizeof(b2ParticleColor);
|
|
void* inBufWithOffset = (void*) (GetColorBuffer() + startIndex);
|
|
return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
|
|
copySize);
|
|
}
|
|
|
|
inline int b2ParticleSystem::CopyWeightBuffer(int startIndex,
|
|
int numParticles,
|
|
void* outBuf,
|
|
int size) const
|
|
{
|
|
int copySize = numParticles * sizeof(float32);
|
|
void* inBufWithOffset = (void*) (GetWeightBuffer() + startIndex);
|
|
return CopyBuffer(startIndex, numParticles, inBufWithOffset, outBuf, size,
|
|
copySize);
|
|
}
|
|
|
|
inline int b2ParticleSystem::CopyBuffer(int startIndex, int numParticles,
|
|
void* inBufWithOffset, void* outBuf,
|
|
int outBufSize, int copySize) const
|
|
{
|
|
b2ExceptionType exception = IsBufCopyValid(startIndex, numParticles,
|
|
copySize, outBufSize);
|
|
if (exception != b2_noExceptions)
|
|
{
|
|
return exception;
|
|
}
|
|
|
|
memcpy(outBuf, inBufWithOffset, copySize);
|
|
return b2_noExceptions;
|
|
}
|
|
|
|
#endif // LIQUIDFUN_EXTERNAL_LANGUAGE_API
|
|
|
|
#endif
|
|
|