PAAvoid Struct Reference

#include <actions.h>

Inheritance diagram for PAAvoid:

[legend]

Collaboration diagram for PAAvoid:

[legend]

List of all members.

Public Member Functions
	~PAAvoid ()
void	Exec (const PDTriangle &dom, ParticleGroup &group, ParticleList::iterator ibegin, ParticleList::iterator iend)
void	Exec (const PDRectangle &dom, ParticleGroup &group, ParticleList::iterator ibegin, ParticleList::iterator iend)
void	Exec (const PDPlane &dom, ParticleGroup &group, ParticleList::iterator ibegin, ParticleList::iterator iend)
void	Exec (const PDSphere &dom, ParticleGroup &group, ParticleList::iterator ibegin, ParticleList::iterator iend)
void	Exec (const PDDisc &dom, ParticleGroup &group, ParticleList::iterator ibegin, ParticleList::iterator iend)
Public Attributes
pDomain *	position
float	look_ahead
float	magnitude
float	epsilon
	EXEC_METHOD

---

Detailed Description

Definition at line 45 of file actions.h.

---

Constructor & Destructor Documentation

PAAvoid::~PAAvoid

(

)

[inline]

Definition at line 54 of file actions.h.

References position.

{delete position;}

---

Member Function Documentation

void PAAvoid::Exec	(	const PDTriangle &	dom,
		ParticleGroup &	group,
		ParticleList::iterator	ibegin,
		ParticleList::iterator	iend
	)

Definition at line 31 of file actions.cpp.

References PDTriangle::D, PActionBase::dt, epsilon, fsqr(), pVec::length(), pVec::length2(), look_ahead, magnitude, NewBasis(), pVec::normalize(), PDTriangle::nrm, PDTriangle::p, Particle::pos, pSameSign(), PDTriangle::u, PDTriangle::uNrm, PDTriangle::v, Particle::vel, and PDTriangle::vNrm.

{
    float magdt = magnitude * dt;

    const pVec &u = dom.u;
    const pVec &v = dom.v;

    // The normalized bases are needed inside the loop.
    const pVec &un = dom.uNrm;
    const pVec &vn = dom.vNrm;

    // f is the third (non-basis) triangle edge.
    pVec f = v - u;
    pVec fn = f;
    fn.normalize();

    // Compute the inverse matrix of the plane basis.
    pVec s1, s2;
    NewBasis(u, v, s1, s2);

    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // See if particle's current and look_ahead positions cross plane.
        // If not, couldn't hit, so keep going.
        pVec pnext = m.pos + m.vel * dt * look_ahead;

        // nrm stores the plane normal (the a,b,c of the plane eqn).
        // Old and new distances: dist(p,plane) = n * p + d
        float distold = m.pos * dom.nrm + dom.D;
        float distnew = pnext * dom.nrm + dom.D;

        if(pSameSign(distold, distnew))
            continue;

        float nv = dom.nrm * m.vel;
        float t = -distold / nv; // Time steps before hit

        pVec phit = m.pos + m.vel * t; // Actual intersection point
        pVec offset = phit - dom.p; // Offset from origin in plane

        // Dot product with basis vectors of old frame
        // in terms of new frame gives position in uv frame.
        float upos = offset * s1;
        float vpos = offset * s2;

        // Did it cross plane outside triangle?
        if(upos < 0 || vpos < 0 || (upos + vpos) > 1)
            continue;

        // A hit! A most palpable hit!
        // Compute distance to the three edges.
        pVec uofs = (un * (un * offset)) - offset;
        float udistSqr = uofs.length2();
        pVec vofs = (vn * (vn * offset)) - offset;
        float vdistSqr = vofs.length2();

        pVec foffset = offset - u;
        pVec fofs = (fn * (fn * foffset)) - foffset;
        float fdistSqr = fofs.length2();

        // S is the safety vector toward the closest point on boundary.
        pVec S;
        if(udistSqr <= vdistSqr && udistSqr <= fdistSqr) S = uofs;
        else if(vdistSqr <= fdistSqr) S = vofs;
        else S = fofs;

        // Blend S with m.vel.
        S.normalize();

        float vm = m.vel.length();
        pVec Vn = m.vel / vm;

        pVec dir = (S * (magdt / (fsqr(t)+epsilon))) + Vn;
        m.vel = dir * (vm / dir.length()); // Speed of m.vel, but in direction dir.
    }
}

