PhongShader.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 __PHONGSHADER_H__
#define __PHONGSHADER_H__
 
#include <H3D/H3DGeneratedFragmentShaderNode.h>
#include <H3D/X3DTexture2DNode.h>
#include <H3D/SFMatrix4f.h>
 
namespace H3D {
 
  class H3DAPI_API PhongShader : 
    public H3DGeneratedFragmentShaderNode {
  public:
  
    typedef DependentSFNode< X3DTexture2DNode, 
                             FieldRef< H3DDisplayListObject,
                                       H3DDisplayListObject::DisplayList,
                                       &H3DDisplayListObject::displayList >, 
                             true >
    SFTexture2DNode;
 
    PhongShader( 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< MFString > _fragmentShaderString = 0,
                 Inst< MFString > _vertexShaderString = 0,
                 Inst< SFTexture2DNode > _ambientMap  = 0,
                 Inst< SFTexture2DNode > _diffuseMap  = 0,
                 Inst< SFTexture2DNode > _emissionMap  = 0,
                 Inst< SFTexture2DNode > _normalMap   = 0,
                 Inst< SFString        > _normalMapCoordSpace = 0,
                 Inst< SFMatrix4f      > _normalMapMatrix = 0,
                 Inst< SFTexture2DNode > _specularMap = 0,
                 Inst< SFTexture2DNode > _glossMap    = 0,
                 Inst< SFTexture2DNode > _specularColorRamp = 0,
                 Inst< SFString        > _specularColorRampMode = 0,
                 Inst< SFTexture2DNode > _diffuseColorRamp = 0,
                 Inst< SFString        > _diffuseColorRampMode = 0,
                 Inst< SFFloat         > _fresnel      = 0,
                 Inst< SFBool          > _modulateMaps = 0,
                 Inst< SFTexture2DNode > _backAmbientMap  = 0,
                 Inst< SFTexture2DNode > _backDiffuseMap  = 0,
                 Inst< SFTexture2DNode > _backEmissionMap  = 0,
                 Inst< SFTexture2DNode > _backNormalMap   = 0,
                 Inst< SFString        > _backNormalMapCoordSpace = 0,
                 Inst< SFMatrix4f      > _backNormalMapMatrix = 0,
                 Inst< SFTexture2DNode > _backSpecularMap = 0,
                 Inst< SFTexture2DNode > _backGlossMap    = 0,
                 Inst< SFTexture2DNode > _backSpecularColorRamp = 0,
                 Inst< SFString        > _backSpecularColorRampMode = 0,
                 Inst< SFTexture2DNode > _backDiffuseColorRamp = 0,
                 Inst< SFString        > _backDiffuseColorRampMode = 0,
                 Inst< SFFloat         > _backFresnel = 0,
                 Inst< SFBool          > _backModulateMaps = 0,
                 Inst< SFBool          > _separateBackColor = 0,
                 Inst< SFString        > _model = 0 );
    
    virtual void traverseSG( TraverseInfo &ti );
 
    //
    H3DUniquePtr< SFTexture2DNode > ambientMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > diffuseMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > emissionMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > normalMap;
 
    //
    H3DUniquePtr< SFMatrix4f > normalMapMatrix;
 
    H3DUniquePtr< SFString > normalMapCoordSpace;
 
    //
    H3DUniquePtr< SFTexture2DNode > specularMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > glossMap;
 
    H3DUniquePtr< SFTexture2DNode > diffuseColorRamp;
 
    H3DUniquePtr< SFString > diffuseColorRampMode;
 
    H3DUniquePtr< SFTexture2DNode > specularColorRamp;
 
 
    H3DUniquePtr< SFString > specularColorRampMode;
 
    H3DUniquePtr< SFFloat > fresnel;
 
    H3DUniquePtr< SFBool > modulateMaps;
 
    //
    H3DUniquePtr< SFTexture2DNode > backAmbientMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > backDiffuseMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > backEmissionMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > backNormalMap;
 
    //
    H3DUniquePtr< SFMatrix4f > backNormalMapMatrix;
 
    H3DUniquePtr< SFString > backNormalMapCoordSpace;
 
    //
    H3DUniquePtr< SFTexture2DNode > backSpecularMap;
 
    //
    H3DUniquePtr< SFTexture2DNode > backGlossMap;
 
    H3DUniquePtr< SFTexture2DNode > backDiffuseColorRamp;
 
    H3DUniquePtr< SFString > backDiffuseColorRampMode;
 
    H3DUniquePtr< SFTexture2DNode > backSpecularColorRamp;
 
    H3DUniquePtr< SFString > backSpecularColorRampMode;
 
    H3DUniquePtr< SFFloat > backFresnel;
 
    H3DUniquePtr< SFBool > backModulateMaps;
 
    H3DUniquePtr< SFBool > separateBackColor;
 
    H3DUniquePtr< SFString > model;
 
    static H3DNodeDatabase database;
  protected:
 
    TraverseInfo::LightVector current_light_nodes;
 
    AutoPtrVector< SFMatrix4f > current_light_node_transforms;
 
    unsigned int current_nr_lightsources;
 
    string uniqueLightFieldName( const string &field_name,
                                 X3DLightNode *light);
 
    virtual string addUniformFields( ComposedShader *shader );
 
    virtual string addUniformFieldsForLight( ComposedShader *shader,
                                             X3DLightNode *light,
                                             int gl_index);
 
    virtual string getFunctionShaderString();
 
    virtual void getVaryingVariables( vector< VaryingVariable > &variables );
 
    virtual void getAttributes( vector< Attribute > &attributes );
 
    virtual string getFragmentShaderString();
 
    virtual string getBaseDiffuseColor( const string &diffuse_color, 
                                        const string &back_diffuse_color );
 
    virtual string getBaseEmissionColor( const string &emission_color, 
                                         const string &back_emission_color );
 
    virtual string getBaseAmbientColor( const string &ambient_color, 
                                        const string &back_ambient_color );
 
    virtual string getBaseSpecularColor( const string &specular_color, 
                                         const string &back_specular_color );
    
    virtual string getBaseShininess( const string &shininess, 
                                     const string &back_shininess );
 
    virtual string getBaseNormal( const string &normal, 
                                  const string &back_normal );
 
    virtual string getBaseColors( const string &emission_color,
                                  const string &shininess, 
                                  const string &ambient_color,
                                  const string &diffuse_color,
                                  const string &specular_color,
                                  const string &normal,
                                  const string &back_emission_color,
                                  const string &back_shininess, 
                                  const string &back_ambient_color,
                                  const string &back_diffuse_color,
                                  const string &back_specular_color,
                                  const string &back_normal );
 
    virtual string getLightContribution( X3DLightNode *light,
                                         unsigned int index, 
                                         string normal, 
                                         string vertex, 
                                         string shininess, 
                                         string ambient_color,
                                         string diffuse_color,
                                         string specular_color );
 
    virtual string setupLight( X3DLightNode *light,
                               unsigned int gl_index );
  };
}
 
#endif