C:/Projects/ngn/include/shader.h

/***************************************************************************
 *            shader.h
 *
 *  Sun Sep 12 22:19:14 2004
 *  Copyright  2004  thierry schartz
 *  thierry.schartz@bluebottle.com
 ****************************************************************************/

/*
 *  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 Library 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.
 */

#ifndef SHADER_H
#define SHADER_H

#ifdef WIN32
#include <windows.h>
#endif



#include "GLee.h"

namespace ngn {
        namespace gl {



                        /* base OpenGL shading language wrapper class */
                        class Shader
                        {
                        public:
                                Shader();
                                Shader( const Shader& other );
                                virtual ~Shader();
                                
                                bool load( const char* shader_file );
                                
                                GLubyte* getSource();
                                GLhandleARB getHandler();
                                
                                int compile();

                        protected:
                                GLhandleARB m_handler;

                        private:
                                GLubyte *m_src;
                                const char* m_shader_file;
                        };

                        /* fragment shader class */
                        class FragmentShader : public Shader
                        {
                        public:
                                FragmentShader();
                        };

                        /* vertex shader class */
                        class VertexShader : public Shader
                        {
                        public:
                                VertexShader();
                        };



                        /* GLSL shader program class */
                        class ShaderProgram
                        {
                                public:
                                        ShaderProgram();
                                        ShaderProgram( const ShaderProgram& other );
                                        virtual ~ShaderProgram();
                                        // create shader ( load, compile and link )            
                                        bool create( const char* fragment_shader_file, const char* vertex_shader_file  );
                                        // begin rendering with shader
                                        void begin();
                                        // post rendering with shader
                                        void end();
                                        /* send vars to GLSL program */
                                        // float
                                        bool sendUniform1f(char* varname, GLfloat v0); 
                                        bool sendUniform2f(char* varname, GLfloat v0, GLfloat v1); 
                                        bool sendUniform3f(char* varname, GLfloat v0, GLfloat v1, GLfloat v2); 
                                        bool sendUniform4f(char* varname, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); 
                                        // int
                                        bool sendUniform1i(char* varname, GLint v0);
                                        bool sendUniform2i(char* varname, GLint v0, GLint v1);
                                        bool sendUniform3i(char* varname, GLint v0, GLint v1, GLint v2);
                                        bool sendUniform4i(char* varname, GLint v0, GLint v1, GLint v2, GLint v3);
                                        // float array
                                        bool sendUniform1fv(char* varname, GLsizei count, GLfloat *value);
                                        bool sendUniform2fv(char* varname, GLsizei count, GLfloat *value);
                                        bool sendUniform3fv(char* varname, GLsizei count, GLfloat *value);
                                        bool sendUniform4fv(char* varname, GLsizei count, GLfloat *value);
                                        // int array
                                        bool sendUniform1iv(char* varname, GLsizei count, GLint *value);
                                        bool sendUniform2iv(char* varname, GLsizei count, GLint *value);
                                        bool sendUniform3iv(char* varname, GLsizei count, GLint *value);
                                        bool sendUniform4iv(char* varname, GLsizei count, GLint *value);
                                        // matrices 2x2,3x3 & 4x4
                                        bool sendUniformMatrix2fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value);
                                        bool sendUniformMatrix3fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value);
                                        bool sendUniformMatrix4fv(char* varname, GLsizei count, GLboolean transpose, GLfloat *value);

                                        // receive vars
                                        void getUniformfv(char* name, GLfloat* values);
                                        void getUniformiv(char* name, GLint* values); 

                                        // query shader state
                                        bool isReady();
                                                                                
                
                                private:
                                        bool compile();
                                        bool link();
                                        GLint getUniformLocation( const GLcharARB *name );

                                        FragmentShader m_fragment;
                                        VertexShader m_vertex;
                                        GLhandleARB m_program;

                                        bool m_compiled;
                                        bool m_loaded;
                                        bool m_linked;
      
                        };




        }//gl
}//ngn
#endif /* SHADER_H */

    
            

---