src/PerspectiveCamera.h

Go to the documentation of this file.

#ifndef PERSPECTIVECAMERA_H
#define PERSPECTIVECAMERA_H


#include <cmath>

#include "Camera.h"


class PerspectiveCamera : public Camera
{
public:
    PerspectiveCamera(  Vec3f   pos,
                        Vec3f   dir,
                        Vec3f   up,
                        float   angle,
                        int     resX,
                        int     resY )
        : Camera(pos, resX, resY),
            mDir(dir),
            mUp(up),
            mAngle(angle * M_PI / 180.0f),
            mFocus(0.0f),
            mAspect(),
            mXAxis(),
            mYAxis()
    {
        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(resX) / resY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    virtual ~PerspectiveCamera()
    {}

    virtual Ray initRay(float x, float y)
    {
        Vec3f rdir  = (2.0f * ((x / mResX - .5f) * mAspect) * mXAxis)
                        + (2.0f * (y / mResY - .5f) * mYAxis)
                        + (mFocus * mDir);
        Ray ray;
        ray.init(mPos, rdir);
        return ray;
    }

    void setPos(Vec3f pos)
    {
        mPos = pos;
    }

    void setDir(Vec3f dir)
    {
        mDir = dir;

        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(mResX) / mResY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    void setUp(Vec3f up)
    {
        mUp = up;

        mDir.normalize();
        mUp.normalize();

        mXAxis = mDir.cross(mUp).normal();
        mYAxis = mXAxis.cross(mDir).normal();

        mAspect = static_cast<float>(mResX) / mResY;
        mFocus = 1.f / tanf(mAngle / 2.0f);
    }

    virtual const Vec3f & dir() const
    {
        return mDir;
    }

    const Vec3f & up() const
    {
        return mUp;
    }

    float angle() const
    {
        return mAngle / M_PI * 180.0f;
    }

    float aspect() const
    {
        return mAspect;
    }

    int depthSamples() const
    {
        return 1;
    }

    virtual const float focusDistance() const
    {
        return 1.0f;
    }

    virtual const float aperture() const
    {
        return 0.04;
    }

    void setDepthSamples(unsigned int) { };

    void setFocusDistance(float) { };

    void setAperture(float) { };


    void setSlowCorrect() { }

    void setFastIncorrect() { }

private:
    Vec3f   mDir;

    Vec3f   mUp;

    float   mAngle;

    float   mFocus;

    float   mAspect;

    Vec3f   mXAxis;

    Vec3f   mYAxis;
};

#endif

---