---

---

AI_SDB_Camera.h

Go to the documentation of this file.

#ifndef AI_SDB_CAMERA_H
#define AI_SDB_CAMERA_H
//------------------------------------------------------------------------------
//#include "kernel/ntypes.h"
#include "../math/AI_Matrix.h"
#include "../math/AI_BBox.h"

//------------------------------------------------------------------------------
class AI_SDB_Camera
{
public:
    enum ClipStatus 
    {
        Outside,
        Inside,
        Clipped,
    };

    enum Type
    {
        Perspective,
        Orthogonal,
    };

    AI_SDB_Camera();
    AI_SDB_Camera(float aov, float aspect, float nearp, float farp);
    void SetPerspective(float aov, float aspect, float nearp, float farp);
    void SetOrthogonal(float w, float h, float nearp, float farp);
    void SetType(Type t);
    Type GetType() const;
    void SetWidth(float w);
    float GetWidth() const;
    void SetHeight(float h);
    float GetHeight() const;
    void SetAngleOfView(float a);
    float GetAngleOfView() const;
    void SetAspectRatio(float r);
    float GetAspectRatio() const;
    void SetNearPlane(float v);
    float GetNearPlane() const;
    void SetFarPlane(float v);
    float GetFarPlane() const;
    const AI_Matrix44& GetProjection();
    const AI_Matrix44& GetInvProjection();
    const AI_BBox& GetBox();
    // get the view volume
    void GetViewVolume(float & minx, float & maxx, float & miny, float & maxy, float & minz, float & maxz) const;
    ClipStatus GetClipStatus(const AI_Matrix44& myTransform, const AI_Matrix44& otherViewProjection);

private:
    void UpdateProjInvProj();

    Type type;
    float width;
    float height;
    float angleOfView;
    float aspectRatio;
    float nearPlane;
    float farPlane;
    bool projDirty;
    bool boxDirty;
    AI_Matrix44 proj;
    AI_Matrix44 invProj;
    AI_BBox box;
};

//------------------------------------------------------------------------------
inline
AI_SDB_Camera::AI_SDB_Camera() :
    type(Perspective),
    width(0),
    height(0),
    angleOfView(ai_deg2rad(60.0f)),
    aspectRatio(4.0f / 3.0f),
    nearPlane(0.1f),
    farPlane(5000.0f),
    projDirty(true),
    boxDirty(true)
{
    // empty
}

