shader.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 LILITH_SHADER_INCLUDED
#define LILITH_SHADER_INCLUDED

#include "glew.h"
#include "../grinliz/gltypes.h"
#include "../grinliz/glvector.h"
#include "../grinliz/glcolor.h"
#include "../grinliz/glmatrix.h"
#include <string>
#include <map>

namespace lilith3d
{

class Texture;
class ShaderManager;

struct Shader
{
        GLhandleARB vertex;
        GLhandleARB fragment;
        GLhandleARB program;
};

class ShaderManager
{
  public:
        enum {
                TERRAIN_SHADER,
                TERRAIN_SHADOW_SHADER,
                WATER_SHADER,
                FOLIAGE_SHADER,
                DIFFUSE_SHADER,
                DIFFUSE_SHADOW_SHADER,
                TREE_SHADER,
                TREE_BB_SHADER,
                COLORFACET_SHADER,

                SHADER_COUNT,
        };

        ShaderManager();
        ~ShaderManager();

        static int MaxTextures();
        static ShaderManager* Instance()        { return instance; }

        bool PowerFragments()   { return powerFrag; }

        void    SetImportPath( const std::string& path )        { importPath = path; }
        bool    LoadRequiredShaders();

        const Shader* GetShader( int id ) { GLASSERT( id >= 0 && id < SHADER_COUNT );   
                                                                                         return &shaderGroup[id]; }

        void    UseShader( const Shader* group );

        const Shader* CurrentShader()   { return currentShader; }

        void    BindTextures( const Shader* group, const Texture* textures[], int numTextures );

        void    UnBindTextures( int startIndex, int count );

        void    SetUniform( const Shader* group, const char* name, float value );
        void    SetUniform( const Shader* group, const char* name, const grinliz::Vector3F& value );
        void    SetUniform( const Shader* group, const char* name, const grinliz::Vector4F& value );
        void    SetUniform( const Shader* group, const char* name, const grinliz::Color3F& value );
        void    SetUniform( const Shader* group, const char* name, const grinliz::Color4F& value );
        void    SetUniform( const Shader* group, const char* name, const grinliz::Matrix4& value );

        void    ClearShaders();

        void    PrintInfoLog( GLhandleARB obj );
        void    CheckError( GLhandleARB object );

  private:
        const Shader*   LoadShader( Shader* group,
                                                                        const char* filenameVertex, 
                                                                        const char* filenameFragment );

        GLhandleARB             LoadShader( GLhandleARB program, const char* filename, int type );
        
        bool PowerFragmentProgram();
        static ShaderManager* instance;

        Shader shaderGroup[ SHADER_COUNT ];

        std::string importPath;
        const Shader* currentShader;
        bool powerFrag;

        // Constant shaders linked to all loaded shaders:
        std::string constantText;
        std::string utilityFragment;
        std::string utilityVertex;
};

};      // namespace lilith3d

#endif

---