SoShaderParameter.h

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2022 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
                                                             /* include files */
#ifndef _SO_SHADER_PARAMETER_H_
#define _SO_SHADER_PARAMETER_H_
 
#include <Inventor/SbBasic.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/nodes/SoNode.h>
#include <Inventor/fields/SoSFBufferObject.h>
#include <Inventor/fields/SoSFString.h>
#include <Inventor/fields/SoSFFloat.h>
#include <Inventor/fields/SoSFInt32.h>
#include <Inventor/fields/SoSFVec2f.h>
#include <Inventor/fields/SoSFVec2i32.h>
#include <Inventor/fields/SoSFVec3f.h>
#include <Inventor/fields/SoSFVec3i32.h>
#include <Inventor/fields/SoSFVec4f.h>
#include <Inventor/fields/SoSFVec4i32.h>
#include <Inventor/fields/SoSFBool.h>
#include <Inventor/fields/SoMFFloat.h>
#include <Inventor/fields/SoMFInt32.h>
#include <Inventor/fields/SoMFShort.h>
#include <Inventor/fields/SoMFVec2f.h>
#include <Inventor/fields/SoMFVec2s.h>
#include <Inventor/fields/SoMFVec2i32.h>
#include <Inventor/fields/SoMFVec3f.h>
#include <Inventor/fields/SoMFVec3s.h>
#include <Inventor/fields/SoMFVec3i32.h>
#include <Inventor/fields/SoMFVec4f.h>
#include <Inventor/fields/SoMFVec4i32.h>
#include <Inventor/fields/SoMFVec4s.h>
#include <Inventor/fields/SoMFVec4b.h>
#include <Inventor/fields/SoMFVec4ui32.h>
#include <Inventor/fields/SoMFVec4us.h>
#include <Inventor/fields/SoMFVec4ub.h>
#include <Inventor/fields/SoSFMatrix.h>
#include <Inventor/fields/SoSFMatrix3.h>
#include <Inventor/fields/SoMFMatrix.h>
#include <Inventor/fields/SoSFNode.h>
#include <Inventor/fields/SoMFNode.h>
#include <Inventor/fields/SoSFEnum.h>
#include <Inventor/SbEventHandler.h>
#include <Inventor/renderer/RendererResourceMacro.h>
 
typedef unsigned int GLenum;
 
class SoGLShaderObject ;
class SoShaderObject ;
class SoShaderProgram ;
 
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter : public SoNode {
 
  SO_NODE_ABSTRACT_HEADER(SoShaderParameter);
 
public:
  SoSFString name;
 
  SoSFInt32 identifier;
 
 
private:
  static void initClass() ;
  static void exitClass() ;
 
  SbBool isInternal() const;
 
private:
  SoShaderParameter();
 
  // Destructor
  virtual ~SoShaderParameter();
 
};
 
class  SoUniformShaderParameter : public SoShaderParameter {
 
  SO_NODE_ABSTRACT_HEADER(SoUniformShaderParameter);
  RENDERER_RESOURCE(SoUniformShaderParameter);
 
public:
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const = 0;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
  virtual void notify(SoNotList *list);
 
private:
  void GLRender(SoGLRenderAction *action);
 
private:
  SoUniformShaderParameter();
 
  // Destructor
  virtual ~SoUniformShaderParameter();
 
private:
 
#if 1             SoDEPRECATED enum
  ShaderType {
    VERTEX,
    FRAGMENT
  };
 
  SoSFEnum     SoDEPRECATED shaderType;
#endif 
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter1f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter1f);
 
public:
 
  SoSFFloat value;
 
  SoShaderParameter1f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
 
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter1f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter1i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter1i);
 
public:
  SoSFInt32 value;
 
  SoShaderParameter1i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter1i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter2f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter2f);
 
public:
  SoSFVec2f value;
 
  SoShaderParameter2f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter2f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter2i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter2i);
 
public:
  SoSFVec2i32 value;
 
  SoShaderParameter2i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter2i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter3f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter3f);
 
public:
  SoSFVec3f value;
 
  SoShaderParameter3f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter3f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter3i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter3i);
 
public:
  SoSFVec3i32 value;
 
  SoShaderParameter3i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter3i();
 
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter4f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter4f);
 