Here is the call graph for this function:

void PAAvoid::Exec	(	const PDRectangle &	dom,
		ParticleGroup &	group,
		ParticleList::iterator	ibegin,
		ParticleList::iterator	iend
	)

Definition at line 109 of file actions.cpp.

References PDRectangle::D, PActionBase::dt, epsilon, fsqr(), pVec::length(), pVec::length2(), look_ahead, magnitude, NewBasis(), pVec::normalize(), PDRectangle::nrm, PDRectangle::p, Particle::pos, pSameSign(), PDRectangle::u, PDRectangle::uNrm, PDRectangle::v, Particle::vel, and PDRectangle::vNrm.

{
    float magdt = magnitude * dt;

    const pVec &u = dom.u;
    const pVec &v = dom.v;

    // The normalized bases are needed inside the loop.
    const pVec &un = dom.uNrm;
    const pVec &vn = dom.vNrm;

    // Compute the inverse matrix of the plane basis.
    pVec s1, s2;
    NewBasis(u, v, s1, s2);

    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // See if particle's current and look_ahead positions cross plane.
        // If not, couldn't hit, so keep going.
        pVec pnext = m.pos + m.vel * dt * look_ahead;

        // nrm stores the plane normal (the a,b,c of the plane eqn).
        // Old and new distances: dist(p,plane) = n * p + d
        float distold = m.pos * dom.nrm + dom.D;
        float distnew = pnext * dom.nrm + dom.D;

        if(pSameSign(distold, distnew))
            continue;

        float nv = dom.nrm * m.vel;
        float t = -distold / nv;

        pVec phit = m.pos + m.vel * t; // Actual intersection point
        pVec offset = phit - dom.p; // Offset from origin in plane

        // Dot product with basis vectors of old frame
        // in terms of new frame gives position in uv frame.
        float upos = offset * s1;
        float vpos = offset * s2;

        // Did it cross plane outside rectangle?
        if(upos < 0 || vpos < 0 || upos > 1 || vpos > 1)
            continue;

        // A hit! A most palpable hit!
        // Compute distance to the three edges.
        pVec uofs = (un * (un * offset)) - offset;
        float udistSqr = uofs.length2();
        pVec vofs = (vn * (vn * offset)) - offset;
        float vdistSqr = vofs.length2();

        pVec foffset = (u + v) - offset;
        pVec fofs = (un * (un * foffset)) - foffset;
        float fdistSqr = fofs.length2();
        pVec gofs = (un * (un * foffset)) - foffset;
        float gdistSqr = gofs.length2();

        pVec S;
        if(udistSqr <= vdistSqr && udistSqr <= fdistSqr
                && udistSqr <= gdistSqr) S = uofs;
        else if(vdistSqr <= fdistSqr && vdistSqr <= gdistSqr) S = vofs;
        else if(fdistSqr <= gdistSqr) S = fofs;
        else S = gofs;

        // Blend S with m.vel.
        S.normalize();

        float vm = m.vel.length();
        pVec Vn = m.vel / vm;

        pVec dir = (S * (magdt / (fsqr(t)+epsilon))) + Vn;
        m.vel = dir * (vm / dir.length()); // Speed of m.vel, but in direction dir.
    }
}

Here is the call graph for this function:

void PAAvoid::Exec	(	const PDPlane &	dom,
		ParticleGroup &	group,
		ParticleList::iterator	ibegin,
		ParticleList::iterator	iend
	)

Definition at line 185 of file actions.cpp.

References PDPlane::D, PActionBase::dt, epsilon, fsqr(), pVec::length(), look_ahead, magnitude, PDPlane::nrm, Particle::pos, pSameSign(), and Particle::vel.

{
    float magdt = magnitude * dt;

    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // See if particle's current and look_ahead positions cross plane.
        // If not, couldn't hit, so keep going.
        pVec pnext = m.pos + m.vel * dt * look_ahead;

        // nrm stores the plane normal (the a,b,c of the plane eqn).
        // Old and new distances: dist(p,plane) = n * p + d
        float distold = m.pos * dom.nrm + dom.D;
        float distnew = pnext * dom.nrm + dom.D;

        if(pSameSign(distold, distnew))
            continue;

        float nv = dom.nrm * m.vel;
        float t = -distold / nv;

        // Blend S with m.vel.
        const pVec &S = dom.nrm;

        float vm = m.vel.length();
        pVec Vn = m.vel / vm;

        pVec dir = (S * (magdt / (fsqr(t)+epsilon))) + Vn;
        m.vel = dir * (vm / dir.length()); // Speed of m.vel, but in direction dir.
    }
}

