Changing Collision Poly

bool actionParticleCollisions( const t2dParticleEffect* pParentEffect, const F32 elapsedTime, t2dPhysics::cCollisionStatus& sendCollisionStatus, CDebugStats* pDebugStats );

bool t2dParticleEmitter::actionParticleCollisions( const t2dParticleEffect* pParentEffect, const F32 elapsedTime, t2dPhysics::cCollisionStatus& sendCollisionStatus, CDebugStats* pDebugStats )
{
    // Reset Initial Collision Status.
    bool collisionStatus = false;

    // Fetch SceneGraph.
    t2dSceneGraph* pSceneGraph = pParentEffect->getSceneGraph();

    // Get Parent Collision Masks.
    const U32 groupMask = pParentEffect->getCollisionGroupMask();
    const U32 layerMask = pParentEffect->getCollisionLayerMask();

    // Get Parent Collision Response.
    const t2dPhysics::eCollisionResponse collisionResponse = pParentEffect->getCollisionResponseMode();

    // Get Parent Restitution.
    const F32 restitution = pParentEffect->getRestitution();

    // Fetch First Particle Node.
    tParticleNode* pParticleNode = mParticleNodeHead.mNextNode;

    // Next Particle Node.
    tParticleNode* pNextParticleNode;

    // Process All particle nodes.
    while ( pParticleNode != &mParticleNodeHead )
    {
        t2dVector newPosition;

        // Default to not suppressing movement.
        pParticleNode->mSuppressMovement = false;

        // Fetch Start Position.
        t2dVector& startPosition = pParticleNode->mPosition;
        // Calculate Projected Position.
        const t2dVector endPosition = pParticleNode->mPosition + (pParticleNode->mVelocity * pParticleNode->mRenderSpeed * elapsedTime);

        // Pick Objects along our velocity path.
        const U32 pickedObjects = pSceneGraph->pickLine( startPosition, endPosition, groupMask, layerMask, false, pParentEffect );

        // Reference next Particle Node.
        // NOTE:-   We do this here because we may destroy the particle if the collision-response is in "KILL" mode.
        pNextParticleNode = pParticleNode->mNextNode;

        // Did we collide?
        if ( pickedObjects > 0 )
        {
            // Flag Collision Occurred.
            collisionStatus = true;

            // Fetch Colliding Object.
            typeSceneObjectVectorConstRef pickVector = pSceneGraph->getPickList();
            // Fetch Scene Object.
            t2dSceneObject* pSceneObject = pickVector[0];
            // Fetch Collisoin Time.
            const F32& collisionTime = pSceneObject->mSortKeyCollisionTime;

            // Lerp to collision position.
            startPosition.lerp( endPosition, collisionTime, startPosition );

            // Reference Velocity.
            t2dVector& linearVelocity = pParticleNode->mVelocity;
            // Reference Collision Normal.
            t2dVector& collisionNormal = pSceneObject->mSortKeyCollisionNormal;

            switch( collisionResponse )
            {
                // Bounce.
                case t2dPhysics::T2D_RESPONSE_BOUNCE:
                {
                    // Calculate Dot Velocity Normal.
                    const F32 dotVelocityNormal = collisionNormal * linearVelocity;
                    // Any velocity to clamp?
                    if ( dotVelocityNormal < 0.0f )
                    {
                        // Set new Linear Velocity.
                        linearVelocity -= (collisionNormal*(2.0f*dotVelocityNormal) * restitution);
                    }

                } break;

                // Clamp.
                case t2dPhysics::T2D_RESPONSE_CLAMP:
                {
                    // Calculate Dot Velocity Normal.
                    const F32 dotVelocityNormal = collisionNormal * linearVelocity;
                    // Any velocity to clamp?
                    if ( dotVelocityNormal < 0.0f )
                    {
                        // Set new Linear Velocity.
                        linearVelocity -= collisionNormal*dotVelocityNormal;
                    }

                } break;

                // Bounce.
                case t2dPhysics::T2D_RESPONSE_STICKY:
                {
                    // Set at rest.
                    linearVelocity.set(0.0f,0.0f);

                } break;

                // Kill.
                case t2dPhysics::T2D_RESPONSE_KILL:
                {
                    // Free Particle.
                    freeParticle( pParticleNode );

                } break;
            };

            // Suppress Movment.
            pParticleNode->mSuppressMovement = true;
        }

        // Move to next Particle Node.
        pParticleNode = pNextParticleNode;
    };   

    // Return Collision Status.
    return collisionStatus;
}

bool t2dParticleEffect::checkCollisionSend( const F32 elapsedTime, t2dPhysics::cCollisionStatus& sendCollisionStatus, CDebugStats* pDebugStats )
{
    // Use Effect Collisions?
    if ( mUseEffectCollisions )
    {
        // Yes, so use standard core-collision.
        return Parent::checkCollisionSend( elapsedTime, sendCollisionStatus, pDebugStats );
    }


// T2D Debug Profiling.
#ifdef T2D_DEBUG_PROFILING
    PROFILE_START(T2D_t2dParticleEffect_checkCollisionSend);
#endif

    // Reset Initial Collision Status.
    bool collisionStatus = false;

    // Update all emitters.
    for ( U32 n = 0; n < mParticleEmitterList.size(); n++ )
    {
        // Fetch Particle Emitter Reference.
        t2dParticleEmitter*& particleEmitter = mParticleEmitterList[n];

        // Integrate Emitter (if visible).
        if ( particleEmitter->getVisible() && particleEmitter->getEmitterCollisionStatus() )
        {
            // Action Particle Collision.
            if ( particleEmitter->actionParticleCollisions( this, elapsedTime, sendCollisionStatus, pDebugStats ) )
            {
                // Flag Collision Occurred.
                collisionStatus = true;
            }
        }
    }

    // Did a collision occur.
    if ( collisionStatus )
    {
        // Yes, so perform callback.
        Con::executef( this, 1, "onParticleCollision" );
    }

// T2D Debug Profiling.
#ifdef T2D_DEBUG_PROFILING
    PROFILE_END();   // T2D_t2dParticleEffect_checkCollisionSend
#endif

    // Return No Collision Always.
    // NOTE:-   This stops the particle-effect object from ever receiving collisions itself!
    return false;
}