PABounce Struct Reference

#include <actions.h>

Inheritance diagram for PABounce:

[legend]

Collaboration diagram for PABounce:

[legend]

List of all members.

Public Member Functions
	~PABounce ()
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	oneMinusFriction
float	resilience
float	cutoffSqr
	EXEC_METHOD

---

Detailed Description

Definition at line 63 of file actions.h.

---

Constructor & Destructor Documentation

PABounce::~PABounce

(

)

[inline]

Definition at line 72 of file actions.h.

References position.

{delete position;}

---

Member Function Documentation

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

Definition at line 313 of file actions.cpp.

References cutoffSqr, PDTriangle::D, PActionBase::dt, pVec::length2(), NewBasis(), PDTriangle::nrm, oneMinusFriction, PDTriangle::p, Particle::pos, pSameSign(), resilience, PDTriangle::u, PDTriangle::v, and Particle::vel.

{
    pVec s1, s2;
    NewBasis(dom.u, dom.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;

        // 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 tangential and normal components of velocity
        pVec vn = dom.nrm * nv; // Normal Vn = (V.N)N
        pVec vt = m.vel - vn;   // Tangent Vt = V - Vn

        // Compute new velocity heading out:
        // Don't apply friction if tangential velocity < cutoff
        if(vt.length2() <= cutoffSqr)
            m.vel = vt - vn * resilience;
        else
            m.vel = vt * oneMinusFriction - vn * resilience;
    }
}

Here is the call graph for this function:

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

Definition at line 362 of file actions.cpp.

References cutoffSqr, PDRectangle::D, PActionBase::dt, pVec::length2(), NewBasis(), PDRectangle::nrm, oneMinusFriction, PDRectangle::p, Particle::pos, pSameSign(), resilience, PDRectangle::u, PDRectangle::v, and Particle::vel.

{
    pVec s1, s2;
    NewBasis(dom.u, dom.v, s1, s2);

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

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

        // 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 rectangle?
        if(upos < 0 || upos > 1 || vpos < 0 || vpos > 1)
            continue;

        // A hit! A most palpable hit!
        // Compute tangential and normal components of velocity
        pVec vn = dom.nrm * nv; // Normal Vn = (V.N)N
        pVec vt = m.vel - vn;   // Tangent Vt = V - Vn

        // Compute new velocity heading out:
        // Don't apply friction if tangential velocity < cutoff
        if(vt.length2() <= cutoffSqr)
            m.vel = vt - vn * resilience;
        else
            m.vel = vt * oneMinusFriction - vn * resilience;
    }
}

Here is the call graph for this function:

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

Definition at line 411 of file actions.cpp.

References cutoffSqr, PDPlane::D, PActionBase::dt, pVec::length2(), PDPlane::nrm, oneMinusFriction, Particle::pos, pSameSign(), resilience, and Particle::vel.

{
    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;

        // 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

        // A hit! A most palpable hit!
        // Compute tangential and normal components of velocity
        pVec vn = dom.nrm * nv; // Normal Vn = (V.N)N
        pVec vt = m.vel - vn;   // Tangent Vt = V - Vn

        // Compute new velocity heading out:
        // Don't apply friction if tangential velocity < cutoff
        if(vt.length2() <= cutoffSqr)
            m.vel = vt - vn * resilience;
        else
            m.vel = vt * oneMinusFriction - vn * resilience;
    }
}

Here is the call graph for this function:

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

Definition at line 445 of file actions.cpp.

References PDSphere::ctr, cutoffSqr, PActionBase::dt, pVec::length(), pVec::length2(), pVec::normalize(), oneMinusFriction, PASSERT, Particle::pos, PDSphere::radIn, PDSphere::radOut, resilience, Particle::vel, and PDSphere::Within().