//------------------------------------------------------------------------------
inline
AI_SDB_Camera::AI_SDB_Camera(float aov, float aspect, float nearp, float farp) :
    type(Perspective),
    width(0),
    height(0),
    angleOfView(ai_deg2rad(aov)),
    aspectRatio(aspect),
    nearPlane(nearp),
    farPlane(farp),
    projDirty(true),
    boxDirty(true)
{
    // empty
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetPerspective(float aov, float aspect, float nearp, float farp)
{
    this->type = Perspective;
    this->angleOfView = ai_deg2rad(aov);
    this->aspectRatio = aspect;
    this->nearPlane = nearp;
    this->farPlane = farp;
    this->projDirty = true;
    this->boxDirty = true;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetOrthogonal(float w, float h, float nearp, float farp)
{
    this->type = Orthogonal;
    this->width = w;
    this->height = h;
    this->nearPlane = nearp;
    this->farPlane = farp;
    this->projDirty = true;
    this->boxDirty = true;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetType(Type t)
{
    this->type = t;
    this->projDirty = true;
    this->boxDirty  = true;
}

//------------------------------------------------------------------------------
inline
AI_SDB_Camera::Type
AI_SDB_Camera::GetType() const
{
    return this->type;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetWidth(float w)
{
    this->width = w;
    this->projDirty = true;
    this->boxDirty  = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetWidth() const
{
    return this->width;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetHeight(float h)
{
    this->height = h;
    this->projDirty = true;
    this->boxDirty  = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetHeight() const
{
    return this->height;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetAngleOfView(float a)
{
    this->angleOfView = ai_deg2rad(a);
    this->projDirty = true;
    this->boxDirty  = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetAngleOfView() const
{
    return ai_rad2deg(this->angleOfView);
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetAspectRatio(float r)
{
    this->aspectRatio = r;
    this->projDirty = true;
    this->boxDirty = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetAspectRatio() const
{
    return this->aspectRatio;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetNearPlane(float v)
{
    this->nearPlane = v;
    this->projDirty = true;
    this->boxDirty = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetNearPlane() const
{
    return this->nearPlane;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::SetFarPlane(float v)
{
    this->farPlane = v;
    this->projDirty = true;
    this->boxDirty = true;
}

//------------------------------------------------------------------------------
inline
float
AI_SDB_Camera::GetFarPlane() const
{
    return this->farPlane;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::GetViewVolume(float & minx, float & maxx, float & miny, float & maxy, float & minz, float & maxz) const
{
    maxy = this->nearPlane * ai_tan(this->angleOfView * 0.5f);
    miny = -maxy;
    maxx = this->aspectRatio * maxy;
    minx = -maxx;
    minz = this->nearPlane;
    maxz = this->farPlane;
}

//------------------------------------------------------------------------------
inline
void
AI_SDB_Camera::UpdateProjInvProj()
{
    ai_assert(this->projDirty);
    this->projDirty = false;
    if (Perspective == this->type)
    {
        this->proj.perspFovRh(this->angleOfView, this->aspectRatio, this->nearPlane, this->farPlane);
    }
    else
    {
        this->proj.orthoRh(this->width, this->height, this->nearPlane, this->farPlane);
    }
    this->invProj = proj;
    this->invProj.invert();
}

//------------------------------------------------------------------------------
inline
const AI_Matrix44&
AI_SDB_Camera::GetProjection()
{
    if (this->projDirty)
    {
        this->UpdateProjInvProj();
    }
    return this->proj;
}

//------------------------------------------------------------------------------
inline
const AI_Matrix44&
AI_SDB_Camera::GetInvProjection()
{
    if (this->projDirty)
    {
        this->UpdateProjInvProj();
    }
    return this->invProj;
}

//------------------------------------------------------------------------------
inline
AI_SDB_Camera::ClipStatus 
AI_SDB_Camera::GetClipStatus(const AI_Matrix44& myTransform, const AI_Matrix44& otherViewProjection)
{
    // compute matrix which transforms my local hull into
    // projection space of the other camera
    AI_Matrix44 invProjModelViewProj = this->GetInvProjection() * myTransform * otherViewProjection;

    // compute clip code of hull
    int andFlags = 0xffff;
    int orFlags  = 0;
    int i;
    AI_Vector4 v0(0.0f, 0.0f, 0.0f, 1.0f);
    AI_Vector4 v1;
    for (i = 0; i < 8; i++)
    {
        if (i & 1) v0.x = -1.0f;
        else       v0.x = +1.0f;
        if (i & 2) v0.y = -1.0f;
        else       v0.y = +1.0f;
        if (i & 3) v0.z = 0.0f;
        else       v0.z = +1.0f;

        v1 = invProjModelViewProj * v0;
        int clip = 0;
        if (v1.x < -v1.w)       clip |= (1<<0);
        else if (v1.x > v1.w)   clip |= (1<<1);
        if (v1.y < -v1.w)       clip |= (1<<2);
        else if (v1.y > v1.w)   clip |= (1<<3);
        if (v1.z < -v1.w)       clip |= (1<<4);
        else if (v1.z > v1.w)   clip |= (1<<5);
        andFlags &= clip;
        orFlags  |= clip;
    }
    if (0 == orFlags)       return Inside;
    else if (0 != andFlags) return Outside;
    else                    return Clipped;
}

//------------------------------------------------------------------------------
inline
const AI_BBox&
AI_SDB_Camera::GetBox()
{
    if (this->boxDirty)
    {
        this->boxDirty = false;
        if (Perspective == this->type)
        {
            float tanAov = float(tan(this->angleOfView * 0.5f));
            this->box.vmin.z = this->nearPlane;
            this->box.vmax.z = this->farPlane;
            this->box.vmax.y = tanAov * this->farPlane;     // ??? -> tanAov * (this->farPlane - this->nearPlane);
            this->box.vmin.y = -this->box.vmax.y;
            this->box.vmax.x = this->box.vmax.y * this->aspectRatio;
            this->box.vmin.x = -this->box.vmax.x;
        }
        else
        {
            this->box.vmin.x = -this->width * 0.5f;
            this->box.vmin.y = -this->height * 0.5f;
            this->box.vmin.z = -1000000.0f;
            this->box.vmax.x = this->width * 0.5f;
            this->box.vmax.y = this->height * 0.5f;
            this->box.vmax.z = 1000000.0f;
        }
    }
    return this->box;
}

//------------------------------------------------------------------------------
#endif

---

InExIn pages are hosted by
InExIn documentation generated by doxygen at Tue Dec 18 12:55:27 2007