Object.h

Go to the documentation of this file.

#ifndef OBJECT_H
#define OBJECT_H OBJECT_H

#include "TexturedSmoothTriangle.h"
#include "SmoothTriangle.h"
#include "KDTree.h"
#include "Shader.h"

class Object
{
    std::vector<Primitive *> primitive; 
public:
    
    void Add(Primitive *prim)
    {
        primitive.push_back(prim);
    };
private:
    
    KDTree* kdTree;
    
    bool m_useAcc;
    
    Box boundingBox;
    
    ColorRGBA color;
    
    bool m_castShadows;
    
    bool _visible;

public:

    Vector3D center;

    class PrimitiveFactory
    {
    public:
        virtual ~PrimitiveFactory(){}
        virtual Primitive* Create(Vector3D va, Vector3D vb, Vector3D vc, Vector3D na, Vector3D nb, Vector3D nc, PAIR ta, PAIR tb, PAIR tc) const = 0;
    };

    class TriangleFactory : public PrimitiveFactory
    {
        Primitive* Create(Vector3D va, Vector3D vb, Vector3D vc, Vector3D na, Vector3D nb, Vector3D nc, PAIR ta, PAIR tb, PAIR tc) const
        {
            return new Triangle(va, vb, vc);
        }
    };

    class SmoothTriangleFactory : public PrimitiveFactory
    {
        Primitive* Create(Vector3D va, Vector3D vb, Vector3D vc, Vector3D na, Vector3D nb, Vector3D nc, PAIR ta, PAIR tb, PAIR tc) const
        {
            return new SmoothTriangle(va, vb, vc, na, nb, nc);
        }
    };

    class TexturedSmoothTriangleFactory : public PrimitiveFactory
    {
        Primitive* Create(Vector3D va, Vector3D vb, Vector3D vc, Vector3D na, Vector3D nb, Vector3D nc, PAIR ta, PAIR tb, PAIR tc) const
        {
            return new TexturedSmoothTriangle(va, vb, vc, na, nb, nc, ta, tb, tc);
        }
    };

    Object(bool useAcc)
    {
        m_useAcc = useAcc;
        color = Vector3D(0,0,1);
        kdTree = NULL;
        m_castShadows = true;
        center = Vector3D(0.0,0.0,0.0);
        _visible = true;
    };

    ~Object() 
    {
        // cleanup primitives
        for (unsigned int i=0;i<primitive.size();i++)
            delete primitive[i];
                
        // delete tree
        if (kdTree) delete kdTree;
    };

    void setVisible(bool val) { _visible = val; }

    const ColorRGBA& getColor() const { return color; }

    void setColor(const ColorRGBA& v) { color = v; }

    void setShader(Shader* sh) 
    {
        for (unsigned int i=0;i<primitive.size();i++)
            primitive[i]->setShader(sh);
    }

    void ParseOBJ(char *fileName, const PrimitiveFactory& factory = TriangleFactory() );

    bool Intersect(Ray &ray)
    {
        if (_visible) 
        {
            if(m_useAcc)
            {
                return kdTree->Intersect(ray);
            }
            else
            {
                bool hit = false;

                for (unsigned int i=0;i<primitive.size();i++)
                    hit |= primitive[i]->Intersect(ray);
                return hit;
            }
            return false;
        }
        else 
            return false;
    };

    bool Occluded(Ray &ray)
    {
        if (_visible) 
        {
            if(m_useAcc)
            {
                return kdTree->Intersect(ray);
            }
            else
            {
                for (unsigned int i=0;i<primitive.size();i++)
                    if (primitive[i]->Occluded(ray))
                        return true;

                return false;
            }
            return false;
        }
        else 
            return false;
    };

    Box CalcBounds()
    {
        boundingBox.Clear();

        for (int i=0;i<(int)primitive.size();i++) 
        {
            Box box = primitive[i]->GetBounds();
            boundingBox.Extend(box);
        }
        center = boundingBox.min;
        return boundingBox;
    }

    void BuildAccelStructure()
    {
        if (!m_useAcc) return;

        // compute the bounding box
        boundingBox = CalcBounds();

        // recreate the tree if already created
        if (kdTree) delete kdTree;
        kdTree = new KDTree();

        // build acceleration data structure
        kdTree->BuildTree(primitive, boundingBox);
    }

    inline bool isCastShadows() const { return m_castShadows; }
    
    inline void setCastShadows(bool b)
    {
        // this object's cast shadow flag
        m_castShadows = b;

        // set to each primitive 
        for (int i=0;i<(int)primitive.size();i++) 
        {
            primitive[i]->castShadows() = b;
        }
    }

};

#endif

---