{
    PASSERT(dom.radIn == 0.0f, "Bouncing doesn't work on thick shells. radIn must be 0.");

    float dtinv = 1.0f / dt;

    // Bounce particles off the inside or outside of the sphere
    for (ParticleList::iterator it = ibegin; it != iend; it++) {
        Particle &m = (*it);

        // See if particle's next position is on the opposite side of the domain. If so, bounce it.
        pVec pnext = m.pos + m.vel * dt;

        if(dom.Within(m.pos)) {
            // We are bouncing off the inside of the sphere.
            if(dom.Within(pnext))
                // Still inside. Do nothing.
                continue;

            // Trying to go outside. Bounce back in.

            // Inward-pointing normal to surface. This isn't computed quite right;
            // should extrapolate particle position to surface.
            pVec n(dom.ctr - m.pos);
            n.normalize();

            // Compute tangential and normal components of velocity
            float nmag = m.vel * n;

            pVec vn = n * nmag;   // Velocity in Normal dir  Vn = (V.N)N
            pVec vt = m.vel - vn; // Velocity in Tangent dir Vt = V - Vn

            // Reverse normal component of velocity
            if(nmag < 0) vn = -vn; // Don't reverse if it's already heading inward

            // Compute new velocity heading out:
            // Don't apply friction if tangential velocity < cutoff
            float tanscale = (vt.length2() <= cutoffSqr) ? 1.0f : oneMinusFriction;
            m.vel = vt * tanscale + vn * resilience;

            // Now see where the point will end up. Make sure we fixed it to stay inside.
            pVec pthree = m.pos + m.vel * dt;
            if(dom.Within(pthree)) {
                // Still inside. We're good.
                continue;
            } else {
                // Since the tangent plane is outside the sphere, reflecting the velocity vector about it won't necessarily bring it inside the sphere.
                pVec toctr = dom.ctr - pthree;
                float dist = toctr.length();
                pVec pwish = dom.ctr - toctr * (0.999f * dom.radOut / dist); // pwish is a point just inside the sphere
                m.vel = (pwish - m.pos) * dtinv; // Compute a velocity to get us to pwish.
            }
        } else {
            // We are bouncing off the outside of the sphere.
            if(!dom.Within(pnext))
                continue;

            // Trying to go inside. Bounce back out.

            // Outward-pointing normal to surface. This isn't computed quite right;
            // should extrapolate particle position to surface.
            pVec n = m.pos - dom.ctr;
            n.normalize();

            // Compute tangential and normal components of velocity
            float nmag = m.vel * n;

            pVec vn = n * nmag;   // Velocity in Normal dir  Vn = (V.N)N
            pVec vt = m.vel - vn; // Velocity in Tangent dir Vt = V - Vn

            // Reverse normal component of velocity if it points in
            if(nmag < 0)
                vn = -vn;

            // Compute new velocity heading out:
            // Don't apply friction if tangential velocity < cutoff
            float tanscale = (vt.length2() <= cutoffSqr) ? 1.0f : oneMinusFriction;
            m.vel = vt * tanscale + vn * resilience;
        }
    }
}

Here is the call graph for this function:

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

Definition at line 527 of file actions.cpp.

References cutoffSqr, PDDisc::D, PActionBase::dt, pVec::length2(), PDDisc::nrm, oneMinusFriction, PDDisc::p, Particle::pos, pSameSign(), PDDisc::radOutSqr, resilience, and Particle::vel.

{
    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;

        // 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

        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;

        // A hit! A most palpable hit!
        // Compute tangential and normal components of velocity
        pVec vn = dom.nrm * nv; // Normal Vn = (V.N)N
        pVec vt = m.vel - vn;   // Tangent Vt = V - Vn

        // Compute new velocity heading out:
        // Don't apply friction if tangential velocity < cutoff
        if(vt.length2() <= cutoffSqr)
            m.vel = vt - vn * resilience;
        else
            m.vel = vt * oneMinusFriction - vn * resilience;
    }
}

Here is the call graph for this function:

---

Member Data Documentation

pDomain* PABounce::position

Definition at line 65 of file actions.h.

Referenced by pBounce(), and ~PABounce().

float PABounce::oneMinusFriction

Definition at line 66 of file actions.h.

Referenced by Exec(), and pBounce().

float PABounce::resilience

Definition at line 67 of file actions.h.

Referenced by Exec(), and pBounce().

float PABounce::cutoffSqr

Definition at line 68 of file actions.h.

Referenced by Exec(), and pBounce().

PABounce::EXEC_METHOD

Reimplemented from PActionBase.

Definition at line 70 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

---