Inventor/nodes/SoShaderParameter.h

Go to the documentation of this file.

/*=======================================================================
 *** 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-2021 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/SoMFMatrix.h>
#include <Inventor/fields/SoSFNode.h>
#include <Inventor/fields/SoMFNode.h>
#include <Inventor/fields/SoSFEnum.h>

typedef unsigned int GLenum;

class SoGLShaderObject ;
class SoShaderObject ;
class SoShaderProgram ;

typedef WINGDIAPI void APIENTRY SoVPCacheFunc(const char *const);
typedef WINGDIAPI void APIENTRY SoVPCacheFunc2(int, const char *const);

/*----------------------------------------------------------------------------*/

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);
public:SoDEPRECATED enum
  ShaderType {
    VERTEX,
    FRAGMENT
  };

  SoSFEnum     SoDEPRECATED shaderType;

  virtual bool isEqual(const SoUniformShaderParameter* param) const = 0;

private:
  static void initClass() ;
  static void exitClass() ;

  // Sets or updates a parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj)=0;

  // Indicates if this parameter has a regular behavior.
  // A parameter has a regular behavior if as soon as it is modified
  // the value should be sent to the vertex/fragment shader.
  // This is not the case of some parameters such as SoShaderStateMatrixParameter or
  // SoShaderTextureParameter which depends on the state.
  SbBool isRegularBehavior() const
  { return m_isRegularBehavior ; }
private:
  void GLRender(SoGLRenderAction *action);

private:
  SoUniformShaderParameter();

  SbBool m_isRegularBehavior ;

  // Destructor
  virtual ~SoUniformShaderParameter();

};
/*----------------------------------------------------------------------------*/

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

private:
  // Destructor
  virtual ~SoShaderParameterMatrix();

};
/*----------------------------------------------------------------------------*/

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

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() ;

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

private:
  // Destructor
  virtual ~SoShaderStateMatrixParameter();

};
/*----------------------------------------------------------------------------*/

class  SoShaderParameterStruct : public SoUniformShaderParameter {

  SO_NODE_HEADER(SoShaderParameterStruct);

public:
  SoShaderParameterStruct();
  SoMFNode value;

  virtual bool isEqual(const SoUniformShaderParameter* param) const;

private:
  static void initClass();
  static void exitClass();

  // Sets or updates the parameter's value
  virtual void updateParameter(SoGLRenderAction* action, SoGLShaderObject *glShadObj);

private:
  // Destructor
  virtual ~SoShaderParameterStruct();
};

/*----------------------------------------------------------------------------*/

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 SoVPCacheFunc2 * getVertexAttribFunc() = 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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 *  getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 *  getVertexAttribFunc();

  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 SoVPCacheFunc2 *  getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  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 SoVPCacheFunc2 *  getVertexAttribFunc();

  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 SoVPCacheFunc2 * getVertexAttribFunc();

  virtual const char * getVertexAttribPtr(int)
   {
    uintptr_t castedOffest = (uintptr_t)offset.getValue();
    return reinterpret_cast<char*>(castedOffest);
  }
  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_*/

---

Open Inventor Toolkit reference manual, generated on 12 Feb 2024
Copyright © Thermo Fisher Scientific All rights reserved. http://www.openinventor.com/