source: GTP/trunk/App/Games/Jungle_Rumble/src/Quad.cpp @ 1378

#include "dxstdafx.h"
#include ".\quad.h"
#include "Camera.h"
#include "Plane.h"

Quad::Quad(void)
{
        this->width = 0;
        this->height = 0;
        this->level = -1;
        for(int i=0;i<4;i++) {
                q[i] = 0;
        }
        this->fullyVisible = false;
        this->partlyVisible = false;
}

Quad::~Quad(void)
{
        this->deleteQuadTree();
}

void Quad::setPosition(float _x, float _z) {
        this->position.x = _x;
        this->position.y = 0;
        this->position.z = _z;

        //BBox berechnen
        this->minBBox.x = this->position.x - this->width/2;
        this->minBBox.y = 0;
        this->minBBox.z = this->position.z - this->height/2;

        this->maxBBox.x = this->position.x + this->width/2;
        this->maxBBox.y = 0;
        this->maxBBox.z = this->position.z + this->height/2;
}

void Quad::setDimension(float _width, float _height) {
        this->width = _width;
        this->height = _height;

        //BBox berechnen
        this->minBBox.x = this->position.x - this->width/2;
        this->minBBox.y = 0;
        this->minBBox.z = this->position.z - this->height/2;

        this->maxBBox.x = this->position.x + this->width/2;
        this->maxBBox.y = 0;
        this->maxBBox.z = this->position.z + this->height/2;
}

void Quad::buildQuadTree(int _level) {
        this->level = _level-1;
        float tx = 0;
        float tz = 0;
        for(int i=0;i<4;i++) {
                q[i] = new Quad();
                q[i]->setDimension(this->width/2, this->height/2);
                //Positionieren
                switch(i) {
                        case 0: 
                                tx = this->position.x - this->width/4;
                tz = this->position.z - this->height/4;                         
                                break;
                        case 1:
                                tx = this->position.x + this->width/4;
                tz = this->position.z - this->height/4; 
                                break;
                        case 2:
                                tx = this->position.x - this->width/4;
                tz = this->position.z + this->height/4; 
                                break;
                        case 3:
                                tx = this->position.x + this->width/4;
                tz = this->position.z + this->height/4; 
                                break;
                }
                q[i]->setPosition(tx, tz);
                if(this->level>0) {
                        q[i]->buildQuadTree(this->level);
                }
        }       
}

void Quad::clipQuadAgainstCamera(Plane *view)//, std::list<Quad *> &visibleQuadList) {
{
        this->fullyVisible = false;
        this->partlyVisible = false;
        switch(getClipType(view)) {
                case 0: //The Quad is in the Cameras ViewFrustum
                        this->fullyVisible = true;
                        //visibleQuadList.push_back(this);
                        break;
                case 1: //The Quad is outside the Cameras ViewFrustum
                        break;
                default: //The Quad is not fully in Cameras ViewFrustum (go down one level)
                        if(this->level>0) {
                                this->partlyVisible = true;
                                for(int i=0;i<4;i++)
                                        q[i]->clipQuadAgainstCamera(view);//, visibleQuadList);
                        } else {
                                //Level 0 Quad which is partly visible -> quad is visible
                                this->fullyVisible = true;
                                //visibleQuadList.push_back(this);
                        }
                        break;
        }
}

bool Quad::nodeInside(Node* node)
{
        if(!this->fullyVisible && !this->partlyVisible) {
                return false;
        }
        if(this->fullyVisible) {
                Vector *minNode;
                Vector *maxNode;

                minNode = &node->absMinAABBox;
                maxNode = &node->absMaxAABBox;

                if(maxNode->x < this->minBBox.x ||
                minNode->x > this->maxBBox.x ||
                maxNode->z < this->minBBox.z ||
                minNode->z > this->maxBBox.z) {
                        return false;
                } else {
                        return true;
                }
        }
        if(this->partlyVisible) {
                for(int i=0;i<4;i++) {
                        if(q[i]->nodeInside(node)) {
                                return true;
                        }
                }
                return false;
        }
        return false;
}

void Quad::deleteQuadTree() {
        if(this->level>=0) {
                for(int i=0;i<4;i++) {
                        delete this->q[i];
                }
        }
}

Vector Quad::getMinBBox() {
        return minBBox;
}

Vector Quad::getMaxBBox() {
        return maxBBox;
}

int Quad::getClipType(Plane *view) {
        bool inSide[6];
        Vector corner[4];

        corner[0] = this->maxBBox;
        corner[1].x = this->maxBBox.x; corner[1].z = this->minBBox.z;
        corner[2] = this->minBBox;
        corner[3].x = this->minBBox.x; corner[3].z = this->maxBBox.z;

        //Ueberpruefen ob alle Punkte außerhalb einer Frustumfläche der Kamera liegen -> quad is outside
        //Ueberprüfung findet fuer front, near, left und right statt da die quads die höhe 0 haben!
        bool bInFront[16];
        for(int i=0;i<16;i+=4) {
                bInFront[i+0] = view[i/4].inFront(corner[0]);
                bInFront[i+1] = view[i/4].inFront(corner[1]);
                bInFront[i+2] = view[i/4].inFront(corner[2]);
                bInFront[i+3] = view[i/4].inFront(corner[3]);
        }

        for(int i=0;i<4;i++) {
                if(bInFront[i*4+0] == false &&
                   bInFront[i*4+1] == false &&
                   bInFront[i*4+2] == false &&
                   bInFront[i*4+3] == false) {
                   //Quad is behind plane i -> quad is outside of frustum
                   return 1;
                }
        }

        //Ueberpruefen ob alle Punkte innerhalb des Frustums liegen -> quad is inside
        for(int i=0;i<4;i++) {
                if(bInFront[i*4+0] == true &&
                   bInFront[i*4+1] == true &&
                   bInFront[i*4+2] == true &&
                   bInFront[i*4+3] == true) {
                        //Quad is behind plane i -> quad is outside of frustum
                        inSide[i] = true;
                } else {
                        inSide[i] = false;
                }
        }
                 
        if(inSide[0] == true &&
           inSide[1] == true &&
           inSide[2] == true &&
           inSide[3] == true) {
                //Quad is completely inside frustum
           return 0;
        }

        //sonst Quad schneidet Frustum -> divide & conquer
        return -1;
}