object3d.h

/* *************************************************************************
                          object3d.h  -  description
                             -------------------
    begin                : Wed Oct 16 2002    
    copyright            : (C) 2002 by Micha Riser
    email                : mriser@gmx.net

    $Id: object3d_8h-source.html,v 1.1 2005/02/04 21:02:27 micha Exp $
    
 ************************************************************************* */

/* *************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ************************************************************************* */

#ifndef OBJECT3D_H
#define OBJECT3D_H

#include "transparenttransformatable.h"
#include "surfacepatch3d.h"
#include "boundingbox.h"
#include "objectconstructionerror.h"

class PatchObject;
class InsideList;

class Material3D;
class Texture3D;
class Pigment3D;
class Finish;
class Interior;
class Media3D;

class Object3D: public SurfacePatch3D, public TransparentTransformatable {

public: // Public attributes
    Material3D* material;

public: // Constructors and destructor

    Object3D(): material(0), boundingbox(0), inverse(false) {};

    Object3D(Vector3 location): TransparentTransformatable(location),
      material(0), boundingbox(0), inverse(false) {};

    virtual ~Object3D();
    
protected:
    Object3D(const Object3D &o);

private:
    Object3D& operator=(const Object3D&);
    
public: // Public methods

    // Methods used during pre-rendering stage

    // overwrite the transformation in TransparentTranformatable to get the
    // boundingbox transformed as well
    virtual void translate(const Vector3& v);
    virtual void scale(const Vector3& v);
    virtual void rotateDeg(const Vector3& v);
    virtual void rotateRad(const Vector3& v);
    virtual void applyOrthogonalMatrix(const Matrix& m);
    virtual void applyMatrix(const Matrix& m);        
        
    virtual void transform(const TransparentTransformatable& t);
    virtual void transformInverse(const TransparentTransformatable& t);

    // to implement SurfacePatch3D:

    virtual bool hasFinitBounding() const {return boundingbox != 0;}

    virtual Vector3 getBoundingMin() const {
        if (boundingbox == 0) throw ObjectConstructionError("Object3D::getBoundingMin(): no bounding");
        return boundingbox->getBoxMin();
    }

    virtual Vector3 getBoundingMax() const {
        if (boundingbox == 0) throw ObjectConstructionError("Object3D::getBoundingMin(): no bounding");
        return boundingbox->getBoxMax();
    }

    virtual DBL intersectBounding(const Ray &r) const;
    virtual DBL intersectBounding(const Ray &r, DBL tmax) const;
    
    virtual Intersection* intersect(const Ray &r) const {
        Ray local = r;
        transformRayIn(local);
        return intersectLocal(local);
    }
    
    virtual Intersection* intersectLimitedTime(const Ray &r, DBL maxtime) const {
        Ray local = r;
        transformRayIn(local);
        return intersectLocalLimitedTime(local,maxtime);
    }


    // methods to set Object3D's material and sub-components

    void setMaterial(const Material3D &m);

    void setTexture(const Texture3D &t);

    void setPigment(const Pigment3D &p);

    void setFinish(const Finish &f);

    void setInterior(const Interior &i);

    void setMedia(const Media3D &m);

    virtual Object3D* invert() const {  
        Object3D* inv = static_cast<Object3D*>(duplicate());
        if (inverse) inv->inverse=false; else inv->inverse=true;
        return inv;
    }

    virtual PatchObject* toPatch(double precision) const {return 0;}
    
    virtual void listInside(const Vector3& location, InsideList& l) const;

    bool isInsideAtBounded(Vector3 location) const {
        if (boundingbox && !boundingbox->isInsideAt(location)) return inverse;        
        transformPointIn(location);
        return isInsideAt(location);
    }

    bool isInverse() const {return inverse;}

protected:
    // virtual methods for local object intersection
    virtual Intersection* intersectLocal(const Ray& r) const {
        return intersectLocalLimitedTime(r,INTERSECTION_INFINIT_TIME);
    }

    virtual Intersection* intersectLocalLimitedTime(const Ray& r, DBL maxtime) const = 0;


    virtual bool isInsideAt(const Vector3 &locallocation) const = 0;    

    
protected: // Protected attributes
    BoundingBox* boundingbox;

    bool inverse;
    
};

#endif

---