src/render/rTexture.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program 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.

This program 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 this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  
***************************************************************************

*/

#ifndef ArmageTron_TEXTURE_H
#define ArmageTron_TEXTURE_H

#include "tString.h"
#include "tResourceManager.h"
#include "tDirectories.h"
#include "tList.h"
#include "rGL.h"
#include "rGLuintObject.h"
#include <list>

struct SDL_Surface;

class rTextureGroups
{
public:
    enum Group
    {
        TEX_FLOOR=0,
        TEX_WALL=1,
        TEX_OBJ=2,
        TEX_FONT=3,
        TEX_GROUPS
    };

    static int TextureMode[TEX_GROUPS];                 
    static char const * TextureGroupDescription[TEX_GROUPS];   
};

class rSurface
{
public:
    explicit rSurface( char const * fileName, tPath const *path = &tDirectories::Data() );       
    ~rSurface();                                      
    rSurface( rSurface const & other );               
    rSurface & operator = ( rSurface const & other ); 
protected:
    rSurface();                             
    void Init();                            
    void Clear();                           
    void Create( char const * fileName, tPath const *path = &tDirectories::Data() );   
    void Create( SDL_Surface * surface );   

private:
    // attributes
    SDL_Surface * surface_;                  
    GLenum format_;                          

    void CopyFrom( rSurface const & other ); 

    // accessors
public:
    inline SDL_Surface * GetSurface( void ) const;                           
    inline rSurface const & GetSurface( SDL_Surface * & surface ) const; 
    inline GLenum const & GetFormat( void ) const;                           
    inline rSurface const & GetFormat( GLenum & format ) const;          
protected:
    inline rSurface & SetSurface( SDL_Surface * surface );                   
    inline rSurface & SetFormat( GLenum const & format );                    
private:
};

// ******************************************************************************************

class rITexture
{
public:
    virtual ~rITexture() = 0;                

    static void UnloadAll();                 
    static void LoadAll();                   

    inline void Select(bool enforce=false);  
    inline void Unload();                    
protected:
    rITexture(); 

    virtual void OnSelect(bool enforce) = 0; 
    virtual void OnUnload() = 0;             

private:
    static tList<rITexture> s_textures_;     
    int id_;                                 

    // disable copying
    rITexture( rITexture const & );
    rITexture & operator = ( rITexture const & );
};

// ******************************************************************************************

class rISurfaceTexture: public rITexture
{
public:
    rISurfaceTexture(int group, bool repx=0, bool repy=0,
                     bool storeAlpha=false);        
    virtual ~rISurfaceTexture();                    

    bool Loaded(){ return textureModeLast_ >= 0; }  

    static bool storageHack_;
protected:
    virtual void ProcessImage(SDL_Surface *);       

    void Upload( rSurface & surface );              

    virtual void OnSelect(bool enforce);            
    virtual void OnSelect()=0;                      
    virtual void OnUnload();                        

    void StoreAlpha();                              

    static bool s_reportErrors_;                    
private:

    int group_;             

    int textureModeLast_;   

    rGLuintObjectTexture tint_;   
    bool repx_,repy_;             
    bool storeAlpha_;             
};

// ******************************************************************************************

class rFileTexture: public rISurfaceTexture
{
public:
    rFileTexture(int group, char const * fileName, bool repx=0, bool repy=0,
                 bool storeAlpha=false, tPath const *path = &tDirectories::Data());    
    virtual ~rFileTexture();                

protected:
    virtual void OnSelect();                
private:
    tString fileName_;                      
    tPath const *path_;

public:
    inline tString const & GetFileName( void ) const;                     
    inline rFileTexture const & GetFileName( tString & fileName ) const;  
protected:
private:
    inline rFileTexture & SetFileName( tString const & fileName );            
};

class rResourceTextureWrapper;

class rResourceTexture
{
    class InternalTex;
    friend class InternalTex;
    class InternalTex : public rFileTexture
    {
    public:
        int use_;
        tResourcePath path_;

