c:/Users/DaveMc/Desktop/Particle221Src/Particle2/Particle/pAPI.h

#ifndef particle_api_h
#define particle_api_h

#include "pDomain.h"

namespace PAPI {
    const int P_VERSION = 220;

    const float P_MAXFLOAT = 1.0e16f; // Actually this must be < sqrt(MAXFLOAT) since we store this value squared.

    const float P_EPS = 1e-3f;

    const size_t P_MAXINT = 0x7fffffff;

    typedef void (*P_PARTICLE_CALLBACK)(struct Particle_t &particle, puint64 data);

    class PInternalState_t; // The API-internal struct containing the context's state. Don't try to use it.
    class PInternalSourceState_t; // The API-internal struct containing the context's source state. Don't try to use it.

    class PContextSourceState_t
    {
    public:
        void Color(const pVec &color, const float alpha = 1.0f);

        void Color(const float red, const float green, const float blue, const float alpha = 1.0f);

        void Color(const pDomain &cdom);

        void Color(const pDomain &cdom, 
            const pDomain &adom 
            );

        void Data(const puint64 data);

        void Size(const pVec &size);

        void Size(const pDomain &dom);

        void Mass(const float mass);

        void RotVelocity(const pVec &v);

        void RotVelocity(const pDomain &dom);

        void StartingAge(const float age, 
            const float sigma = 0.0f 
            );

        void UpVec(const pVec &v);

        void UpVec(const pDomain &dom);

        void Velocity(const pVec &vel);

        void Velocity(const pDomain &dom);

        void VertexB(const pVec &v);

        void VertexB(const pDomain &dom);

        void VertexBTracks(const bool track_vertex = true);

        void ResetSourceState();

    protected:
        PInternalSourceState_t *PSS;
        void InternalSetup(PInternalSourceState_t *Sr);
    };

    class PContextActionList_t
    {
    public:
        void Seed(const unsigned int seed);

        void TimeStep(const float new_dt);

        void CallActionList(const int action_list_num);

        void DeleteActionLists(const int action_list_num, 
            const int action_list_count = 1 
            );

        void EndActionList();

        int GenActionLists(const int action_list_count = 1 
            );

        void NewActionList(const int action_list_num);

    protected:
        PInternalState_t *PS; // The internal API data for this context is stored here.
        void InternalSetup(PInternalState_t *Sr); // Calls this after construction to set up the PS pointer
        PInternalState_t *getInternalState() const; // Return a pointer to the internal state
    };

    class PContextParticleGroup_t
    {
    public:
        void CopyGroup(const int p_src_group_num, 
            const size_t index = 0, 
            const size_t copy_count = P_MAXINT 
            );

        void CurrentGroup(const int p_group_num);

        void DeleteParticleGroups(const int p_group_num, 
            const int p_group_count = 1 
            );

        int GenParticleGroups(const int p_group_count = 1, 
            const size_t max_particles = 0 
            );

        size_t GetGroupCount();

        size_t GetMaxParticles();

        size_t GetParticles(const size_t index, 
            const size_t count, 
            float *position = NULL, 
            float *color = NULL, 
            float *vel = NULL, 
            float *size = NULL, 
            float *age = NULL 
            );

        size_t GetParticlePointer(float *&ptr, 
            size_t &stride, 
            size_t &pos3Ofs, 
            size_t &posB3Ofs, 
            size_t &size3Ofs, 
            size_t &vel3Ofs, 
            size_t &velB3Ofs, 
            size_t &color3Ofs, 
            size_t &alpha1Ofs, 
            size_t &age1Ofs, 
            size_t &up3Ofs, 
            size_t &rvel3Ofs, 
            size_t &upB3Ofs, 
            size_t &mass1Ofs, 
            size_t &data1Ofs 
        );

        void SetMaxParticles(const size_t max_count);

        void BirthCallback(P_PARTICLE_CALLBACK callback, 
            puint64 group_data = 0 
            );

        void DeathCallback(P_PARTICLE_CALLBACK callback, 
            puint64 group_data = 0 
            );

        void SetWorkingSetSize(const int set_size_bytes);

    protected:
        PInternalState_t *PS; // The internal API data for this context is stored here.
        void InternalSetup(PInternalState_t *Sr); // Calls this after construction to set up the PS pointer
    };

    class PContextActions_t
    {
    public:
        void Avoid(float magnitude, 
            const float epsilon, 
            const float look_ahead, 
            const pDomain &dom 
            );

        void Bounce(float friction, 
            const float resilience, 
            const float cutoff, 
            const pDomain &dom 
            );

        void Callback(P_PARTICLE_CALLBACK callback, 
            puint64 call_data = 0 
            );

        void CopyVertexB(const bool copy_pos = true, 
            const bool copy_vel = false 
            );

        void Damping(const pVec &damping, 
            const float vlow = 0.0f, const float vhigh = P_MAXFLOAT);

        void RotDamping(const pVec &damping, 
            const float vlow = 0.0f, const float vhigh = P_MAXFLOAT);

        void Explosion(const pVec &center, 
            const float radius, 
            const float magnitude, 
            const float sigma, 
            const float epsilon = P_EPS 
            );

        void Follow(float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void Gravitate(const float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void Gravity(const pVec &dir);

        void Jet(const pDomain &dom, 
            const pDomain &acc); 

        void KillOld(const float age_limit,
            const bool kill_less_than = false 
            );

        void MatchVelocity(const float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void MatchRotVelocity(const float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void Move(const bool move_velocity = true, 
            const bool move_rotational_velocity = true 
            );

        void OrbitLine(const pVec &p, 
            const pVec &axis, 
            const float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void OrbitPoint(const pVec &center, 
            const float magnitude = 1.0f, 
            const float epsilon = P_EPS, 
            const float max_radius = P_MAXFLOAT 
            );

        void RandomAccel(const pDomain &dom);

        void RandomDisplace(const pDomain &dom);

        void RandomVelocity(const pDomain &dom);

        void RandomRotVelocity(const pDomain &dom);

        void Restore(const float time, 
            const bool vel = true, 
            const bool rvel = true 
            );

        void Sink(const bool kill_inside, 
            const pDomain &dom);

        void SinkVelocity(const bool kill_inside, 
            const pDomain &dom);

        void Sort(const pVec &eye,
            const pVec &look,
            const bool front_to_back = false, 
            const bool clamp_negative = false 
            );

        void Source(const float particle_rate, 
            const pDomain &dom 
            );

        void SpeedLimit(const float min_speed, const float max_speed = P_MAXFLOAT);

        void TargetColor(const pVec &color, 
            const float alpha, 
            const float scale 
            );

        void TargetSize(const pVec &size, 
            const pVec &scale 
            );

        void TargetVelocity(const pVec &vel, 
            const float scale 
            );

        void TargetRotVelocity(const pVec &rvel, 
            const float scale 
            );

        void Vertex(const pVec &v, 
            puint64 data = 0 
            );

        void Vortex(
            const pVec &center, 
            const pVec &axis, 
            const float tightnessExponent, 
            const float max_radius, 
            const float inSpeed, 
            const float upSpeed, 
            const float aroundSpeed 
            );

    protected:
        PInternalState_t *PS; // The internal API data for this context is stored here.
        void InternalSetup(PInternalState_t *Sr); // Calls this after construction to set up the PS pointer
    };

    class ParticleContext_t : public PContextActionList_t, public PContextParticleGroup_t, public PContextActions_t, public PContextSourceState_t
    {
    public:
        ParticleContext_t();

        ~ParticleContext_t();
    };

};

#endif

---