public:
  SoSFVec4f value;
 
  SoShaderParameter4f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter4f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameter4i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameter4i);
 
public:
  SoSFVec4i32 value;
 
  SoShaderParameter4i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameter4i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray1f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray1f);
 
public:
  SoMFFloat value;
 
  SoShaderParameterArray1f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray1f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray1i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray1i);
 
public:
  SoMFInt32 value;
 
  SoShaderParameterArray1i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray1i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray2f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray2f);
 
public:
  SoMFVec2f value;
 
  SoShaderParameterArray2f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray2f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray2i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray2i);
 
public:
  SoMFVec2i32 value;
 
  SoShaderParameterArray2i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray2i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray3f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray3f);
 
public:
  SoMFVec3f value;
 
  SoShaderParameterArray3f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray3f();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray3i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray3i);
 
public:
  SoMFVec3i32 value;
 
  SoShaderParameterArray3i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray3i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray4f : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray4f);
 
public:
  SoMFVec4f value;
 
  SoShaderParameterArray4f();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray4f();
 
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterArray4i : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterArray4i);
 
public:
  SoMFVec4i32 value;
 
  SoShaderParameterArray4i();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterArray4i();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterMatrix : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterMatrix);
 
public:
  SoSFMatrix value;
 
  SoShaderParameterMatrix();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterMatrix();
 
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderParameterMatrix3 : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterMatrix3);
 
public:
  SoSFMatrix3 value;
 
  SoShaderParameterMatrix3();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterMatrix3();
 
};
/*----------------------------------------------------------------------------*/
 
 
class  SoShaderParameterMatrixArray : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderParameterMatrixArray);
 
public:
  SoMFMatrix value;
 
  SoShaderParameterMatrixArray();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderParameterMatrixArray();
};
/*----------------------------------------------------------------------------*/
 
class  SoShaderStateMatrixParameter : public SoUniformShaderParameter {
 
  SO_NODE_HEADER(SoShaderStateMatrixParameter);
 
public:
 
  enum MatrixType {
    MODELVIEW,
 
    PROJECTION,
 
    TEXTURE,
 
    MODELVIEW_PROJECTION
  };
 
   enum MatrixTransform {
    IDENTITY,
 
    TRANSPOSE,
 
    INVERSE,
 
    INVERSE_TRANSPOSE
  };
 
  SoSFEnum matrixType;
 
  SoSFEnum matrixTransform;
 
  SoShaderStateMatrixParameter();
 
  virtual bool isEqual(const SoUniformShaderParameter* param) const;
 
private:
  static void initClass() ;
  static void exitClass() ;
 
private:
  // Destructor
  virtual ~SoShaderStateMatrixParameter();
 
};
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter : public SoShaderParameter {
 
  SO_NODE_ABSTRACT_HEADER(SoVertexShaderParameter);
 
private:
  virtual void doAction(SoAction *action);
  virtual void GLRender(SoGLRenderAction *action);
  virtual void callback(SoCallbackAction *action);
  virtual void getBoundingBox( SoGetBoundingBoxAction *action );
  virtual void rayPick(SoRayPickAction *action );
  virtual void getPrimitiveCount(SoGetPrimitiveCountAction *action );
 
private:
  static void initClass();
  static void exitClass();
 
  static SbBool areVertexAttribFuncAvailable();
  static SbBool areVertexAttribDivisorFuncAvailable();
 
  void getVertexAttribIndex(SoState * state, int& firstInd, int& size);
 
  virtual size_t       getVertexAttribOffset(int)     { return 0; }
  virtual const char * getVertexAttribPtr(int i=0)    = 0;
  virtual size_t       getVertexAttribStride()        = 0;
  virtual int          getVertexAttribNum()           = 0;
  virtual GLenum       getVertexAttribType()          = 0;
  virtual int          getVertexAttribSize()          = 0;
  virtual SbBool       getVertexAttribIsToNormalize() = 0;
  virtual unsigned int getVertexAttribDivisor()       { return 0; }
private:
  SoVertexShaderParameter();
 
  // Destructor
  virtual ~SoVertexShaderParameter();
 
};
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter1f : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter1f);
 