        InternalTex(tResourcePath const &path);

        void Release();
        void Use() {++use_;}
    };
    typedef InternalTex tex_t; // don't ask me why this is needed. InteralTex just won't cut it in some places
    typedef std::list<InternalTex *> texlist_t;
    static texlist_t textures;
    InternalTex *tex_;

    bool repx_, repy_;
public:
    rResourceTexture() : tex_(0) {}
    rResourceTexture(tResourcePath const &path, bool repx=false, bool repy=false);

    rResourceTexture(rResourceTexture const &other) : tex_(other.tex_) {if(tex_) tex_->Use();}
    rResourceTexture &operator=(rResourceTexture const &other);
    ~rResourceTexture() {if(tex_) tex_->Release();}
    bool Valid() {return tex_;}
        void Select();
    tResourcePath const &Path() {return tex_->path_;}
};

// ******************************************************************************************

class rSurfaceTexture: public rISurfaceTexture
{
public:
    rSurfaceTexture(int group, rSurface const & surface, bool repx=0, bool repy=0,
                    bool storeAlpha=false );    
    virtual ~rSurfaceTexture();                 

protected:
    virtual void OnSelect();                    
private:
    rSurface const & surface_;                  

public:
    inline const rSurface & GetSurface( void ) const; 
protected:
private:
};

// ******************************************************************************************
// *
// *    GetSurface
// *
// ******************************************************************************************
// ******************************************************************************************

SDL_Surface * rSurface::GetSurface( void ) const
{
    return this->surface_;
}

// ******************************************************************************************
// *
// *    GetSurface
// *
// ******************************************************************************************
// ******************************************************************************************

rSurface const & rSurface::GetSurface( SDL_Surface * & surface ) const
{
    surface = this->surface_;
    return *this;
}

// ******************************************************************************************
// *
// *    SetSurface
// *
// ******************************************************************************************
// ******************************************************************************************

rSurface & rSurface::SetSurface( SDL_Surface * surface )
{
    this->surface_ = surface;
    return *this;
}

// ******************************************************************************************
// *
// *    GetFormat
// *
// ******************************************************************************************
// ******************************************************************************************

GLenum const & rSurface::GetFormat( void ) const
{
    return this->format_;
}

// ******************************************************************************************
// *
// *    GetFormat
// *
// ******************************************************************************************
// ******************************************************************************************

rSurface const & rSurface::GetFormat( GLenum & format ) const
{
    format = this->format_;
    return *this;
}

// ******************************************************************************************
// *
// *    SetFormat
// *
// ******************************************************************************************
// ******************************************************************************************

rSurface & rSurface::SetFormat( GLenum const & format )
{
    this->format_ = format;
    return *this;
}

// ******************************************************************************************
// *
// *    Select
// *
// ******************************************************************************************
// ******************************************************************************************

void rITexture::Select( bool enforce )
{
    this->OnSelect( enforce );
}

// ******************************************************************************************
// *
// *    Unload
// *
// ******************************************************************************************
// ******************************************************************************************

void rITexture::Unload()
{
    this->OnUnload();
}

// ****************************************************************************
// *
// *    GetFileName
// *
// ****************************************************************************
// ****************************************************************************

tString const & rFileTexture::GetFileName( void ) const
{
    return this->fileName_;
}

// ****************************************************************************
// *
// *    GetFileName
// *
// ****************************************************************************
// ****************************************************************************

rFileTexture const & rFileTexture::GetFileName( tString & fileName ) const
{
    fileName = this->fileName_;
    return *this;
}

// ****************************************************************************
// *
// *    SetFileName
// *
// ****************************************************************************
// ****************************************************************************

rFileTexture & rFileTexture::SetFileName( tString const & fileName )
{
    this->fileName_ = fileName;
    return *this;
}

// ****************************************************************************
// *
// *    GetSurface
// *
// ****************************************************************************
// ****************************************************************************

const rSurface & rSurfaceTexture::GetSurface( void ) const
{
    return this->surface_;
}

#endif

---