VRS - The Virtual Rendering System

version 3.3

ubershadermanager.h

Go to the documentation of this file.

/******************************************************************************
 * VRS - The Virtual Rendering System
 * Copyright (C) 2000-2006 Computer Graphics Systems Group at the 
 * Hasso-Plattner-Institute (HPI), Potsdam, Germany.
 *
 * This  library  is  free  software; you can redistribute it and/or  modify it
 * under the terms of the GNU Lesser General Public  License  as  published  by
 * the  Free  Software  Foundation;  either  version 2.1 of the License, or (at
 * your option) any later version. This 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 for more details. You should have received
 * a copy of the GNU Lesser+ General Public License along with this library; if
 * not, write to the FreeSoftware Foundation, Inc., 59 Temple Place, Suite 330,
 * Boston, MA, 02111-1307, USA.
 ******************************************************************************/

// $Id: $
//
// $Log: $

#ifndef VRS_GL2_EXTSHADER_UBERSHADERMANAGER_H
#define VRS_GL2_EXTSHADER_UBERSHADERMANAGER_H

//
// VRS
//
#include <vrs/sharedobj.h>
#include <vrs/container/dictionary.h>
#include <vrs/opengl/gl2/fragmentshaderobject.h>
#include <vrs/opengl/gl2/vertexshaderobject.h>
#include <vrs/opengl/gl2/programobject.h>


//
// EXTSHADER
//
#include <vrs/opengl/gl2/us/shaderhandler.h>
#include <vrs/opengl/gl2/us/handlerinterface.h>
#include <vrs/opengl/gl2/us/prototypehandlertable.h>
#include <vrs/opengl/gl2/us/ubershaderprogramobject.h>
#include <vrs/opengl/gl2/us/ubershaderuniformvariable.h>


namespace VRS
{
        namespace GL2
        {
                namespace EXTSHADER
                {
            class VRS_US_API UberShaderManager : public SharedObj
                        {
                        public:

                                static SO<UberShaderManager> getInstance(void);

                void setVertexHandlerInterface(SO<HandlerInterface> vertexHandlerInterface);
                inline SO<HandlerInterface> getVertexHandlerInterface(void) const
                                {
                                        return this->vertexHandlerInterface_;
                                }

                void setFragmentHandlerInterface(SO<HandlerInterface> fragmentHandlerInterface);
                inline SO<HandlerInterface> getFragmentHandlerInterface(void) const
                                {
                                        return this->fragmentHandlerInterface_;
                                }

                                void setVertexPrototypeHandlerTable(SO<PrototypeHandlerTable> vertexHandlerPrototypeTable);
                                inline SO<PrototypeHandlerTable> getVertexPrototypeHandlerTable(void) const
                                {
                                        return this->vertexHandlerPrototypeTable_;
                                }

                                void setFragmentPrototypeHandlerTable(SO<PrototypeHandlerTable> fragmentHandlerPrototypeTable);
                                inline SO<PrototypeHandlerTable> getFragmentPrototypeHandlerTable(void) const
                                {
                                        return this->fragmentHandlerPrototypeTable_;
                                }


                bool registerVertexHandler(SO<HandlerObject> vertexHandler,
                                           SO<UberShaderProgramObject> uberShaderProgramObject);

                bool isRegisteredVertexHandler(SO<HandlerObject> vertexHandler);

                void unregisterVertexHandler(SO<HandlerObject> vertexHandler);

                bool registerFragmentHandler(SO<HandlerObject> fragmentHandler,
                                               SO<UberShaderProgramObject> uberShaderProgramObject);

                bool isRegisteredFragmentHandler(SO<HandlerObject> fragmentHandler);

                void unregisterFragmentHandler(SO<HandlerObject> fragmentHandler);

                void registerUberShaderProgram(SO<UberShaderProgramObject> uberShaderProgram);
                bool isRegisteredUberShaderProgram(SO<UberShaderProgramObject> uberShaderProgram);
                void unregisterUberShaderProgram(SO<UberShaderProgramObject> uberShaderProgram);

