Texture.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public License
   as published by the Free Software Foundation; either version 2.1
   of the License, or (at your option) any later version.
   
   This library 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
   Lesser General Public License for more details.
    
   You should have received a copy of the GNU Lesser General Public
   License along with this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */

#ifndef _GG_Texture_h_
#define _GG_Texture_h_

#include <GG/Base.h>
#include <GG/Exception.h>

#include <boost/serialization/access.hpp>
#include <boost/serialization/binary_object.hpp>


namespace GG {

class GG_API Texture
{
public: 
    Texture();          
    virtual ~Texture(); 

 
    std::string      Filename() const;         
    GLenum           WrapS() const;            
    GLenum           WrapT() const;            
    GLenum           MinFilter() const;        
    GLenum           MagFilter() const;        
    int              BytesPP() const;          
    GLint            Width() const;            
    GLint            Height() const;           
    bool             MipMapped() const;        
    GLuint           OpenGLId() const;         
    const GLfloat*   DefaultTexCoords() const; 
    GLint            DefaultWidth() const;     
    GLint            DefaultHeight() const;    

    void OrthoBlit(const Pt& pt1, const Pt& pt2, const GLfloat* tex_coords = 0) const;

    void OrthoBlit(const Pt& pt) const;
 
    // intialization functions
    void Load(const std::string& filename, bool mipmap = false);

    void Init(int width, int height, const unsigned char* image, GLenum format, GLenum type, int bytes_per_pixel, bool mipmap = false);

    void Init(int x, int y, int width, int height, int image_width, const unsigned char* image, GLenum format, GLenum type, int bytes_per_pixel, bool mipmap = false);

    void SetWrap(GLenum s, GLenum t);         
    void SetFilters(GLenum min, GLenum mag);  
    void Clear();  

 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(BadFile, GG::Texture, Exception);

    GG_CONCRETE_EXCEPTION(InvalidColorChannels, GG::Texture, Exception);

    GG_CONCRETE_EXCEPTION(InsufficientResources, GG::Texture, Exception);

private:
    Texture(const Texture& rhs);             
    Texture& operator=(const Texture& rhs);  
    void InitFromRawData(int width, int height, const unsigned char* image, GLenum format, GLenum type, int bytes_per_pixel, bool mipmap);
    unsigned char* GetRawBytes();

    std::string m_filename;   

    int         m_bytes_pp;
    GLint       m_width;
    GLint       m_height;

    GLenum      m_wrap_s, m_wrap_t;
    GLenum      m_min_filter, m_mag_filter;

    bool        m_mipmaps;
    GLuint      m_opengl_id;   
    GLenum      m_format;
    GLenum      m_type;

    GLfloat     m_tex_coords[4];  
    GLint       m_default_width;  
    GLint       m_default_height;

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

class GG_API SubTexture
{
public: 
    SubTexture(); 

    SubTexture(const boost::shared_ptr<const Texture>& texture, int x1, int y1, int x2, int y2);  

    SubTexture(const SubTexture& rhs); 
    const SubTexture& operator=(const SubTexture& rhs); 
    virtual ~SubTexture(); 

 
    bool             Empty() const;     
    const GLfloat*   TexCoords() const; 
    GLint            Width() const;     
    GLint            Height() const;    
    const Texture*   GetTexture() const;

    void OrthoBlit(const Pt& pt1, const Pt& pt2) const;

    void OrthoBlit(const Pt& pt) const;
 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(BadTexture, GG::SubTexture, Exception);

    GG_CONCRETE_EXCEPTION(InvalidTextureCoordinates, GG::SubTexture, Exception);

private:
    boost::shared_ptr<const Texture> m_texture;        
    GLint                            m_width;
    GLint                            m_height;
    GLfloat                          m_tex_coords[4];  

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};

class GG_API TextureManager
{
public: 

    boost::shared_ptr<Texture> StoreTexture(Texture* texture, const std::string& texture_name);

    boost::shared_ptr<Texture> StoreTexture(const boost::shared_ptr<Texture>& texture, const std::string& texture_name);

    boost::shared_ptr<Texture> GetTexture(const std::string& name, bool mipmap = false);

    void                FreeTexture(const std::string& name);

    static void         InitDevIL(); 

private:
    TextureManager();
    boost::shared_ptr<Texture> LoadTexture(const std::string& filename, bool mipmap);

    static bool s_created;
    static bool s_il_initialized;
    std::map<std::string, boost::shared_ptr<Texture> > m_textures;

    friend TextureManager& GetTextureManager();
};

TextureManager& GetTextureManager();

} // namespace GG

// template implementations
template <class Archive>
void GG::Texture::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(m_filename)
        & BOOST_SERIALIZATION_NVP(m_bytes_pp)
        & BOOST_SERIALIZATION_NVP(m_width)
        & BOOST_SERIALIZATION_NVP(m_height)
        & BOOST_SERIALIZATION_NVP(m_wrap_s)
        & BOOST_SERIALIZATION_NVP(m_wrap_t)
        & BOOST_SERIALIZATION_NVP(m_min_filter)
        & BOOST_SERIALIZATION_NVP(m_mag_filter)
        & BOOST_SERIALIZATION_NVP(m_mipmaps)
        & BOOST_SERIALIZATION_NVP(m_format)
        & BOOST_SERIALIZATION_NVP(m_type)
        & BOOST_SERIALIZATION_NVP(m_tex_coords)
        & BOOST_SERIALIZATION_NVP(m_default_width)
        & BOOST_SERIALIZATION_NVP(m_default_height);

    unsigned char* raw_data_bytes = 0;
    std::size_t raw_data_size = 0;
    if (Archive::is_saving::value) {
        if (m_filename == "" && m_opengl_id)
            raw_data_bytes = GetRawBytes();
        if (raw_data_bytes)
            raw_data_size = static_cast<std::size_t>(m_width * m_height * m_bytes_pp);
    }
    ar & BOOST_SERIALIZATION_NVP(raw_data_size);
    if (raw_data_size) {
        if (Archive::is_loading::value) {
            typedef unsigned char uchar;
            raw_data_bytes = new uchar[raw_data_size];
        }
        boost::serialization::binary_object raw_data(raw_data_bytes, raw_data_size);
        ar & BOOST_SERIALIZATION_NVP(raw_data);
    }

    if (Archive::is_loading::value) {
        if (raw_data_size) {
            Init(0, 0, m_default_width, m_default_height, m_width, raw_data_bytes, m_format, m_type, m_bytes_pp, m_mipmaps);
        } else {
            try {
                Load(m_filename);
            } catch (const BadFile& e) {
                // take no action; the Texture must have been uninitialized when saved
            }
        }
        SetWrap(m_wrap_s, m_wrap_t);
        SetFilters(m_min_filter, m_mag_filter);
    }

    if (raw_data_size)
        delete [] raw_data_bytes;
}

template <class Archive>
void GG::SubTexture::serialize(Archive& ar, const unsigned int version)
{
    boost::shared_ptr<Texture> non_const_texture;
    if (Archive::is_saving::value)
        non_const_texture = boost::const_pointer_cast<Texture>(m_texture);

    ar  & boost::serialization::make_nvp("m_texture", non_const_texture)
        & BOOST_SERIALIZATION_NVP(m_width)
        & BOOST_SERIALIZATION_NVP(m_height)
        & BOOST_SERIALIZATION_NVP(m_tex_coords);

    if (Archive::is_loading::value)
        m_texture = boost::const_pointer_cast<const Texture>(non_const_texture);
}

#endif // _GG_Texture_h_

---