---

GLRenderer.cc

Go to the documentation of this file.

/*
    File:       GLRenderer.cc

    Function:   OpenGL-based renderer

    Author:     Andrew Willmott

    Notes:      
*/

#include "gcl/GLRenderer.h"
#ifndef GCL_NO_GL
#include "vl/VLgl.h"


// --- Copying data from & to an image ----------------------------------------


GLRenderer::GLRenderer(Int w, Int h) : Renderer(),
        glWidth(w), glHeight(h), oldImage(0) 
{
}

Renderer &GLRenderer::GetImage(Image &image)
{
    if (image.Tag() == imgRGBATag)
    {
        image.SetSize(glWidth, glHeight);

        SetWindow();
        glReadBuffer(GL_FRONT);
        glPixelStorei(GL_PACK_ALIGNMENT, 8);

        glReadPixels(0, 0, glWidth, glHeight, GL_RGBA, GL_UNSIGNED_BYTE,
                     ((RGBAImage&) image).RGBAData());
    }
    else
        _Error("(GetImage) non-RGBA images unsupported");

    return(SELF);
}

Renderer &GLRenderer::PutImage(const Image &image, Int x, Int y)
{
    if (image.Tag() == imgRGBATag)
    {
        SetWindow();
        glDrawBuffer(GL_FRONT);
        glRasterPos2i(x, y);
        glDrawPixels(image.Width(), image.Height(), GL_RGBA,
                     GL_UNSIGNED_BYTE, ((RGBAImage&) image).RGBAData());    
    }
    else
        _Error("(PutImage) non-RGBA images unsupported");

    return(SELF);
}


// --- GLRenderer Drawing Operators -------------------------------------------

// translation from render-style to GL style...
static Int pcTable[8] = 
    { 0, GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_LINE_LOOP, GL_POLYGON, GL_TRIANGLES, GL_TRIANGLE_STRIP };

Void GLRenderer::Show()
{
    SetWindow();
    glFlush();
}

Renderer &GLRenderer::SetPoint(const Point &p)
{
    glVertex(p);    
    
    return(SELF);
}

Renderer &GLRenderer::SetNormal(const Vector &n)
{
    glNormal(n);    
    
    return(SELF);
}

Renderer &GLRenderer::SetCoord(const Coord &c)
{
    glVertex(c);    
    
    return(SELF);
}

Renderer &GLRenderer::SetTexCoord(const Coord &c)
{
    glTexCoord(c);  
    
    return(SELF);
}

Renderer &GLRenderer::SetColour(const Colour &c)
{
    glColor(c); 
    
    return(SELF);
}

Renderer &GLRenderer::SetColour(const Colour4 &c)
{
    glColor(c); 
    
    return(SELF);
}

Renderer &GLRenderer::SetTransform(const Transform &t)
{
    glMultMatrix(t);

    return(SELF);
}

Renderer &GLRenderer::SetCamera(const Camera &c)
{
    GLint       mm;
    Int         i;

    SetWindow();

    glGetIntegerv(GL_MATRIX_MODE, &mm);     // save the current matrix mode

    glMatrixMode(GL_PROJECTION);            // set the projection matrix
    glLoadMatrix(c.ProjMatrix());       
    glMatrixMode(GL_MODELVIEW);             // clear the model matrix
    glLoadMatrix(c.ModelMatrix());      

    glMatrixMode((GLenum) mm);              // restore matrix mode
    
    return(SELF);
}

Renderer &GLRenderer::SetTexture(const Image *image)
{
    SetWindow();

    if (image == oldImage) return(SELF);
    
    if (!image)
    {
        glDisable(GL_TEXTURE_2D);
        oldImage = 0;
        return(SELF);
    }
    
    if (image->Tag() == imgRGBATag)
    {
        glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
        glTexImage2D(GL_TEXTURE_2D, 0, 3, image->Width(), image->Height(), 0,
                     GL_RGBA, GL_UNSIGNED_BYTE,
                     ((RGBAImage*) image)->RGBAData());
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
//      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
//      glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        glEnable(GL_TEXTURE_2D);
        oldImage = image;
    }
    else
        _Error("non-rgba images unsupported");
    
    return(SELF);
}

Renderer &GLRenderer::Pop()
{
    glPopMatrix();
    
    return(SELF);
}

Renderer &GLRenderer::Push()
{
    glPushMatrix();
    
    return(SELF);
}

Renderer &GLRenderer::Clear()
{
    SetWindow();
    glClearDepth(1);
    glClearColor(bgColour[0], bgColour[1], bgColour[2], 1.0);
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    
    return(SELF);
}

Renderer &GLRenderer::Begin(RenderStyle style)
{
    glBegin((GLenum) pcTable[style]);
    return(SELF);
}

Renderer &GLRenderer::End()
{
    glEnd();
    return(SELF);
}

Void GLRenderer::Print(ostream &s)
//  Output state of the Renderer. Largely for debugging.
{
    Double  m[16];
    Int     i;
    
    SetWindow();
    
    glGetDoublev(GL_PROJECTION_MATRIX, m);
    
    s << "projection transform: " << endl;
    
    for (i = 0; i < 4; i++)
        s << "[ " << m[i] << " " << m[i+ 4] << " " << m[i + 8] << " " 
            << m[i + 12] << " ]" << endl;
    s << endl;

    glGetDoublev(GL_MODELVIEW_MATRIX, m);
    
    s << "model transform: " << endl;
    
    for (i = 0; i < 4; i++)
        s << "[ " << m[i] << " " << m[i+ 4] << " " << m[i + 8] << " " 
            << m[i + 12] << " ]" << endl;
    s << endl;
}

Void GLRenderer::Init()
{
    // call from attach() routine...
    glMatrixMode(GL_MODELVIEW);
    glEnable(GL_DEPTH_TEST);
    glCullFace(GL_BACK);
    glEnable(GL_CULL_FACE);
    glEnable(GL_NORMALIZE);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

static GLfloat light0Position[] = { 0.0, 0.0, 1.0, 0.0 };
static GLfloat matAmbient[] = { 0.0, 0.0, 0.0, 1.0 };
static GLfloat matDiffuse[] = { 0.7, 0.7, 0.7, 1.0 };
static GLfloat matSpecular[] = { 0.03, 0.03, 0.03, 1.0 };
static GLfloat matShininess[] = { 100.0 };

Void GLRenderer::SetDoubleSided(Bool on)
{
    if (!on)
        glEnable(GL_CULL_FACE);
    else
        glDisable(GL_CULL_FACE);
}

Void GLRenderer::SetHeadlight(Bool on)
{
    SetWindow();

    if (on)
    {
        glMatrixMode(GL_MODELVIEW);
        glPushMatrix();
        glLoadIdentity();
        glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, 1);
        glEnable(GL_AUTO_NORMAL);
        glEnable(GL_LIGHT0);
        glEnable(GL_LIGHTING);
        glEnable(GL_COLOR_MATERIAL);
        glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
        glLightfv(GL_LIGHT0, GL_POSITION, light0Position);

        glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT, matAmbient);
        glMaterialfv(GL_FRONT_AND_BACK, GL_DIFFUSE, matDiffuse);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SPECULAR, matSpecular);
        glMaterialfv(GL_FRONT_AND_BACK, GL_SHININESS, matShininess);
        glPopMatrix();
    }
    else
    {
        glDisable(GL_LIGHTING);
        glDisable(GL_COLOR_MATERIAL);
    }       
}

#endif

---