texture.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/
#ifndef TEXTURE_INCLUDED
#define TEXTURE_INCLUDED


#ifdef _MSC_VER
#pragma warning ( disable : 4786 )
#endif
#include <string>
#include <map>
#include <vector>

#include "SDL.h"
#include "../grinliz/gltypes.h"
#include "../grinliz/glcolor.h"
#include "lilith3dgl.h"


namespace lilith3d
{


class Texture
{
        friend class TextureManager;

  public:
        Texture()       {
                nameId = 0;
                textureId = 0;
        }

        const std::string&      Name() const    { return name; }
        U32                                     NameId() const  { return nameId; }

        // The id reported to opengl
        U32 TextureId() const   { return textureId; }

        //bool EmitsLight() const       { return flags.IsSet( EMISSIVE ) != 0; }

        void SetTexture( SDL_Surface* surface ) const;

        const grinliz::Color4F& AverageColor() const { return averageColor; }
        const grinliz::Color3F  AverageOpaqueColor() const { return averageOpaqueColor; }

        enum {
                ALPHA           = 0x01,
//              EMISSIVE        = 0x02,
        };

  private:
        std::string name;
        std::string filename;
        U32 nameId;
        U32 textureId;
        grinliz::Flag<U32> flags;

        grinliz::Color4F averageColor;
        grinliz::Color3F averageOpaqueColor;
};


struct TextureInputDesc
{
        const char* name;
        U32                     id;
        U32                     x, y;
};


class TextureManager
{
  public:
        enum {
                NO_MIPMAP = 0x01,
                //EMITS_LIGHT = 0x02,
                TRANSPARENT_BORDER = 0x04,
        };

        static TextureManager* Instance()       {       return instance;
                                                                                }
        TextureManager();
        ~TextureManager();

        void SetImportPath( const std::string& path )   { importPath = path; }
        const std::string& ImportPath()                                 { return importPath; }

        bool LoadRequiredTextures();

        bool UseHighQuality()                                                   { return highQuality; }

        const Texture* LoadTexture(     const std::string& fileName,            
                                                                const std::string& textureName,
                                                                int id = 0,
                                                                int flags = 0 );
                                                
        const Texture* CreateTexture(   SDL_Surface*,                                           // Create from an SDL 32 bit surface. ABGR.
                                                                        const std::string& textureName,         // Name to give the texture
                                                                        int id,                                                         // More name, for instance water:2
                                                                        int options );                  // Is this a glow or light texture?

        const Texture* CreateTexture(   int size,                                                       // 32 bit ABGR.
                                                                        const std::string& textureName,         // Name to give the texture
                                                                        int id,                                                         // More name, for instance water:2
                                                                        int options );                  // Is this a glow or light texture?

        const Texture* GetTexture( const std::string& textureName, U32 nameId );

        unsigned TextureMemory() { return textureMemory; }

  private:
        int ToGLFormat( SDL_PixelFormat* format );
        void CalcAverageColor( SDL_Surface* surface, U8* start, int size, grinliz::Color3F* opaque, grinliz::Color4F* transparent );

        static TextureManager* instance;
        
        unsigned textureMemory;
        enum {
                MAX_TEXTURES = 256,
                MAX_IMAGES = 256
        };
        int textureDefCount;
        Texture textureDefArr[ MAX_TEXTURES ];

        std::string importPath;
        bool highQuality;
        int terrainCount;
};
};      // namespace lilith3d

#endif

---