transparenttransformatable.h

/* *************************************************************************
                          transparenttransformatable.h  -  description
                             -------------------
    begin                : Fri Jan 17 2003
    copyright            : (C) 2003 by Micha Riser
    email                : mriser@gmx.net
    
    $Id: transparenttransformatable_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 TRANSPARENTTRANSFORMATABLE_H
#define TRANSPARENTTRANSFORMATABLE_H

#include "transformatable.h"
#include "matrix.h"
#include "ray.h"

class TransparentTransformatable: public Transformatable  {
    
public: // Constructors and destructor

    TransparentTransformatable():
      translation(0),transformation(0),inverse(0) {}

    TransparentTransformatable(const Vector3& loc):
      translation(loc),transformation(0),inverse(0) {}

    TransparentTransformatable(const TransparentTransformatable &t): 
      Transformatable(t), translation(t.translation), transformation(0), inverse(0) {
          
        if (t.transformation) {
            transformation = new Matrix(*t.transformation);
            inverse = new Matrix(*t.inverse);
        } 

    }
    
    virtual ~TransparentTransformatable() {
        delete(transformation);
        delete(inverse);
    }

private:
    TransparentTransformatable& operator=(const TransparentTransformatable);

public: // Methods that implement Transformatable

    virtual void translate(const Vector3& v) {translation.add(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);

public: // Additional transformation methods

    virtual void transform(const TransparentTransformatable& t);

    virtual void transformInverse(const TransparentTransformatable& t);
    
public: // Methods to do space transformations    

    void transformPointIn(Vector3 &p) const {
        // p' = T*(p-t)
        p.sub(translation);
        if (transformation) p.applyFromLeft(*transformation);
    }

    void transformPointOut(Vector3 &p) const {
        // p = T*p'+t  /* *check me* for correctness */
        if (transformation) p.applyFromLeft(*inverse);
        p.add(translation);
    }

//    void transformNormalIn(Vector3 &p) const;

    void transformNormalOut(Vector3 &p) const {
        if (transformation) p.applyFromLeftTransposed(*transformation);
    }

    void transformRayIn(Ray &r) const {
        r.origin.sub(translation);
        if (transformation) {
            r.origin.applyFromLeft(*transformation);
            r.direction.applyFromLeft(*transformation);
        }
    }


public: // Functions that give read access to transformations    
    Vector3 getTranslation() const {return translation;}

    const Matrix* getTransformationMatrix() const {return transformation;}

    const Matrix* getInverseMatrix() const {return inverse;}
    
protected: // Functions that give write access to transformations
    void clearTransformation() {
        delete(transformation);
        delete(inverse);
        transformation = 0;
        inverse = 0;
        translation = Vector3(0);
    }

    void setTranslation(const Vector3& v) {
        translation = v;
    }
    
private: // Protected attributes

    Vector3 translation;

    Matrix* transformation;

    Matrix* inverse;

};

#endif

---