src/PhysicalObject.h

Go to the documentation of this file.

#ifndef PHYSICALOBJECT_H
#define PHYSICALOBJECT_H


#include <cassert>
#include <iosfwd>

#include "Matrix.h"
#include "Ray.h"
#include "Vec3f.h"


class PhysicalObject
{
public:
    PhysicalObject(bool enablePhysics);

    virtual ~PhysicalObject();

    void resetTransform()
    {
        mTransform = mInverseTransform = Matrix();
    }

    void translate(const Vec3f & vector)
    {
        mTransform          = Matrix(vector) * mTransform;
        mInverseTransform   *= Matrix(-vector);
        if (mPhysicsOn)
            mPosition = vector;
    }

    void rotate(const float angle, const Vec3f & axis)
    {
        if (axis.length() > EPSILON)
        {
            mTransform          = Matrix(angle, axis) * mTransform;
            mInverseTransform   *= Matrix(-angle, axis);
            if (mPhysicsOn)
                mRotation = axis.normal()*angle;
        }
        else
        {
            if (mPhysicsOn)
                mRotation = Vec3f();
        }
    }

    void scale(const float x, const float y, const float z)
    {
        mTransform          = Matrix(x, y, z) * mTransform;
        mInverseTransform   *= Matrix(1.0f/x, 1.0f/y, 1.0f/z);
        if (mPhysicsOn)
            mScaling = (x + y + z) / 3.0;
    }

    void toLocalCoordinates(Ray & ray) const
    {
        ray = mInverseTransform * ray;
    }

    void toLocalCoordinates(Vec3f & vector) const
    {
        vector = mInverseTransform.transformVector(vector);
    }

    void toGlobalCoordinates(Ray & ray) const
    {
        ray = mTransform * ray;
    }

    void toGlobalCoordinates(Vec3f & vector) const
    {
        vector = mTransform.transformVector(vector);
    }

    bool applyPhysics() const
    {
        return mPhysicsOn;
    }

    float mass() const
    {
        return mMass;
    }

    void setMass(float m)
    {
        mMass = m;
    }

    const Vec3f & velocity() const
    {
        return mVelocity;
    }

    void setVelocity(const Vec3f & v)
    {
        mVelocity = v;
    }

    const Vec3f & angularVelocity() const
    {
        return mAngularVelocity;
    }

    void setAngularVelocity(const Vec3f & omega)
    {
        mAngularVelocity = omega;
    }

    const Vec3f & position() const
    {
        return mPosition;
    }

    void offset(const Vec3f off)
    {
        mPosition += off;
    }

    float time() const
    {
        return mTime;
    }

    void updateProperties(float t);

    virtual void dump() const = 0;

    virtual void writeDump(std::ostream & outs);

    virtual void readDump(std::istream & ins);

protected:
    Matrix                      mTransform;

    Matrix                      mInverseTransform;

    bool                        mPhysicsOn;

    float                       mMass;

    Vec3f                       mPosition;

    float                       mScaling;

    Vec3f                       mRotation;

    Vec3f                       mVelocity;

    Vec3f                       mAngularVelocity;

    float                       mTime;

};


#endif

---