OSDLGLTexture.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2003-2009 Olivier Boudeville
 *
 * This file is part of the OSDL library.
 *
 * The OSDL library is free software: you can redistribute it and/or modify
 * it under the terms of either the GNU Lesser General Public License or
 * the GNU General Public License, as they are published by the Free Software
 * Foundation, either version 3 of these Licenses, or (at your option) 
 * any later version.
 *
 * The OSDL 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 and the GNU General Public License
 * for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License and of the GNU General Public License along with the OSDL library.
 * If not, see <http://www.gnu.org/licenses/>.
 *
 * Author: Olivier Boudeville (olivier.boudeville@esperide.com)
 *
 */


#ifndef OSDL_GL_TEXTURE_H_
#define OSDL_GL_TEXTURE_H_


#include "OSDLOpenGL.h"    // for OpenGLException

#include "Ceylan.h"        // for inheritance, Uint32, CountedPointer, etc.

#include <string>




namespace OSDL
{


    
    namespace Video
    {
    
    
    
        // Texture are made from surfaces.
        class Surface ;
        
    
    
        namespace OpenGL
        {
        
        
        
            typedef GLU::Int GLTextureIdentifier ;
        
        
        
        
            class OSDL_DLL GLTextureException : public OpenGLException
            {
            
                public:
                
                
                    GLTextureException( const std::string & reason ) ;
                    
                    
                    virtual ~GLTextureException() throw() ;
                                
            } ;



            class OSDL_DLL GLTexture : public Ceylan::TextDisplayable,
                public Ceylan::LoadableWithContent<Surface>
            {

            
                public:

            
            
                    enum TextureDimensionality { Disabled, OneDim, TwoDim } ;
                    
                    
                    
                    enum TextureFlavour { None, Basic, For2D, For3D } ;

                
                
                    explicit GLTexture( const std::string textureFilename,
                        TextureFlavour flavour, bool preload = true ) ;
                
                
                
                    GLTexture( Surface & sourceSurface,
                        TextureFlavour flavour ) ;
                
                
                
                    virtual ~GLTexture() throw() ;
                


                    virtual Length getWidth() const ;


                    virtual Length getHeight() const ;



                    
                    /*
                     * Section dealing with the transfer and removal of this
                     * texture from the system memory to the video card.
                     *
                     */
                    
            
                    virtual bool wasUploaded() const ;
                    
                     
                    virtual void upload() ;
                    
                    
                    
                    virtual void remove() ;
                    
                    
                    
                    
                    
                    virtual void setAsCurrent() const ;
                
                    
                    
                    virtual bool isResident() ;
                    
                    
                    
                    

                    // LoadableWithContent template instanciation.
        
                
                
                    virtual bool load() ;
        
        
        
                    virtual bool unload() ;
                    



                    
                    virtual const std::string toString( 
                        Ceylan::VerbosityLevels level = Ceylan::high ) const ;
                
                
                

                
                
                    // Static section.
                    
                    
                    // Should use the flavour member.
                        
                                        
                    static TextureDimensionality GetTextureDimensionality() ;
                
                    
                    
                    static void SetTextureDimensionality( 
                        TextureDimensionality Dimensionality = TwoDim ) ;
                
                
                
                    static TextureDimensionality CurrentTextureDimensionality ;
                    
                                
                
                    static void SetTextureFlavour( 
                        TextureFlavour textureFlavour ) ;
                    
                    

                    static void SetTextureEnvironmentParameter( 
                        GLEnumeration targetEnvironment,
                        GLEnumeration environmentParameter,
                        GLfloat parameterValue ) ;



                    static void SetTextureEnvironmentParameter( 
                        GLEnumeration targetEnvironment,
                        GLEnumeration environmentParameter,
                        const GLfloat * parameterValues ) ;



                    static void UnbindCurrentTexture() ;
                    
                    
                    
                    static std::string GetExtensionForFlavour( 
                        TextureFlavour flavour ) ;
                    
                    
                    
                    
                    
                    
                protected:
                
                
                
                    void setUpInternalSurfaceFrom( Surface & sourceSurface ) ;
                    
                    
                    
                    /*
                     * The internal texture surface itself is in the _content
                     * member, inherited from the loadable template.
                     *
                     */
                     
                     
            
                    GLTextureIdentifier _id ;
            
                
                
                    TextureFlavour _flavour ;
            
            
            
                    bool _unloadable ;


            
                private:
                
                
                
                    explicit GLTexture( const GLTexture & source ) ;
            
            
            
                    GLTexture & operator = ( const GLTexture & source ) ;
            
            
            } ;
            
            
            
            typedef Ceylan::CountedPointer<GLTexture> TextureCountedPtr ;
        
        }
        
    }

}



#endif // OSDL_GL_TEXTURE_H_

---