framebuffer.cpp

Go to the documentation of this file.

/*
    toxic - A Global Illumination Renderer
    Copyright (C) 2003-2004 Francois Beaune
    Contact: http://toxicengine.sourceforge.net/

    This file is part of toxic.

    toxic is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    toxic is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with toxic; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#include "framebuffer.h"    // include first

#include <cmath>    // std::powf()
#include <IL/il.h>
#include <IL/ilu.h>
#include <limits>

using namespace sheep;
using namespace std;
using namespace toxic;

Framebuffer::Framebuffer(int width, int height, Format format) :
    m_width(width), m_height(height),
    m_pixels(width * height),
    m_format(format)
{
    assert(m_width > 0);
    assert(m_height > 0);
    assert(m_pixels > 0);

    switch(m_format) {
    case RGB_FLOAT_32:
        m_bits.m_rgb_float_32 = new pixel_rgb_float_32[m_pixels];
        assert(m_bits.m_rgb_float_32);  //!\todo Throw an exception if memory allocation failed.
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }

    m_inv_width = 1.0 / m_width;
    m_inv_height = 1.0 / m_height;
    m_half_inv_width = 1.0 / (2.0 * m_width);
    m_half_inv_height = 1.0 / (2.0 * m_height);
}

Framebuffer::~Framebuffer() {
    switch(m_format) {
    case RGB_FLOAT_32:
        delete [] m_bits.m_rgb_float_32;
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }
}

int Framebuffer::GetSizeInMemory() const {
    switch(m_format) {
    case RGB_FLOAT_32:
        return
            sizeof(Framebuffer) +
            sizeof(pixel_rgb_float_32) * m_pixels;
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }

    return 0;   // keep the compiler happy
}

void Framebuffer::Clear(Color3 color /*= Color3(0.0)*/) {
    switch(m_format) {
    case RGB_FLOAT_32:
        {
            pixel_rgb_float_32 *p = m_bits.m_rgb_float_32;
            for(int i = 0; i < m_pixels; ++i, ++p) {
                p->m_r = static_cast<float32>(color.m_r);
                p->m_g = static_cast<float32>(color.m_g);
                p->m_b = static_cast<float32>(color.m_b);
            }
        }
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }
}

void Framebuffer::PlotLine(int x1, int y1, int x2, int y2, const Color3 &color) {
    const int dx = x2 - x1;
    const int ax = 2 * (dx < 0 ? -dx : dx);
    const int sx = dx < 0 ? -1 : 1;

    const int dy = y2 - y1;
    const int ay = 2 * (dy < 0 ? -dy : dy);
    const int sy = dy < 0 ? -1 : 1;

    if(ax > ay) {
        int d = ay - ax / 2;

        while(true) {
            SetPixel(x1, y1, color);

            if(x1 == x2)
                return;

            if(d >= 0) {
                y1 += sy;
                d -= ax;
            }

            x1 += sx;
            d += ay;
        }
    } else {
        int d = ax - ay / 2;

        while(true) {
            SetPixel(x1, y1, color);

            if(y1 == y2)
                return;

            if(d >= 0) {
                x1 += sx;
                d -= ay;
            }

            y1 += sy;
            d += ax;
        }
    }
}

void Framebuffer::Normalize() {
    switch(m_format) {
    case RGB_FLOAT_32:
        {
            Real smallest = numeric_limits<Real>::max();
            Real largest = -numeric_limits<Real>::max();

            pixel_rgb_float_32 *p = m_bits.m_rgb_float_32;

            for(int i = 0; i < m_pixels; ++i, ++p) {
                if(p->m_r > largest) largest = p->m_r;
                if(p->m_g > largest) largest = p->m_g;
                if(p->m_b > largest) largest = p->m_b;

                if(p->m_r < smallest) smallest = p->m_r;
                if(p->m_g < smallest) smallest = p->m_g;
                if(p->m_b < smallest) smallest = p->m_b;
            }

            const Real delta = largest - smallest;

            assert(delta >= 0.0);

            if(delta > 0.0) {
                const Real scale = 1.0 / delta;

                p = m_bits.m_rgb_float_32;

                for(int i = 0; i < m_pixels; ++i, ++p) {
                    p->m_r = (p->m_r - smallest) * scale;
                    p->m_g = (p->m_g - smallest) * scale;
                    p->m_b = (p->m_b - smallest) * scale;

                    if(p->m_r < 0.0) p->m_r = 0.0;
                    if(p->m_g < 0.0) p->m_g = 0.0;
                    if(p->m_b < 0.0) p->m_b = 0.0;

                    if(p->m_r > 1.0) p->m_r = 1.0;
                    if(p->m_g > 1.0) p->m_g = 1.0;
                    if(p->m_b > 1.0) p->m_b = 1.0;
                }
            } else {
                p = m_bits.m_rgb_float_32;

                for(int i = 0; i < m_pixels; ++i, ++p) {
                    p->m_r = p->m_g = p->m_b = 0.5;
                }
            }
        }
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }
}

void Framebuffer::CorrectGamma(Real target_gamma) {
    assert(target_gamma > 0.0);

    switch(m_format) {
    case RGB_FLOAT_32:
        {
            const float32 inv_target_gamma = static_cast<float32>(1.0 / target_gamma);
            pixel_rgb_float_32 *p = m_bits.m_rgb_float_32;
            for(int i = 0; i < m_pixels; ++i, ++p) {
                p->m_r = powf(p->m_r, inv_target_gamma);
                p->m_g = powf(p->m_g, inv_target_gamma);
                p->m_b = powf(p->m_b, inv_target_gamma);
            }
        }
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }
}

namespace {
    inline
    uint8 convert_float32_to_uint8(float32 x) {
        assert(x >= 0.0f);

        int n = static_cast<int>(x * 256.0f);   // discarding the fractional part

        if(n > 255)
            return 255;
        else return static_cast<uint8>(n);
    }
}

bool Framebuffer::WriteToDisk(const std::string &filename) const {
    uint8 *buffer;

    switch(m_format) {
    case RGB_FLOAT_32:
        {
            uint8 *buf = buffer = new uint8[3 * m_pixels];
            const pixel_rgb_float_32 *p = m_bits.m_rgb_float_32 + m_pixels - m_width;
            // We have to flip the image vertically because DevIL seems to
            // place the origin at the bottom left corner of the image.
            //!\todo Use ilEnable(IL_ORIGIN_SET) followed by ilOriginFunc(IL_ORIGIN_UPPER_LEFT)
            //! to place the origin at the upper left corner.
            for(int y = 0; y < m_height; ++y) {
                for(int x = 0; x < m_width; ++x, ++p) {
                    *buf++ = convert_float32_to_uint8(p->m_r);
                    *buf++ = convert_float32_to_uint8(p->m_g);
                    *buf++ = convert_float32_to_uint8(p->m_b);
                }
                p -= 2 * m_width;
            }
        }
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }

    ILuint image_id;
    ilGenImages(1, &image_id);
    ilBindImage(image_id);

    switch(m_format) {
    case RGB_FLOAT_32:
        ilTexImage(m_width, m_height, 1, 3, IL_RGB, IL_UNSIGNED_BYTE, buffer);
        break;
    default:
        assert(!"Unknown framebuffer format.");
    }

    delete [] buffer;

    ilEnable(IL_FILE_OVERWRITE);
    ilSaveImage(const_cast<ILstring>(filename.c_str()));

    ilDeleteImages(1, &image_id);

    return ilGetError() == IL_NO_ERROR;
}

---