public:
  SoVertexShaderParameter1f();
 
  SoMFFloat value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr( int )      { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 1; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter1f();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter1s : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter1s);
 
public:
  SoVertexShaderParameter1s();
 
  SoMFShort value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 1; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter1s();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter2f : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter2f);
 
public:
  SoVertexShaderParameter2f();
 
  SoMFVec2f value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 2; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter2f();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter2s : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter2s);
 
public:
  SoVertexShaderParameter2s();
 
  SoMFVec2s value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 2; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter2s();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter3f : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter3f);
 
public:
  SoVertexShaderParameter3f();
 
  SoMFVec3f value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 3; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter3f();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter3s : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter3s);
 
public:
  SoVertexShaderParameter3s();
 
  SoMFVec3s value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 3; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter3s();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4f : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4f);
 
public:
  SoVertexShaderParameter4f();
 
  SoMFVec4f value;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4f();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4i : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4i);
 
public:
  SoVertexShaderParameter4i();
 
  SoMFVec4i32   value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4i();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4s : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4s);
 
public:
  SoVertexShaderParameter4s();
 
  SoMFVec4s     value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4s();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4b : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4b);
 
public:
  SoVertexShaderParameter4b();
 
  SoMFVec4b     value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4b();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4ui : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4ui);
 
public:
  SoVertexShaderParameter4ui();
 
  SoMFVec4ui32  value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4ui();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4us : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4us);
 
public:
  SoVertexShaderParameter4us();
 
  SoMFVec4us    value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4us();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameter4ub : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameter4ub);
 
public:
  SoVertexShaderParameter4ub();
 
  SoMFVec4ub    value;
 
  SoSFBool      rangeScaling;
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int)        { return (char *)value.getValues(0); }
  virtual size_t       getVertexAttribStride()        { return value.getValueSize(); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return rangeScaling.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameter4ub();
};
 
/*----------------------------------------------------------------------------*/
 
class  SoVertexShaderParameterMatrix : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameterMatrix);
 
public:
  SoVertexShaderParameterMatrix();
 
  SoMFMatrix    value;
 
private:
  virtual void doAction(SoAction *action);
 
private:
  static void initClass();
  static void exitClass();
 
  virtual const char * getVertexAttribPtr(int i=0);
  virtual size_t       getVertexAttribStride()        { return sizeof(SbMat); }
  virtual int          getVertexAttribNum()           { return value.getNum(); }
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return 4; }
  virtual SbBool       getVertexAttribIsToNormalize() { return FALSE; }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameterMatrix();
 
private:
  // Storing a list of the transposed matrices of the value field is necessary
  // because Open Inventor stores matrices in row major order whereas OpenGL
  // load them in column major order. Consequently, this list is necessary, to provide
  // values sequentially stored in column major order.
  SbMat * m_columnMajorOrderMatrices;
  int     m_matricesNumber;
  void    storeColumnMajorOrderMatrices(int startIndex);
};
 
/*----------------------------------------------------------------------------*/
 
//@TOBEWRAPPED
class  SoVertexShaderParameterBufferObject : public SoVertexShaderParameter {
 
  SO_NODE_HEADER(SoVertexShaderParameterBufferObject);
 
public:
  SoVertexShaderParameterBufferObject();
 
  SoSFBufferObject value;
 
  SoSFInt32 components;
 
  SoSFEnum type;
 
  SoSFInt32 offset;
 
  SoSFInt32 stride;
 
  SoSFBool shouldBeNormalized;
 
private:
  virtual void doAction(SoAction *action);
 
private:
 
  static void initClass();
  static void exitClass();
 
  virtual size_t       getVertexAttribOffset(int)     { return (size_t)offset.getValue(); }
  virtual const char*  getVertexAttribPtr(int);
 
  virtual size_t       getVertexAttribStride();
  virtual int          getVertexAttribNum();
  virtual GLenum       getVertexAttribType();
  virtual int          getVertexAttribSize()          { return components.getValue(); }
  virtual SbBool       getVertexAttribIsToNormalize() { return shouldBeNormalized.getValue(); }
 
private:
  // Destructor
  virtual ~SoVertexShaderParameterBufferObject();
};
 
/*----------------------------------------------------------------------------*/
 
 
 
#endif /*_SO_SHADER_PARAMETER_H_*/