texture.cpp

Go to the documentation of this file.

/*
 * texture.cpp
 *
 * Copyright (C) 2009  Thomas A. Vaughan
 * All rights reserved.
 *
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THOMAS A. VAUGHAN ''AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL THOMAS A. VAUGHAN BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *
 * Texture creation.  See texture.h
 */

// includes --------------------------------------------------------------------
#include "texture.h"                    // always include our own header first!

#include "util/file.h"


namespace glut {



////////////////////////////////////////////////////////////////////////////////
//
//      static helper methods
//
////////////////////////////////////////////////////////////////////////////////

static GLint
getGlutInternalFormat
(
IN const media::image_t& image
)
{
        return image.bytes_per_pixel;
}



static GLint
getGlutFormatFromColorFormat
(
IN const media::image_t& image
)
{
        switch (image.color_format) {
        case media::eColorFormat_Grayscale:     return GL_LUMINANCE;
        case media::eColorFormat_GrayAlpha:     return GL_LUMINANCE_ALPHA;
        case media::eColorFormat_RGB:           return GL_RGB;
        case media::eColorFormat_RGBA:          return GL_RGBA;
        default:
                ASSERT_THROW(false, "unknown color format: "
                    << image.color_format);
        }

        // never get here!
        return 0;
}



static int
createOpenGLTexture
(
IN const media::image_t& image
)
{
        ASSERT_THROW(image.isValid(), "Invalid image?");

        GLuint id = 0;
        glGenTextures(1, &id);
        DPRINTF("Generated texture %d...", id);

        glBindTexture(GL_TEXTURE_2D, id);

        // use linear interpolation for small/big textures
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

        // texture should wrap
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);

        GLint level = 0;
        GLint internalFormat = getGlutInternalFormat(image);
        GLint format = getGlutFormatFromColorFormat(image);
        GLint border = 0;
        DPRINTF("internalFormat = %d", internalFormat);
        DPRINTF("format = %d", format);

        GLsizei width = image.width;
        GLsizei height = image.height;
        DPRINTF("  texture width:  %d", width);
        DPRINTF("  texture height: %d", height);
        glTexImage2D(GL_TEXTURE_2D, level, internalFormat, width,
            height, border, format, GL_UNSIGNED_BYTE, image.data);

        return id;
}



class CreateTextureTask : public Task {
public:
        CreateTextureTask(IN const media::image_t * image) {
                        ASSERT(image, "null");
                        m_image = image;
                }
        ~CreateTextureTask(void) throw() { }

        // public class methods ------------------------------------------------
        int getTextureId(void) const throw() { return m_textureId; }

        // glut::Task class interface methods ----------------------------------
        void doTask(void) {
                        ASSERT(m_image, "null");
                        m_textureId = createOpenGLTexture(*m_image);
                }

private:
        CreateTextureTask(void) throw() : m_image(NULL), m_textureId(0) { }

        // private member data -------------------------------------------------
        const media::image_t *  m_image;
        int                     m_textureId;
};



////////////////////////////////////////////////////////////////////////////////
//
//      public API
//
////////////////////////////////////////////////////////////////////////////////

int
createTextureFromImage
(
IN const media::image_t& image
)
{
        ASSERT_THROW(image.isValid(), "Invalid image?");
        smart_ptr<CreateTextureTask> task = new CreateTextureTask(&image);
        ASSERT(task, "out of memory");

        requestTask(task);

        return task->getTextureId();
}



};      // glut namespace