ComposedShader.h

Go to the documentation of this file.

//    Copyright 2004-2019, SenseGraphics AB
//
//    This file is part of H3D API.
//
//    H3D API 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.
//
//    H3D API 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 H3D API; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
//
//    A commercial license is also available. Please contact us at 
//    www.sensegraphics.com for more information.
//
//
//
#ifndef __COMPOSEDSHADER_H__
#define __COMPOSEDSHADER_H__
 
#include <H3D/X3DShaderNode.h>
#include <H3D/ShaderPart.h>
#include <H3D/X3DProgrammableShaderObject.h>
#include <H3D/DependentNodeFields.h>
#include <H3D/FieldTemplates.h>
#include <H3D/SField.h>
#include <string>
#include <H3D/ShaderFunctions.h>
#include <H3D/H3DSingleTextureNode.h>
#include <H3D/ShaderConstants.h>
 
namespace H3D {
 
 
 
//#define EXPORT_SHADER
  
  class H3DAPI_API ComposedShader : 
    public X3DShaderNode, 
    public X3DProgrammableShaderObject {
  public:
 
    typedef DependentSFNode<ShaderConstants, 
      FieldRef< H3DDisplayListObject,
      H3DDisplayListObject::DisplayList, 
      &H3DDisplayListObject::displayList >,
      true > SFShaderConstantsBase;
 
    class H3DAPI_API SFShaderConstants : public SFShaderConstantsBase {
    protected:
      virtual void onAdd( Node *n );
    };
 
    typedef std::map< string , H3D::Shaders::UniformInfo > UniformFieldMap;    
 
    // a map to maintain the uniform values and their related properties 
    UniformFieldMap uniformFields;
 
    typedef DependentMFNode< ShaderPart,
      FieldRef< ShaderPart, 
      ShaderPart::SFShaderString, 
      &ShaderPart::shaderString >,
      true > 
      MFShaderPartBase;
 
    class H3DAPI_API MFShaderPart: public MFShaderPartBase {
    protected:
      virtual void onAdd( Node *);
      virtual void onRemove( Node *);
    };
 
#ifdef EXPORT_SHADER
    class H3DAPI_API UpdateSaveShadersToUrl: public OnNewValueSField < AutoUpdate < SFString > >
    {
      protected:
        virtual void onNewValue( const std::string &v );
    };
    
 
#endif
 
    ComposedShader( Inst< DisplayList  > _displayList = 0,
                    Inst< SFNode       > _metadata    = 0,
                    Inst< SFBool       > _isSelected  = 0,
                    Inst< SFBool       > _isValid     = 0,
                    Inst< SFBool       > _activate    = 0,
                    Inst< SFString     > _language    = 0,
                    Inst< MFShaderPart > _parts       = 0,
                    Inst< SFBool       > _suppressUniformWarnings = 0,
                    Inst< SFString     > _geometryInputType = 0,
                    Inst< SFString     > _geometryOutputType = 0,
                    Inst< SFInt32      > _geometryVerticesOut = 0,
                    Inst< SFString     > _transparencyDetectMode = 0,
                    Inst< MFString     > _transformFeedbackVaryings = 0,
                    Inst< SFBool       > _printShaderWarnings = 0,
                    Inst< SFShaderConstants > _shaderConstants = 0
#ifdef EXPORT_SHADER
                    ,
                    Inst< UpdateSaveShadersToUrl > _saveShadersToUrl = 0
#endif
                    );
 
    virtual ~ComposedShader();
    
    virtual bool addField( const string &_name,
                           const Field::AccessType &access,
                           Field *field );
    
    virtual bool removeField ( const string& _name );
 
    virtual void traverseSG ( TraverseInfo& ti );
 
    virtual void render();
 
    virtual void preRender();
 
    virtual void postRender();
 
    virtual GLbitfield getAffectedGLAttribs();
 
    virtual bool isTransparent( X3DMaterialNode *material );
 
    GLhandleARB getProgramHandle() {
      return program_handle;
    }
   
#ifdef EXPORT_SHADER
    H3DUniquePtr< UpdateSaveShadersToUrl > saveShadersToUrl;
#endif
    
    H3DUniquePtr< SFShaderConstants > shaderConstants;
 
    H3DUniquePtr< MFShaderPart > parts;
 
    H3DUniquePtr< SFBool > suppressUniformWarnings;
 
    H3DUniquePtr< SFString > geometryInputType;
 
    H3DUniquePtr< SFString > geometryOutputType;
 
    H3DUniquePtr< SFInt32  > geometryVerticesOut;
 
 
    H3DUniquePtr< SFString  > transparencyDetectMode;
 
    H3DUniquePtr< MFString > transformFeedbackVaryings;
 
    H3DUniquePtr< SFBool > printShaderWarnings;
 
    static H3DNodeDatabase database;
  protected:
 
    class UpdateUniforms : public EventCollectingField < Field > {
      virtual void update ();
    };
 
    static bool shader_support_checked;
 
    static bool tessellation_support_checked;
 
    GLhandleARB program_handle;
 
    vector< GLhandleARB > current_shaders;
 
    // list of program handles separated by key
    static map<string, GLhandleARB> phandles_map;
    static map<GLhandleARB, int> phandle_counts;
 
    // create program handle for a shader
    static GLhandleARB createHandle(ComposedShader* shader);
 
    // try to find existing handle (with the same signature), if not, go create one
    static std::string genKeyFromShader(ComposedShader* shader);
 
    void setGeometryShaderParameters( GLenum _program_handle);
 
    class SetupDynamicRoutes : public AutoUpdate< Field > {
    protected:
      virtual void update();
 
    public:
      // Map from Fields to nodes in the fields, needed in
      // order to remove nodes properly.
      map< Field *, NodeVector > fields_to_nodes;
    };
 
    H3DUniquePtr< SetupDynamicRoutes > setupDynamicRoutes;
 
    list<H3DSingleTextureNode*> shader_textures;
 
    H3DUniquePtr<UpdateUniforms> updateUniforms;
 
    class UpdateCache: public OnValueChangeSField< SFBool >
    {
    protected:
      virtual void onValueChange( const bool &new_value );
    };
    // this field will be used to react to global caching changing, this will
    // be used to control whether to route uniform field to displayList
    H3DUniquePtr<UpdateCache> updateCache;
 
    H3DInt32 max_texture_in_shader;
 
    H3DInt32 max_image_in_shader;
    
    bool printShaderLog();
    DebugOptions *debug_options_previous;
  public:
    virtual void initialize();
  };
}
 
#endif