                void pushUberShader(SO<Engine> engine, SO<UberShaderProgramObject> uberShader);
                void popUberShader(SO<Engine> engine, SO<UberShaderProgramObject> uberShader);

                                static const HandlerID generateProgramObjectID(void)
                                {
                                        return ++programObjectBaseID_;
                                }

                static const std::string cleanString(const std::string& str);
                static const std::string stripWhiteSpaces(const std::string& str);

                SO<GL2::ProgramObject> getUberShaderProgram(void) const
                {
                    return this->mainProgramObject_;
                }

                                ~UberShaderManager(void);

                        private:

                                UberShaderManager(void);

                        private:

                //prevent fragmentation of invoker table...
                void freeVertexInvokerIndex(unsigned int index);
                void freeFragmentInvokerIndex(unsigned int index);

                std::string createFragmentHookTable(void);
                std::string createVertexHookTable(void);

                void updateInvokerTables(SO<UberShaderProgramObject> uberShaderProgram, bool active);

                void setVertexHandlerInvokerStatus(const std::string& prototypeHandlerName, bool active);
                void setFragmentHandlerInvokerStatus(const std::string& prototypeHandlerName, bool active);

                                bool hasVertexHandlerInvokerStatus(const std::string& prototypeHandlerName, bool active);
                bool hasFragmentHandlerInvokerStatus(const std::string& prototypeHandlerName, bool active);

                        private:

                bool                                    initUberShader_;
                unsigned int                            pushedUberShader_; //reference counting...

                //global handler invoker tables
                std::vector<float>                      globalVertexHandlerInvokerTable_;
                std::vector<float>                      globalFragmentHandlerInvokerTable_;
                        
                SO<UberShaderUniformVariable<std::vector<float> > > globalVertexHandlerInvokerTableUniform_;
                SO<UberShaderUniformVariable<std::vector<float> > > globalFragmentHandlerInvokerTableUniform_;

                //shared main program...
                SO<GL2::FragmentShaderObject >          mainFragmentShaderObject_;
                SO<GL2::VertexShaderObject>             mainVertexShaderObject_;
                SO<GL2::VertexShaderObject>             hookTableVertexShaderObject_;
                SO<GL2::FragmentShaderObject >          hookTableFragmentShaderObject_;
                SO<GL2::ProgramObject>                  mainProgramObject_;

                SO<Array<SO<UberShaderProgramObject> > > priorityProgramTable_;

                SO<Dictionary<std::string, SO<Array<SO<ShaderHandler> > > > > vertexHookTable_;
                SO<Dictionary<std::string, SO<Array<SO<ShaderHandler> > > > > fragmentHookTable_;

                SO<Dictionary<SO<HandlerObject>, SO<GL2::VertexShaderObject> > >       vertexShaders_;
                SO<Dictionary<SO<HandlerObject>, SO<GL2::FragmentShaderObject> > >     fragmentShaders_;

                //local invoker mapping tables
                SO<Dictionary<SO<ShaderHandler>, unsigned int> >  vertexHandlerInvokerMappingTable_;
                SO<Dictionary<SO<ShaderHandler>, unsigned int> >  fragmentHandlerInvokerMappingTable_;

                        private:

                                static HandlerID                    programObjectBaseID_;

                //prototype handler registry....
                                SO<PrototypeHandlerTable>       vertexHandlerPrototypeTable_;
                                SO<PrototypeHandlerTable>   fragmentHandlerPrototypeTable_;

                //handler interface registry....
                                SO<HandlerInterface>            vertexHandlerInterface_;
                                SO<HandlerInterface>            fragmentHandlerInterface_;

            };//endclass UberShaderManager

                };//endnamespace EXTSHADER

        };//endnamespace GL2

};//endnamespace VRS

#endif // VRS_GL2_EXTSHADER_UBERSHADERMANAGER_H

---

Generated on Thu May 24 06:00:16 2012 by Doxygen 1.5.6

© 2001-2010 Hasso-Plattner-Institut | Impressum | Contact