CollisionRectangle.cpp

Go to the documentation of this file.

#include "CollisionRectangle.h"
#include <stdlib.h>
using namespace GraphicsLib;
using namespace ParticleSystems;

CollisionRectangle::CollisionRectangle( Point3 *c1, Point3 *c2, Point3 *c3, Point3 *c4) : CollisionObject() {
    corner1 = c1;
    corner2 = c2;
    corner3 = c3;
    corner4 = c4;
    normal = CalcNormal( corner4, corner3, corner2 );
    //calcCenter();
    //normal.x+=center.x;
    //normal.y+=center.y;
    //normal.z+=center.z;
        #ifdef __COLLISION_PLANE__
        std::cout << center << std::endl;
        #endif

}

CollisionRectangle::~CollisionRectangle() {
}

void CollisionRectangle::collide(Particle *p) {
    distance = getDistance( &normal,&(p->position));
        float ext[6];
        ext[0]=ext[1]=(BBheight()/2.0f);//y
        #ifdef __COLLISION_PLANE__
        //std::cout << "height " << BBheight() << std::endl;
        #endif
        ext[2]=ext[3]=(BBwidth()/2.0f);//x
        #ifdef __COLLISION_PLANE__
        //std::cout << "width " << BBwidth() << std::endl;
        #endif
        ext[4]=ext[5]=(BBdepth()/2.0f);//z
        #ifdef __COLLISION_PLANE__
        //std::cout << "depth " << BBdepth() << std::endl;
        #endif
    #ifdef __COLLISION__
    //std::cout << "Particle position" << " " << p->position << std::endl;
        //std::cout << "Particle velocity" << " " << p->velocity << std::endl;
        //std::cout << "Plane normal" << " " << normal << std::endl;
        //std::cout << "Distance" << " " << distance << std::endl;
    #endif
        
        //check width, height, depth
        //width = -x+x
        //height = -y+y
        //depth = z values
        for(int i =0; i < 6; i++) {
        #ifdef __COLLISION_PLANE__
        //std::cout << "ext[i]" << " " << ext[i] << std::endl;
        //std::cout << "Distance" << " " << distance << std::endl;
        #endif
                if(distance <= BBheight() ) {
                        #ifdef __COLLISION_PLANE__
                        //std::cout << "ext[i]" << " " << ext[i] << std::endl;
                        std::cout << "CRec: Distance" << " " << distance << std::endl;
                        #endif
                        //Dot the direction of the particle with the normal
                        GLfloat x = 2*((p->velocity).dot(normal));
                        Vector newDir = normal*x;
                        #ifdef __COLLISION__
            std::cout << "CRec: Velocity " << p->velocity<< std::endl;
                        std::cout << "CRec: X " << x<< std::endl;
                        std::cout << "Plane normal " << " " << normal << std::endl;
                        std::cout << "CRec: New Velocity " <<newDir<< std::endl;
                        #endif
                        p->velocity = (p->velocity)-newDir;
                        #ifdef __COLLISION__
            std::cout << "CRec: Final Velocity " << p->velocity<< std::endl;
                        #endif
                        p->dead = true;

    }
        }
}

void CollisionRectangle::calcCenter() {

    //(c1-c2)-(c4-c3)
    //(c1-c4)-(c2-c3)
        Real x;
        if(corner1.x == corner3.x) {
                x = corner1.x;
        } else {
                x = corner3.x+corner1.x;
        }
        Real y;
        if(corner1.y == corner3.y) {
                y = corner1.y;
        } else {
                y = corner3.y+corner1.y;
        }
        Real z;
        if(corner1.z == corner3.z) {
                z = corner1.z;
        } else {
                z = corner3.z+corner1.z;
        }
        
   center = new Point3(x,y,z);


    //return center;
}

Real CollisionRectangle::getDistance(Vector *v, Point3 *p) {
    return (v->x * p->x + v->y * p->y + v->z * p->z);
}

void CollisionRectangle::draw() {
glBegin(GL_LINE_LOOP);
        glVertex3f(corner1.x, corner1.y, corner1.z);
        glVertex3f(corner2.x, corner2.y, corner2.z);
    glVertex3f(corner3.x, corner3.y, corner3.z);
    glVertex3f(corner4.x, corner4.y, corner4.z);
glEnd();

}

float CollisionRectangle::BBheight() {
        float maxVal = max(corner1.y,(max(corner2.y,(max(corner3.y,corner4.y)))));
        float minVal = min(corner1.y,(min(corner2.y,(min(corner3.y,corner4.y)))));
        #ifdef __COLLISION_PLANE__
        //std::cout << maxVal << " " << minVal << std::endl;
        #endif
        return fabs(minVal-maxVal);
}

float CollisionRectangle::BBwidth() {
        float maxVal = max(corner1.x,(max(corner2.x,(max(corner3.x,corner4.x)))));
        float minVal = min(corner1.x,(min(corner2.x,(min(corner3.x,corner4.x)))));
        #ifdef __COLLISION_PLANE__
        //std::cout << maxVal << " " << minVal << std::endl;
        #endif
        return fabs(minVal-maxVal);
}

float CollisionRectangle::BBdepth() {
        float maxVal = max(corner1.z,(max(corner2.z,(max(corner3.z,corner4.z)))));
        float minVal = min(corner1.z,(min(corner2.z,(min(corner3.z,corner4.z)))));
        #ifdef __COLLISION_PLANE__
        //std::cout << maxVal << " " << minVal << std::endl;
        #endif
        return fabs(minVal-maxVal);
}
float CollisionRectangle::max(float a, float b) {
        if(a < b) {
                return b;
        } else {
                return a;
        }
}

float CollisionRectangle::min(float a, float b) {
        if(a > b) {
                return b;
        } else {
                return a;
        }
}

void CollisionRectangle::translate() {}
void CollisionRectangle::rotate() {}
void CollisionRectangle::scale() {}

---