---

RenderContext.h

/*
  File: RenderContext.h

  Copyright(C) C. Kotterink, Computed Graphics
*/
#ifndef RENDERCONTEXT_H
#define RENDERCONTEXT_H

#include<AABoundingBox.h>
#include<Color3.h>
#include<Color4.h>
#include<Matrix4.h>
#include<Quaternion.h>
#include<Vertex3.h>
#include<Vertex4.h>

#include<render.h>

class Mesh;
class Material;

class RenderContext
{
public:
    typedef enum Visibility {
        NotVisible,
        Visible,    
        PartlyVisible
    };

    RenderContext();

    void init();

    void setFill(bool fill);
    bool getFill() {
        return solidFill;
    }
    void setRenderBounds(bool render) {
        renderBounds = render;
    }
    bool getRenderBounds() {
        return renderBounds;
    }
    void setViewport(unsigned short w, unsigned short h);
    void printScreen();

    // Matrix operations
    void perspective(float fovy, float zNear, float zFar);
    void pickMatrix(real x, real y);

    // View Frustrum culling and camera coordinate system
    void extractFrustum();
    const Vertex3 &getCameraX() {
        return cameraX;
    }
    const Vertex3 &getCameraY() {
        return cameraY;
    }
    void setCameraPosition(const Vertex3 &position) {
        cameraPos = position;
    }
    const Vertex3 &getCameraPosition() {
        return cameraPos;
    }
    Vertex3 transform(const Vertex3 &v) {
      return M.applyHomogenous(v);
    }
    Vertex3 modelTransform(const Vertex3 &v) {
      return modelView*v;
    }

    bool cull(real x, real y, real z);
    Visibility cull(const Vertex3 &v, real radius);
    Visibility cull(const AABoundingBox &box) {
        return cull(box.getFrom(), box.getTo());
    }
    Visibility cull(const Vertex3 &from, const Vertex3 &to);

    // Render Geo Objects
    RenderContext &operator <<(const Color3 &c) {
        glColor3fv((float*)&c);
        return *this;
    }
    RenderContext &operator <<(const Color4 &c) {
        glColor4fv((float*)&c);
        return *this;
    }
    RenderContext &operator <<(const Vertex3 &v) {
        glVertex3fv((float*)&v);
        return *this;
    }
    RenderContext &operator <<(const Vertex4 &v) {
        glVertex4fv((float*)&v);
        return *this;
    }
    RenderContext &operator <<(const Matrix4 &m) {
        glLoadMatrixf((float*)&m);
        return *this;
    }
    RenderContext &operator <<(Quaternion &q){
        Vertex3 v;
        real angle;

        q.getRotation(v, angle);
        angle /= DEG2RAD;
        glRotatef(angle, v.x, v.y, v.z);
        return *this;
    }
    RenderContext &normal(Vertex3 &v) {
        glNormal3fv((float*)&v);
        return *this;
    }
    RenderContext &operator<<(const AABoundingBox &box) {
        if (renderBounds) {
            boundingBox(box);
        }
        return *this;
    }
    // Gfx Objects
    RenderContext &operator <<(Material *material);

    // Other renderings
    RenderContext &screenQuad(real x, real y, real r);
    RenderContext &texturedQuad(const Vertex3 &p, real r);
    void boundingBox(const AABoundingBox &box);

private:
    class FrustrumPlane
    {
    public:
        real distance(real x, real y, real z) {
            return a*x + b*y + c*z +d;
        }
        void setParam(real aa, real bb, real cc, real dd) {
            real norm = sqrt(aa*aa + bb*bb + cc*cc);
            a = aa/norm;
            b = bb/norm;
            c = cc/norm;
            d = dd/norm;
        }

    private:
        real a, b, c, d;
    };

    static real pickSize;
    static Material defaultMaterial;

    // Flags
    bool solidFill;
    bool renderBounds;

    // View info
    float aspect;
    Vertex3 cameraX;
    Vertex3 cameraY;
    Vertex3 cameraPos;
    Matrix4 M;          // Projection*ModelView
    Matrix4 modelView;
    FrustrumPlane frustum[6];

    // Render state
    Material *currentMaterial;
};

#endif

---

This documentation was generated using doxygen. If you have any comments or additions please mail me.