Here is the call graph for this function:

void PAAvoid::Exec	(	const PDSphere &	dom,
		ParticleGroup &	group,
		ParticleList::iterator	ibegin,
		ParticleList::iterator	iend
	)

Definition at line 219 of file actions.cpp.

References PDSphere::ctr, PActionBase::dt, epsilon, fsqr(), pVec::length(), look_ahead, magnitude, pVec::normalize(), Particle::pos, PDSphere::radOutSqr, sqrtf(), and Particle::vel.

{
    float magdt = magnitude * dt;

    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // First do a ray-sphere intersection test and see if it's soon enough.
        // Can I do this faster without t?
        float vm = m.vel.length();
        pVec Vn = m.vel / vm;

        pVec L = dom.ctr - m.pos;
        float v = L * Vn;

        float disc = dom.radOutSqr - (L * L) + fsqr(v);
        if(disc < 0)
            continue; // I'm not heading toward it.

        // Compute length for second rejection test.
        float t = v - sqrtf(disc);
        if(t < 0 || t > (vm * look_ahead))
            continue;

        // Get a vector to safety.
        pVec C = Cross(Vn, L);
        C.normalize();
        pVec S = Cross(Vn, C);

        pVec dir = (S * (magdt / (fsqr(t)+epsilon))) + Vn;
        m.vel = dir * (vm / dir.length()); // Speed of m.vel, but in direction dir.
    }
}

Here is the call graph for this function:

void PAAvoid::Exec	(	const PDDisc &	dom,
		ParticleGroup &	group,
		ParticleList::iterator	ibegin,
		ParticleList::iterator	iend
	)

Definition at line 253 of file actions.cpp.

References PDDisc::D, PActionBase::dt, epsilon, fsqr(), pVec::length(), pVec::length2(), look_ahead, magnitude, PDDisc::nrm, PDDisc::p, Particle::pos, pSameSign(), PDDisc::radOutSqr, and Particle::vel.

{
    float magdt = magnitude * dt;

    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // See if particle's current and look_ahead positions cross plane.
        // If not, couldn't hit, so keep going.
        pVec pnext = m.pos + m.vel * dt * look_ahead;

        // nrm stores the plane normal (the a,b,c of the plane eqn).
        // Old and new distances: dist(p,plane) = n * p + d
        float distold = m.pos * dom.nrm + dom.D;
        float distnew = pnext * dom.nrm + dom.D;

        if(pSameSign(distold, distnew))
            continue;

        float nv = dom.nrm * m.vel;
        float t = -distold / nv;

        pVec phit = m.pos + m.vel * t; // Actual intersection point
        pVec offset = phit - dom.p; // Offset from origin in plane

        float radSqr = offset.length2();

        // Are we going to hit the disc ring? If so, always turn to the OUTSIDE of the ring.
        if(radSqr < dom.radInSqr || radSqr > dom.radOutSqr)
            continue;

        // Blend S with m.vel.
        pVec S = offset;

        float vm = m.vel.length();
        pVec Vn = m.vel / vm;

        pVec dir = (S * (magdt / (fsqr(t)+epsilon))) + Vn;
        m.vel = dir * (vm / dir.length()); // Speed of m.vel, but in direction dir.
    }
}

Here is the call graph for this function:

---

Member Data Documentation

pDomain* PAAvoid::position

Definition at line 47 of file actions.h.

Referenced by pAvoid(), and ~PAAvoid().

float PAAvoid::look_ahead

Definition at line 48 of file actions.h.

Referenced by Exec(), and pAvoid().

float PAAvoid::magnitude

Definition at line 49 of file actions.h.

Referenced by Exec(), and pAvoid().

float PAAvoid::epsilon

Definition at line 50 of file actions.h.

Referenced by Exec(), and pAvoid().

PAAvoid::EXEC_METHOD

Reimplemented from PActionBase.

Definition at line 52 of file actions.h.

---

The documentation for this struct was generated from the following files:

• src/thirdparty/particles/ParticleDLL/actions.h
• src/thirdparty/particles/ParticleDLL/actions.cpp

---