FrameBufferGL.cc

Go to the documentation of this file.

#include <gra/framebuffer/FrameBufferGL.h>
#include <gra/camera/CameraGL.h>

using namespace gra;

void FrameBufferGL::setWidth(unsigned w) 
{
    FrameBuffer::setWidth(w);
    GLint val[4];
    glGetIntegerv(GL_VIEWPORT, val);
    glViewport(val[0], val[1], w, val[3]);
}

void FrameBufferGL::setHeight(unsigned h)
{
    FrameBuffer::setHeight(h);
    GLint val[4];
    glGetIntegerv(GL_VIEWPORT, val);
    glViewport(val[0], val[1], val[2], h);
}

void FrameBufferGL::setColor(const Camera&  camera,
                             unsigned       x,
                             unsigned       y,
                             float          depth,
                             const Color3f& color)
{
    //cerr << "Setting pixel (" << x << "," << y << "," << depth << "):\t";
    //cerr << color.x << " " << color.y << " " << color.z << endl;

    GLint     v[4];
    GLboolean validRP;
    GLfloat   c[3] = { color.x, color.y, color.z };

    /*
     * Compute position of pixel on the camera's projection plane with
     * respect to projection plane size and position.
     */
    const Projection& proj = camera.getProjection();
    float newX =
        (float)(x+1) / (float)_width * proj.getPlaneWidth() +
        proj.getLeftPlane();
    float newY =
        (float)(y+1) / (float)_height * proj.getPlaneHeight() +
        proj.getBottomPlane();

    glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &validRP);
    if (validRP) glGetIntegerv(GL_CURRENT_RASTER_POSITION, v);

    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glRasterPos3f(newX, newY, depth);
    glDrawPixels(1, 1, GL_RGB, GL_FLOAT, (void*) c);
    if (validRP) glRasterPos4iv(v);
    glPopMatrix();
}

void FrameBufferGL::setColor(const Camera&  camera,
                             unsigned       x,
                             unsigned       y,
                             const Color3f& color)
{
    //cerr << "Setting pixel (" << x << "," << y << "):\t";
    //cerr << color.x << " " << color.y << " " << color.z << endl;

    GLint     v[4];
    GLboolean validRP;
    GLfloat   c[3] = { color.x, color.y, color.z };

    /*
     * Compute position of pixel on the camera's projection plane with
     * respect to projection plane size and position.
     */
    const Projection& proj = camera.getProjection();
    float newX =
        (float)(x+1) / (float)_width * proj.getPlaneWidth() +
        proj.getLeftPlane();
    float newY =
        (float)(y+1) / (float)_height * proj.getPlaneHeight() +
        proj.getBottomPlane();

    /*
     * Ensure that the OpenGL projection matrix is set, store OpenGL state
     */
    glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &validRP);
    if (validRP) glGetIntegerv(GL_CURRENT_RASTER_POSITION, v);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    CameraGL cgl(camera);

    /*
     * OpenGL camera could change transformation
     */
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    /*
     * Set pixel color
     */
    glRasterPos2f(newX, newY);
    glDrawPixels(1, 1, GL_RGB, GL_FLOAT, (void*) c);

    /*
     * Restore OpenGL state
     */
    if (validRP) glRasterPos4iv(v);
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
}

void FrameBufferGL::setColors(const Camera& camera,
                              unsigned      x,
                              unsigned      y,
                              float         depth,
                              const Color3f colors[],
                              unsigned      size)
{
    fprintf(stderr,"FrameBufferGL::setColors(): To do");
    // to do
}

void FrameBufferGL::setColors(const Camera& camera,
                              unsigned      x,
                              unsigned      y,
                              const Color3f colors[],
                              unsigned      size)
{
    GLint     v[4];
    GLboolean validRP;
    GLfloat * c = new GLfloat [3 * size];

    for (unsigned i = 0; i < size; i++) {
        c[3 * i + 0] = colors[i].x;
        c[3 * i + 1] = colors[i].y;
        c[3 * i + 2] = colors[i].z;
        //fprintf(stderr,"%f %f %f\n",colors[i].x,colors[i].y,colors[i].z);
    }

    /*
     * Ensure that the OpenGL projection matrix is set, store OpenGL state
     */
    glGetBooleanv(GL_CURRENT_RASTER_POSITION_VALID, &validRP);
    if (validRP) glGetIntegerv(GL_CURRENT_RASTER_POSITION, v);
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    CameraGL cgl(camera);

    /*
     * OpenGL camera could change transformation
     */
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();

    glPixelZoom(1, -1);

    const Projection& proj = camera.getProjection();
    float xpos, ypos;
    unsigned firstSegment = _width - x;
    unsigned block = 0;
    unsigned lastSegment = 0;

    if (firstSegment == _width)
        firstSegment = 0;
    if (firstSegment > size)
        firstSegment = size;
    else {
        block = (unsigned) ((size - firstSegment) / _width);
        lastSegment = size - firstSegment - block * _width;
    }
    
    //cerr << firstSegment << "," << block << "," << lastSegment << endl;

    Vector2f ps = camera.getPixelSize(_width, _height);
    ps.scale(.5);

    /*
     * write first line segment
     */
    if (firstSegment) {
        xpos =
            (float)(x+1) / (float)_width * proj.getPlaneWidth() +
            proj.getLeftPlane();
        ypos =
            (float)(y+1) / (float)_height * proj.getPlaneHeight() +
            proj.getBottomPlane();

        glRasterPos3f(xpos, ypos, proj.getNearPlane());
        glDrawPixels(firstSegment, 1, GL_RGB, GL_FLOAT, c);
    }

    /*
     * write block of entire lines
     */
    if (block) {
        xpos =
            proj.getPlaneWidth() / (float)_width +
            proj.getLeftPlane();
        ypos =
            (float)(y) / (float)_height * proj.getPlaneHeight() +
            proj.getBottomPlane();

        glRasterPos3f(xpos, ypos, proj.getNearPlane());
        glDrawPixels(_width+1, block, GL_RGB, GL_FLOAT, c + 3 * firstSegment);
    }

    /*
     * write last line segment
     */
    if (lastSegment) {
        xpos =
            (float)(1.0) / (float)_width * proj.getPlaneWidth() +
            proj.getLeftPlane();
        ypos =
            (float)(y - block - ((firstSegment) ? 2 : 1)) / (float)_height * proj.getPlaneHeight() +
            proj.getBottomPlane();
        
        glRasterPos3f(xpos, ypos, proj.getNearPlane());
        glDrawPixels(lastSegment, 1, GL_RGB, GL_FLOAT, c + 3 * firstSegment + 3 * _width * block);
    }
    
    /*
     * Restore OpenGL state
     */
    if (validRP) glRasterPos4iv(v);
    glPopMatrix();
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glPixelZoom(1, 1);

    delete [] c;
}

Color3f FrameBufferGL::getColor(unsigned x, unsigned y) const
{
    /*
     * We need either the camera that made the snapshot (see setColor()),
     * or to remember stored colors separately, which is memory consuming.
     */
    cerr << "FrameBufferGL::getColor(): unimplemented" << endl;
    return Color3f();
}

void FrameBufferGL::clearColor(const Color3f& color)
{
    glClearColor(color.x, color.y, color.z, 1.0);
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}


#if 0
int FrameBufferGL::init()
{
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0, getWidth(), 0, getHeight(), -1, 1);

    glDisable(GL_LIGHTING);

    glMatrixMode(GL_MODELVIEW);

    return 1;
}

#endif // 0

---