gKitGL
ShaderManager.h
00001 
00002 #ifndef _GKSHADER_MANAGER_H
00003 #define _GKSHADER_MANAGER_H
00004 
00005 #include "GLManager.h"
00006 #include "GL/GLShaderObjectIO.h"
00007 #include "GL/TPShaderProgram.h"
00008 
00009 
00010 namespace gk {
00011 
00012 //! \ingroup openGL
00013 //@{
00014 
00015 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 2.
00016 inline
00017 GLShaderProgram *createShaderProgram( 
00018     const TextFile *vertex, 
00019     const TextFile *fragment,
00020     const std::vector<std::string> *definitions= NULL )
00021 {
00022     GLShaderProgram *program= GLManager<GLShaderProgram>::manager().insert( 
00023         new GLShaderProgram());
00024 
00025     if(vertex != NULL)
00026     {
00027         GLShaderObject *shader= GLManager<GLShaderObject>::manager().insert( 
00028             new GLVertexShader());
00029         shader->pushSource(vertex);
00030         if(definitions != NULL)
00031             shader->setDefinitions(*definitions);
00032         program->attachShader(shader);
00033     }
00034     if(fragment != NULL)
00035     {
00036         GLShaderObject *shader= GLManager<GLShaderObject>::manager().insert( 
00037             new GLFragmentShader());
00038         shader->pushSource(fragment);
00039         if(definitions != NULL)
00040             shader->setDefinitions(*definitions);
00041         program->attachShader(shader);
00042     }
00043     
00044     return program;
00045 }
00046 
00047 //! recharge les sources et reconfigure tous les shaders d'un shader program cree par createShaderProgram( ).
00048 inline
00049 int reloadShaderProgram( GLShaderProgram *program )
00050 {
00051     if(program == NULL)
00052         return -1;
00053     
00054     GLShaderObject *shaders[GLShaderObject::SHADERTYPE_LAST];
00055     for(unsigned int i= 0; i < GLShaderObject::SHADERTYPE_LAST; i++)
00056     {
00057         GLShaderObject *shader= program->shader(i);
00058         shaders[i]= shader;     // conserve le shader
00059         if(shader == NULL)
00060             continue;
00061         
00062         // recupere la configuration du shader
00063         // cas particulier, les TextFile dupliquent les donnees, pas de recherche dans le manager avec l'objet lui meme.
00064         TextFile *source= TextFileIO::reload(shader->source()->name());
00065         if(source == NULL)
00066             return -1;
00067         
00068         std::vector<std::string> definitions;
00069         if(shader->definitions() != NULL)
00070             definitions= *shader->definitions();        // duplique les definitions 
00071         
00072         // reconfigure le shader
00073         shader->clear();
00074         shader->pushSource(source);
00075         shader->setDefinitions(definitions);
00076     }
00077     
00078     // reconfigure le shader program
00079     program->clear();
00080     for(unsigned int i= 0; i < GLShaderObject::SHADERTYPE_LAST; i++)
00081         if(shaders[i] != NULL)
00082             program->attachShader(shaders[i]);
00083     
00084     if(program->createGLResource() < 0)
00085         return -1;
00086 
00087     return 1;
00088 }
00089 
00090 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 2.
00091 inline
00092 GLShaderProgram *createShaderProgram( 
00093     const std::string& vertex, 
00094     const std::string& fragment, 
00095     const std::vector<std::string> *definitions= NULL )
00096 {
00097     return createShaderProgram(
00098         TextFileIO::read(vertex),
00099         TextFileIO::read(fragment), 
00100         definitions);
00101 }
00102 
00103 #if defined GK_OPENGL3 || defined GK_OPENGL4    
00104 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 3.
00105 inline
00106 GLShaderProgram *createShaderProgram( 
00107     const TextFile *vertex, 
00108     const TextFile *geometry,
00109     const TextFile *fragment,
00110     const std::vector<std::string> *definitions= NULL )
00111 {
00112     GLShaderProgram *program= createShaderProgram(vertex, fragment, definitions);
00113     if(program == NULL)
00114         return NULL;
00115 
00116     if(geometry != NULL)
00117     {
00118         GLShaderObject *shader= GLManager<GLShaderObject>::manager().insert( 
00119             new GLGeometryShader());
00120         shader->pushSource(geometry);
00121         if(definitions != NULL)
00122             shader->setDefinitions(*definitions);
00123         program->attachShader(shader);
00124     }
00125 
00126     return program;
00127 }
00128 
00129 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 3.
00130 inline
00131 GLShaderProgram *createShaderProgram( 
00132     const std::string& vertex, 
00133     const std::string& geometry,
00134     const std::string& fragment,
00135     const std::vector<std::string> *definitions= NULL )    
00136 {
00137     return createShaderProgram(
00138         TextFileIO::read(vertex),
00139         TextFileIO::read(geometry),
00140         TextFileIO::read(fragment),
00141         definitions);
00142 }
00143 #endif
00144 
00145 #ifdef GK_OPENGL4    
00146 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 4.
00147 inline
00148 GLShaderProgram *createShaderProgram( 
00149     const TextFile *vertex, 
00150     const TextFile *control,
00151     const TextFile *evaluation,
00152     const TextFile *geometry,
00153     const TextFile *fragment,
00154     const std::vector<std::string> *definitions= NULL )
00155 {
00156     GLShaderProgram *program= createShaderProgram(vertex, geometry, fragment, definitions);
00157     if(program == NULL)
00158         return NULL;
00159 
00160     if(control != NULL)
00161     {
00162         GLShaderObject *shader= GLManager<GLShaderObject>::manager().insert( 
00163             new GLControlShader());
00164         shader->pushSource(control);
00165         if(definitions != NULL)
00166             shader->setDefinitions(*definitions);
00167         program->attachShader(shader);
00168     }
00169     if(evaluation != NULL)
00170     {
00171         GLShaderObject *shader= GLManager<GLShaderObject>::manager().insert( 
00172             new GLEvaluationShader());
00173         shader->pushSource(evaluation);
00174         if(definitions != NULL)
00175             shader->setDefinitions(*definitions);
00176         program->attachShader(shader);
00177     }
00178     
00179     return program;
00180 }
00181 
00182 //! gestion 'auto' des ressources openGL : pour les shader programs opengl > 4.
00183 inline
00184 GLShaderProgram *createShaderProgram( 
00185     const std::string& vertex, 
00186     const std::string& control,
00187     const std::string& evaluation,
00188     const std::string& geometry,
00189     const std::string& fragment,
00190     const std::vector<std::string> *definitions= NULL )
00191 {
00192     return createShaderProgram(
00193         TextFileIO::read(vertex),
00194         TextFileIO::read(control),
00195         TextFileIO::read(evaluation),
00196         TextFileIO::read(geometry),
00197         TextFileIO::read(fragment),
00198         definitions);
00199 }
00200 #endif
00201 
00202 //@}
00203 
00204 }
00205 
00206 #endif
 All Classes Namespaces Functions Variables Typedefs Enumerator Friends