/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield * Copyright (C) 2003-2005 3Dlabs Inc. Ltd. * Copyright (C) 2008 Zebra Imaging * Copyright (C) 2012 David Callu * * This application is open source and may be redistributed and/or modified * freely and without restriction, both in commercial and non commercial * applications, as long as this copyright notice is maintained. * * This application 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. */ /* file: include/osg/Uniform * author: Mike Weiblen 2008-01-02 */ #ifndef OSG_UNIFORM #define OSG_UNIFORM 1 #include #include #include #include #include #include #include #include #include #include #include // for memset #include #include namespace osg { // forward declare class NodeVisitor; /////////////////////////////////////////////////////////////////////////// // C++ classes to represent the GLSL-specific types. // // Warning : // OSG is Row major // GLSL is Column Major // // If you define an Uniform with type Uniform::FLOAT_MAT4X2 and so use a Matrix4x2 to setup your Uniform, // like this : // 1 2 // 3 4 // 5 6 // 7 8 // // you will get in your shader a Column Major Matrix like this : // 1 3 5 7 // 2 4 6 8 // // In simple term, you matrix in OSG will be a transposed matrix in GLSL // // // You can avoid this behaviours starting GLSL version 1.40 with uniform layout : // // // layout(row_major) uniform matrix4x2 myVariable; // // // template class MatrixTemplate { public: enum { col_count = ColN }; enum { row_count = RowN }; enum { value_count = ColN * RowN }; typedef T value_type; public: MatrixTemplate() {} ~MatrixTemplate() {} value_type& operator()(int row, int col) { return _mat[row][col]; } value_type operator()(int row, int col) const { return _mat[row][col]; } MatrixTemplate& operator = (const MatrixTemplate& rhs) { if( &rhs == this ) return *this; set(rhs.ptr()); return *this; } void set(const MatrixTemplate& rhs) { set(rhs.ptr()); } void set(value_type const * const ptr) { value_type* local_ptr = (value_type*)_mat; for(int i=0;i class Matrix2Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix2Template() { makeIdentity(); } Matrix2Template( const Matrix2Template& mat ) { set(mat.ptr()); } Matrix2Template( value_type a00, value_type a01, value_type a10, value_type a11 ) { set( a00, a01, a10, a11 ); } ~Matrix2Template() {} using base_class::set; void set(value_type a00, value_type a01, value_type a10, value_type a11 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; } void makeIdentity() { set( 1, 0, 0, 1 ); } }; template class Matrix2x3Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix2x3Template() { base_class::reset(); } Matrix2x3Template( const Matrix2x3Template& mat ) { set(mat.ptr()); } Matrix2x3Template( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12 ) { set( a00, a01, a02, a10, a11, a12 ); } ~Matrix2x3Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[0][2]=a02; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[1][2]=a12; } }; template class Matrix2x4Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix2x4Template() { base_class::reset(); } Matrix2x4Template( const Matrix2x4Template& mat ) { set(mat.ptr()); } Matrix2x4Template( value_type a00, value_type a01, value_type a02, value_type a03, value_type a10, value_type a11, value_type a12, value_type a13 ) { set( a00, a01, a02, a03, a10, a11, a12, a13 ); } ~Matrix2x4Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a02, value_type a03, value_type a10, value_type a11, value_type a12, value_type a13 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[0][2]=a02; base_class::_mat[0][3]=a03; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[1][2]=a12; base_class::_mat[1][3]=a13; } }; template class Matrix3x2Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix3x2Template() { base_class::reset(); } Matrix3x2Template( const Matrix3x2Template& mat ) { set(mat.ptr()); } Matrix3x2Template( value_type a00, value_type a01, value_type a10, value_type a11, value_type a20, value_type a21 ) { set( a00, a01, a10, a11, a20, a21 ); } ~Matrix3x2Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a10, value_type a11, value_type a20, value_type a21 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[2][0]=a20; base_class::_mat[2][1]=a21; } }; template class Matrix3Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix3Template() { base_class::reset(); } Matrix3Template( const Matrix3Template& mat ) { set(mat.ptr()); } Matrix3Template( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12, value_type a20, value_type a21, value_type a22 ) { set( a00, a01, a02, a10, a11, a12, a20, a21, a22 ); } ~Matrix3Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12, value_type a20, value_type a21, value_type a22 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[0][2]=a02; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[1][2]=a12; base_class::_mat[2][0]=a20; base_class::_mat[2][1]=a21; base_class::_mat[2][2]=a22; } void makeIdentity() { set( 1, 0, 0, 0, 1, 0, 0, 0, 1 ); } }; template class Matrix3x4Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix3x4Template() { base_class::reset(); } Matrix3x4Template( const Matrix3x4Template& mat ) { set(mat.ptr()); } Matrix3x4Template( value_type a00, value_type a01, value_type a02, value_type a03, value_type a10, value_type a11, value_type a12, value_type a13, value_type a20, value_type a21, value_type a22, value_type a23 ) { set( a00, a01, a02, a03, a10, a11, a12, a13, a20, a21, a22, a23 ); } ~Matrix3x4Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a02, value_type a03, value_type a10, value_type a11, value_type a12, value_type a13, value_type a20, value_type a21, value_type a22, value_type a23 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[0][2]=a02; base_class::_mat[0][3]=a03; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[1][2]=a12; base_class::_mat[1][3]=a13; base_class::_mat[2][0]=a20; base_class::_mat[2][1]=a21; base_class::_mat[2][2]=a22; base_class::_mat[2][3]=a23; } }; template class Matrix4x2Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix4x2Template() { base_class::reset(); } Matrix4x2Template( const Matrix4x2Template& mat ) { set(mat.ptr()); } Matrix4x2Template( value_type a00, value_type a01, value_type a10, value_type a11, value_type a20, value_type a21, value_type a30, value_type a31 ) { set( a00, a01, a10, a11, a20, a21, a30, a31 ); } ~Matrix4x2Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a10, value_type a11, value_type a20, value_type a21, value_type a30, value_type a31 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[2][0]=a20; base_class::_mat[2][1]=a21; base_class::_mat[3][0]=a30; base_class::_mat[3][1]=a31; } }; template class Matrix4x3Template : public MatrixTemplate { public: typedef MatrixTemplate base_class; typedef typename base_class::value_type value_type; public: Matrix4x3Template() { base_class::reset(); } Matrix4x3Template( const Matrix4x3Template& mat ) { set(mat.ptr()); } Matrix4x3Template( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12, value_type a20, value_type a21, value_type a22, value_type a30, value_type a31, value_type a32 ) { set( a00, a01, a02, a10, a11, a12, a20, a21, a22, a30, a31, a32 ); } ~Matrix4x3Template() {} using base_class::set; void set( value_type a00, value_type a01, value_type a02, value_type a10, value_type a11, value_type a12, value_type a20, value_type a21, value_type a22, value_type a30, value_type a31, value_type a32 ) { base_class::_mat[0][0]=a00; base_class::_mat[0][1]=a01; base_class::_mat[0][2]=a02; base_class::_mat[1][0]=a10; base_class::_mat[1][1]=a11; base_class::_mat[1][2]=a12; base_class::_mat[2][0]=a20; base_class::_mat[2][1]=a21; base_class::_mat[2][2]=a22; base_class::_mat[3][0]=a30; base_class::_mat[3][1]=a31; base_class::_mat[3][2]=a32; } }; typedef Matrix2Template Matrix2; typedef Matrix2x3Template Matrix2x3; typedef Matrix2x4Template Matrix2x4; typedef Matrix3x2Template Matrix3x2; typedef Matrix3Template Matrix3; typedef Matrix3x4Template Matrix3x4; typedef Matrix4x2Template Matrix4x2; typedef Matrix4x3Template Matrix4x3; typedef Matrix2Template Matrix2d; typedef Matrix2x3Template Matrix2x3d; typedef Matrix2x4Template Matrix2x4d; typedef Matrix3x2Template Matrix3x2d; typedef Matrix3Template Matrix3d; typedef Matrix3x4Template Matrix3x4d; typedef Matrix4x2Template Matrix4x2d; typedef Matrix4x3Template Matrix4x3d; /////////////////////////////////////////////////////////////////////////// /** Uniform encapsulates glUniform values */ class OSG_EXPORT Uniform : public Object { public: enum Type { FLOAT = GL_FLOAT, FLOAT_VEC2 = GL_FLOAT_VEC2, FLOAT_VEC3 = GL_FLOAT_VEC3, FLOAT_VEC4 = GL_FLOAT_VEC4, DOUBLE = GL_DOUBLE, DOUBLE_VEC2 = GL_DOUBLE_VEC2, DOUBLE_VEC3 = GL_DOUBLE_VEC3, DOUBLE_VEC4 = GL_DOUBLE_VEC4, INT = GL_INT, INT_VEC2 = GL_INT_VEC2, INT_VEC3 = GL_INT_VEC3, INT_VEC4 = GL_INT_VEC4, UNSIGNED_INT = GL_UNSIGNED_INT, UNSIGNED_INT_VEC2 = GL_UNSIGNED_INT_VEC2_EXT, UNSIGNED_INT_VEC3 = GL_UNSIGNED_INT_VEC3_EXT, UNSIGNED_INT_VEC4 = GL_UNSIGNED_INT_VEC4_EXT, BOOL = GL_BOOL, BOOL_VEC2 = GL_BOOL_VEC2, BOOL_VEC3 = GL_BOOL_VEC3, BOOL_VEC4 = GL_BOOL_VEC4, FLOAT_MAT2 = GL_FLOAT_MAT2, FLOAT_MAT3 = GL_FLOAT_MAT3, FLOAT_MAT4 = GL_FLOAT_MAT4, FLOAT_MAT2x3 = GL_FLOAT_MAT2x3, FLOAT_MAT2x4 = GL_FLOAT_MAT2x4, FLOAT_MAT3x2 = GL_FLOAT_MAT3x2, FLOAT_MAT3x4 = GL_FLOAT_MAT3x4, FLOAT_MAT4x2 = GL_FLOAT_MAT4x2, FLOAT_MAT4x3 = GL_FLOAT_MAT4x3, DOUBLE_MAT2 = GL_DOUBLE_MAT2, DOUBLE_MAT3 = GL_DOUBLE_MAT3, DOUBLE_MAT4 = GL_DOUBLE_MAT4, DOUBLE_MAT2x3 = GL_DOUBLE_MAT2x3, DOUBLE_MAT2x4 = GL_DOUBLE_MAT2x4, DOUBLE_MAT3x2 = GL_DOUBLE_MAT3x2, DOUBLE_MAT3x4 = GL_DOUBLE_MAT3x4, DOUBLE_MAT4x2 = GL_DOUBLE_MAT4x2, DOUBLE_MAT4x3 = GL_DOUBLE_MAT4x3, SAMPLER_1D = GL_SAMPLER_1D, SAMPLER_2D = GL_SAMPLER_2D, SAMPLER_3D = GL_SAMPLER_3D, SAMPLER_CUBE = GL_SAMPLER_CUBE, SAMPLER_1D_SHADOW = GL_SAMPLER_1D_SHADOW, SAMPLER_2D_SHADOW = GL_SAMPLER_2D_SHADOW, SAMPLER_1D_ARRAY = GL_SAMPLER_1D_ARRAY_EXT, SAMPLER_2D_ARRAY = GL_SAMPLER_2D_ARRAY_EXT, SAMPLER_CUBE_MAP_ARRAY = GL_SAMPLER_CUBE_MAP_ARRAY, SAMPLER_1D_ARRAY_SHADOW = GL_SAMPLER_1D_ARRAY_SHADOW_EXT, SAMPLER_2D_ARRAY_SHADOW = GL_SAMPLER_2D_ARRAY_SHADOW_EXT, SAMPLER_2D_MULTISAMPLE = GL_SAMPLER_2D_MULTISAMPLE, SAMPLER_2D_MULTISAMPLE_ARRAY = GL_SAMPLER_2D_MULTISAMPLE_ARRAY, SAMPLER_CUBE_SHADOW = GL_SAMPLER_CUBE_SHADOW_EXT, SAMPLER_CUBE_MAP_ARRAY_SHADOW = GL_SAMPLER_CUBE_MAP_ARRAY_SHADOW, SAMPLER_BUFFER = GL_SAMPLER_BUFFER_EXT, SAMPLER_2D_RECT = GL_SAMPLER_2D_RECT, SAMPLER_2D_RECT_SHADOW = GL_SAMPLER_2D_RECT_SHADOW, INT_SAMPLER_1D = GL_INT_SAMPLER_1D_EXT, INT_SAMPLER_2D = GL_INT_SAMPLER_2D_EXT, INT_SAMPLER_3D = GL_INT_SAMPLER_3D_EXT, INT_SAMPLER_CUBE = GL_INT_SAMPLER_CUBE_EXT, INT_SAMPLER_1D_ARRAY = GL_INT_SAMPLER_1D_ARRAY_EXT, INT_SAMPLER_2D_ARRAY = GL_INT_SAMPLER_2D_ARRAY_EXT, INT_SAMPLER_CUBE_MAP_ARRAY = GL_INT_SAMPLER_CUBE_MAP_ARRAY, INT_SAMPLER_2D_MULTISAMPLE = GL_INT_SAMPLER_2D_MULTISAMPLE, INT_SAMPLER_2D_MULTISAMPLE_ARRAY = GL_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, INT_SAMPLER_BUFFER = GL_INT_SAMPLER_BUFFER_EXT, INT_SAMPLER_2D_RECT = GL_INT_SAMPLER_2D_RECT_EXT, UNSIGNED_INT_SAMPLER_1D = GL_UNSIGNED_INT_SAMPLER_1D_EXT, UNSIGNED_INT_SAMPLER_2D = GL_UNSIGNED_INT_SAMPLER_2D_EXT, UNSIGNED_INT_SAMPLER_3D = GL_UNSIGNED_INT_SAMPLER_3D_EXT, UNSIGNED_INT_SAMPLER_CUBE = GL_UNSIGNED_INT_SAMPLER_CUBE_EXT, UNSIGNED_INT_SAMPLER_1D_ARRAY = GL_UNSIGNED_INT_SAMPLER_1D_ARRAY_EXT, UNSIGNED_INT_SAMPLER_2D_ARRAY = GL_UNSIGNED_INT_SAMPLER_2D_ARRAY_EXT, UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY = GL_UNSIGNED_INT_SAMPLER_CUBE_MAP_ARRAY, UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE, UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY = GL_UNSIGNED_INT_SAMPLER_2D_MULTISAMPLE_ARRAY, UNSIGNED_INT_SAMPLER_BUFFER = GL_UNSIGNED_INT_SAMPLER_BUFFER_EXT, UNSIGNED_INT_SAMPLER_2D_RECT = GL_UNSIGNED_INT_SAMPLER_2D_RECT_EXT, IMAGE_1D = GL_IMAGE_1D, IMAGE_2D = GL_IMAGE_2D, IMAGE_3D = GL_IMAGE_3D, IMAGE_2D_RECT = GL_IMAGE_2D_RECT, IMAGE_CUBE = GL_IMAGE_CUBE, IMAGE_BUFFER = GL_IMAGE_BUFFER, IMAGE_1D_ARRAY = GL_IMAGE_1D_ARRAY, IMAGE_2D_ARRAY = GL_IMAGE_2D_ARRAY, IMAGE_CUBE_MAP_ARRAY = GL_IMAGE_CUBE_MAP_ARRAY, IMAGE_2D_MULTISAMPLE = GL_IMAGE_2D_MULTISAMPLE, IMAGE_2D_MULTISAMPLE_ARRAY = GL_IMAGE_2D_MULTISAMPLE_ARRAY, INT_IMAGE_1D = GL_INT_IMAGE_1D, INT_IMAGE_2D = GL_INT_IMAGE_2D, INT_IMAGE_3D = GL_INT_IMAGE_3D, INT_IMAGE_2D_RECT = GL_INT_IMAGE_2D_RECT, INT_IMAGE_CUBE = GL_INT_IMAGE_CUBE, INT_IMAGE_BUFFER = GL_INT_IMAGE_BUFFER, INT_IMAGE_1D_ARRAY = GL_INT_IMAGE_1D_ARRAY, INT_IMAGE_2D_ARRAY = GL_INT_IMAGE_2D_ARRAY, INT_IMAGE_CUBE_MAP_ARRAY = GL_INT_IMAGE_CUBE_MAP_ARRAY, INT_IMAGE_2D_MULTISAMPLE = GL_INT_IMAGE_2D_MULTISAMPLE, INT_IMAGE_2D_MULTISAMPLE_ARRAY = GL_INT_IMAGE_2D_MULTISAMPLE_ARRAY, UNSIGNED_INT_IMAGE_1D = GL_UNSIGNED_INT_IMAGE_1D, UNSIGNED_INT_IMAGE_2D = GL_UNSIGNED_INT_IMAGE_2D, UNSIGNED_INT_IMAGE_3D = GL_UNSIGNED_INT_IMAGE_3D, UNSIGNED_INT_IMAGE_2D_RECT = GL_UNSIGNED_INT_IMAGE_2D_RECT, UNSIGNED_INT_IMAGE_CUBE = GL_UNSIGNED_INT_IMAGE_CUBE, UNSIGNED_INT_IMAGE_BUFFER = GL_UNSIGNED_INT_IMAGE_BUFFER, UNSIGNED_INT_IMAGE_1D_ARRAY = GL_UNSIGNED_INT_IMAGE_1D_ARRAY, UNSIGNED_INT_IMAGE_2D_ARRAY = GL_UNSIGNED_INT_IMAGE_2D_ARRAY, UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY = GL_UNSIGNED_INT_IMAGE_CUBE_MAP_ARRAY, UNSIGNED_INT_IMAGE_2D_MULTISAMPLE = GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE, UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY = GL_UNSIGNED_INT_IMAGE_2D_MULTISAMPLE_ARRAY, UNDEFINED = 0x0 }; public: Uniform(); Uniform( Type type, const std::string& name, int numElements=1 ); /** Copy constructor using CopyOp to manage deep vs shallow copy. */ Uniform(const Uniform& rhs, const CopyOp& copyop=CopyOp::SHALLOW_COPY); META_Object(osg, Uniform); /** Set the type of glUniform, ensuring it is only set once.*/ bool setType( Type t ); /** Get the type of glUniform as enum. */ Type getType() const { return _type; } /** Set the name of the glUniform, ensuring it is only set once.*/ virtual void setName( const std::string& name ); /** Set the length of a uniform, ensuring it is only set once (1==scalar)*/ void setNumElements( unsigned int numElements ); /** Get the number of GLSL elements of the osg::Uniform (1==scalar) */ unsigned int getNumElements() const { return _numElements; } /** Get the number of elements required for the internal data array. * Returns 0 if the osg::Uniform is not properly configured. */ unsigned int getInternalArrayNumElements() const; /** Return the name of a Type enum as string. */ static const char* getTypename( Type t ); /** Return the the number of components for a GLSL type. */ static int getTypeNumComponents( Type t ); /** Return the Type enum of a Uniform typename string */ static Uniform::Type getTypeId( const std::string& tname ); /** Return the GL API type corresponding to a GLSL type */ static Type getGlApiType( Type t ); /** Return the internal data array type corresponding to a GLSL type */ static GLenum getInternalArrayType( Type t ); /** Return the number that the name maps to uniquely */ static unsigned int getNameID(const std::string& name); /** convenient scalar (non-array) constructors w/ assignment */ explicit Uniform( const char* name, float f ); explicit Uniform( const char* name, double d ); explicit Uniform( const char* name, int i ); explicit Uniform( const char* name, unsigned int ui ); explicit Uniform( const char* name, bool b ); Uniform( const char* name, const osg::Vec2& v2 ); Uniform( const char* name, const osg::Vec3& v3 ); Uniform( const char* name, const osg::Vec4& v4 ); Uniform( const char* name, const osg::Vec2d& v2 ); Uniform( const char* name, const osg::Vec3d& v3 ); Uniform( const char* name, const osg::Vec4d& v4 ); Uniform( const char* name, const osg::Matrix2& m2 ); Uniform( const char* name, const osg::Matrix3& m3 ); Uniform( const char* name, const osg::Matrixf& m4 ); Uniform( const char* name, const osg::Matrix2x3& m2x3 ); Uniform( const char* name, const osg::Matrix2x4& m2x4 ); Uniform( const char* name, const osg::Matrix3x2& m3x2 ); Uniform( const char* name, const osg::Matrix3x4& m3x4 ); Uniform( const char* name, const osg::Matrix4x2& m4x2 ); Uniform( const char* name, const osg::Matrix4x3& m4x3 ); Uniform( const char* name, const osg::Matrix2d& m2 ); Uniform( const char* name, const osg::Matrix3d& m3 ); Uniform( const char* name, const osg::Matrixd& m4 ); Uniform( const char* name, const osg::Matrix2x3d& m2x3 ); Uniform( const char* name, const osg::Matrix2x4d& m2x4 ); Uniform( const char* name, const osg::Matrix3x2d& m3x2 ); Uniform( const char* name, const osg::Matrix3x4d& m3x4 ); Uniform( const char* name, const osg::Matrix4x2d& m4x2 ); Uniform( const char* name, const osg::Matrix4x3d& m4x3 ); Uniform( const char* name, int i0, int i1 ); Uniform( const char* name, int i0, int i1, int i2 ); Uniform( const char* name, int i0, int i1, int i2, int i3 ); Uniform( const char* name, unsigned int ui0, unsigned int ui1 ); Uniform( const char* name, unsigned int ui0, unsigned int ui1, unsigned int ui2 ); Uniform( const char* name, unsigned int ui0, unsigned int ui1, unsigned int ui2, unsigned int ui3 ); Uniform( const char* name, bool b0, bool b1 ); Uniform( const char* name, bool b0, bool b1, bool b2 ); Uniform( const char* name, bool b0, bool b1, bool b2, bool b3 ); /** return -1 if *this < *rhs, 0 if *this==*rhs, 1 if *this>*rhs. */ virtual int compare(const Uniform& rhs) const; virtual int compareData(const Uniform& rhs) const; bool operator < (const Uniform& rhs) const { return compare(rhs)<0; } bool operator == (const Uniform& rhs) const { return compare(rhs)==0; } bool operator != (const Uniform& rhs) const { return compare(rhs)!=0; } void copyData( const Uniform& rhs ); /** A vector of osg::StateSet pointers which is used to store the parent(s) of this Uniform, the parents could be osg::Node or osg::Drawable.*/ typedef std::vector ParentList; /** Get the parent list of this Uniform. */ inline const ParentList& getParents() const { return _parents; } /** Get the a copy of parent list of node. A copy is returned to * prevent modification of the parent list.*/ inline ParentList getParents() { return _parents; } inline StateSet* getParent(unsigned int i) { return _parents[i]; } /** * Get a single const parent of this Uniform. * @param i index of the parent to get. * @return the parent i. */ inline const StateSet* getParent(unsigned int i) const { return _parents[i]; } /** * Get the number of parents of this Uniform. * @return the number of parents of this Uniform. */ inline unsigned int getNumParents() const { return static_cast(_parents.size()); } /** convenient scalar (non-array) value assignment */ bool set( float f ); bool set( double d ); bool set( int i ); bool set( unsigned int ui ); bool set( bool b ); bool set( const osg::Vec2& v2 ); bool set( const osg::Vec3& v3 ); bool set( const osg::Vec4& v4 ); bool set( const osg::Vec2d& v2 ); bool set( const osg::Vec3d& v3 ); bool set( const osg::Vec4d& v4 ); bool set( const osg::Matrix2& m2 ); bool set( const osg::Matrix3& m3 ); bool set( const osg::Matrixf& m4 ); bool set( const osg::Matrix2x3& m2x3 ); bool set( const osg::Matrix2x4& m2x4 ); bool set( const osg::Matrix3x2& m3x2 ); bool set( const osg::Matrix3x4& m3x4 ); bool set( const osg::Matrix4x2& m4x2 ); bool set( const osg::Matrix4x3& m4x3 ); bool set( const osg::Matrix2d& m2 ); bool set( const osg::Matrix3d& m3 ); bool set( const osg::Matrixd& m4 ); bool set( const osg::Matrix2x3d& m2x3 ); bool set( const osg::Matrix2x4d& m2x4 ); bool set( const osg::Matrix3x2d& m3x2 ); bool set( const osg::Matrix3x4d& m3x4 ); bool set( const osg::Matrix4x2d& m4x2 ); bool set( const osg::Matrix4x3d& m4x3 ); bool set( int i0, int i1 ); bool set( int i0, int i1, int i2 ); bool set( int i0, int i1, int i2, int i3 ); bool set( unsigned int ui0, unsigned int ui1 ); bool set( unsigned int ui0, unsigned int ui1, unsigned int ui2 ); bool set( unsigned int ui0, unsigned int ui1, unsigned int ui2, unsigned int ui3 ); bool set( bool b0, bool b1 ); bool set( bool b0, bool b1, bool b2 ); bool set( bool b0, bool b1, bool b2, bool b3 ); /** convenient scalar (non-array) value query */ bool get( float& f ) const; bool get( double& d ) const; bool get( int& i ) const; bool get( unsigned int& ui ) const; bool get( bool& b ) const; bool get( osg::Vec2& v2 ) const; bool get( osg::Vec3& v3 ) const; bool get( osg::Vec4& v4 ) const; bool get( osg::Vec2d& v2 ) const; bool get( osg::Vec3d& v3 ) const; bool get( osg::Vec4d& v4 ) const; bool get( osg::Matrix2& m2 ) const; bool get( osg::Matrix3& m3 ) const; bool get( osg::Matrixf& m4 ) const; bool get( osg::Matrix2x3& m2x3 ) const; bool get( osg::Matrix2x4& m2x4 ) const; bool get( osg::Matrix3x2& m3x2 ) const; bool get( osg::Matrix3x4& m3x4 ) const; bool get( osg::Matrix4x2& m4x2 ) const; bool get( osg::Matrix4x3& m4x3 ) const; bool get( osg::Matrix2d& m2 ) const; bool get( osg::Matrix3d& m3 ) const; bool get( osg::Matrixd& m4 ) const; bool get( osg::Matrix2x3d& m2x3 ) const; bool get( osg::Matrix2x4d& m2x4 ) const; bool get( osg::Matrix3x2d& m3x2 ) const; bool get( osg::Matrix3x4d& m3x4 ) const; bool get( osg::Matrix4x2d& m4x2 ) const; bool get( osg::Matrix4x3d& m4x3 ) const; bool get( int& i0, int& i1 ) const; bool get( int& i0, int& i1, int& i2 ) const; bool get( int& i0, int& i1, int& i2, int& i3 ) const; bool get( unsigned int& ui0, unsigned int& ui1 ) const; bool get( unsigned int& ui0, unsigned int& ui1, unsigned int& ui2 ) const; bool get( unsigned int& ui0, unsigned int& ui1, unsigned int& ui2, unsigned int& ui3 ) const; bool get( bool& b0, bool& b1 ) const; bool get( bool& b0, bool& b1, bool& b2 ) const; bool get( bool& b0, bool& b1, bool& b2, bool& b3 ) const; /** value assignment for array uniforms */ bool setElement( unsigned int index, float f ); bool setElement( unsigned int index, double d ); bool setElement( unsigned int index, int i ); bool setElement( unsigned int index, unsigned int ui ); bool setElement( unsigned int index, bool b ); bool setElement( unsigned int index, const osg::Vec2& v2 ); bool setElement( unsigned int index, const osg::Vec3& v3 ); bool setElement( unsigned int index, const osg::Vec4& v4 ); bool setElement( unsigned int index, const osg::Vec2d& v2 ); bool setElement( unsigned int index, const osg::Vec3d& v3 ); bool setElement( unsigned int index, const osg::Vec4d& v4 ); bool setElement( unsigned int index, const osg::Matrix2& m2 ); bool setElement( unsigned int index, const osg::Matrix3& m3 ); bool setElement( unsigned int index, const osg::Matrixf& m4 ); bool setElement( unsigned int index, const osg::Matrix2x3& m2x3 ); bool setElement( unsigned int index, const osg::Matrix2x4& m2x4 ); bool setElement( unsigned int index, const osg::Matrix3x2& m3x2 ); bool setElement( unsigned int index, const osg::Matrix3x4& m3x4 ); bool setElement( unsigned int index, const osg::Matrix4x2& m4x2 ); bool setElement( unsigned int index, const osg::Matrix4x3& m4x3 ); bool setElement( unsigned int index, const osg::Matrix2d& m2 ); bool setElement( unsigned int index, const osg::Matrix3d& m3 ); bool setElement( unsigned int index, const osg::Matrixd& m4 ); bool setElement( unsigned int index, const osg::Matrix2x3d& m2x3 ); bool setElement( unsigned int index, const osg::Matrix2x4d& m2x4 ); bool setElement( unsigned int index, const osg::Matrix3x2d& m3x2 ); bool setElement( unsigned int index, const osg::Matrix3x4d& m3x4 ); bool setElement( unsigned int index, const osg::Matrix4x2d& m4x2 ); bool setElement( unsigned int index, const osg::Matrix4x3d& m4x3 ); bool setElement( unsigned int index, int i0, int i1 ); bool setElement( unsigned int index, int i0, int i1, int i2 ); bool setElement( unsigned int index, int i0, int i1, int i2, int i3 ); bool setElement( unsigned int index, unsigned int ui0, unsigned int ui1 ); bool setElement( unsigned int index, unsigned int ui0, unsigned int ui1, unsigned int ui2 ); bool setElement( unsigned int index, unsigned int ui0, unsigned int ui1, unsigned int ui2, unsigned int ui3 ); bool setElement( unsigned int index, bool b0, bool b1 ); bool setElement( unsigned int index, bool b0, bool b1, bool b2 ); bool setElement( unsigned int index, bool b0, bool b1, bool b2, bool b3 ); /** value query for array uniforms */ bool getElement( unsigned int index, float& f ) const; bool getElement( unsigned int index, double& d ) const; bool getElement( unsigned int index, int& i ) const; bool getElement( unsigned int index, unsigned int& ui ) const; bool getElement( unsigned int index, bool& b ) const; bool getElement( unsigned int index, osg::Vec2& v2 ) const; bool getElement( unsigned int index, osg::Vec3& v3 ) const; bool getElement( unsigned int index, osg::Vec4& v4 ) const; bool getElement( unsigned int index, osg::Vec2d& v2 ) const; bool getElement( unsigned int index, osg::Vec3d& v3 ) const; bool getElement( unsigned int index, osg::Vec4d& v4 ) const; bool getElement( unsigned int index, osg::Matrix2& m2 ) const; bool getElement( unsigned int index, osg::Matrix3& m3 ) const; bool getElement( unsigned int index, osg::Matrixf& m4 ) const; bool getElement( unsigned int index, osg::Matrix2x3& m2x3 ) const; bool getElement( unsigned int index, osg::Matrix2x4& m2x4 ) const; bool getElement( unsigned int index, osg::Matrix3x2& m3x2 ) const; bool getElement( unsigned int index, osg::Matrix3x4& m3x4 ) const; bool getElement( unsigned int index, osg::Matrix4x2& m4x2 ) const; bool getElement( unsigned int index, osg::Matrix4x3& m4x3 ) const; bool getElement( unsigned int index, osg::Matrix2d& m2 ) const; bool getElement( unsigned int index, osg::Matrix3d& m3 ) const; bool getElement( unsigned int index, osg::Matrixd& m4 ) const; bool getElement( unsigned int index, osg::Matrix2x3d& m2x3 ) const; bool getElement( unsigned int index, osg::Matrix2x4d& m2x4 ) const; bool getElement( unsigned int index, osg::Matrix3x2d& m3x2 ) const; bool getElement( unsigned int index, osg::Matrix3x4d& m3x4 ) const; bool getElement( unsigned int index, osg::Matrix4x2d& m4x2 ) const; bool getElement( unsigned int index, osg::Matrix4x3d& m4x3 ) const; bool getElement( unsigned int index, int& i0, int& i1 ) const; bool getElement( unsigned int index, int& i0, int& i1, int& i2 ) const; bool getElement( unsigned int index, int& i0, int& i1, int& i2, int& i3 ) const; bool getElement( unsigned int index, unsigned int& ui0, unsigned int& ui1 ) const; bool getElement( unsigned int index, unsigned int& ui0, unsigned int& ui1, unsigned int& ui2 ) const; bool getElement( unsigned int index, unsigned int& ui0, unsigned int& ui1, unsigned int& ui2, unsigned int& ui3 ) const; bool getElement( unsigned int index, bool& b0, bool& b1 ) const; bool getElement( unsigned int index, bool& b0, bool& b1, bool& b2 ) const; bool getElement( unsigned int index, bool& b0, bool& b1, bool& b2, bool& b3 ) const; struct Callback : public virtual osg::Object { Callback() {} Callback(const Callback&,const CopyOp&) {} META_Object(osg,Callback); /** do customized update code.*/ virtual void operator () (Uniform*, NodeVisitor*) {} }; /** Set the UpdateCallback which allows users to attach customize the updating of an object during the update traversal.*/ void setUpdateCallback(Callback* uc); /** Get the non const UpdateCallback.*/ Callback* getUpdateCallback() { return _updateCallback.get(); } /** Get the const UpdateCallback.*/ const Callback* getUpdateCallback() const { return _updateCallback.get(); } /** Set the EventCallback which allows users to attach customize the updating of an object during the Event traversal.*/ void setEventCallback(Callback* ec); /** Get the non const EventCallback.*/ Callback* getEventCallback() { return _eventCallback.get(); } /** Get the const EventCallback.*/ const Callback* getEventCallback() const { return _eventCallback.get(); } /** Increment the modified count on the Uniform so Programs watching it know it update themselves. * NOTE: automatically called during osg::Uniform::set*(); * you must call if modifying the internal data array directly. */ inline void dirty() { ++_modifiedCount; } /** Set the internal data array for a osg::Uniform */ bool setArray( FloatArray* array ); bool setArray( DoubleArray* array ); bool setArray( IntArray* array ); bool setArray( UIntArray* array ); /** Get the internal data array for a float osg::Uniform. */ FloatArray* getFloatArray() { return _floatArray.get(); } const FloatArray* getFloatArray() const { return _floatArray.get(); } /** Get the internal data array for a double osg::Uniform. */ DoubleArray* getDoubleArray() { return _doubleArray.get(); } const DoubleArray* getDoubleArray() const { return _doubleArray.get(); } /** Get the internal data array for an int osg::Uniform. */ IntArray* getIntArray() { return _intArray.get(); } const IntArray* getIntArray() const { return _intArray.get(); } /** Get the internal data array for an unsigned int osg::Uniform. */ UIntArray* getUIntArray() { return _uintArray.get(); } const UIntArray* getUIntArray() const { return _uintArray.get(); } inline void setModifiedCount(unsigned int mc) { _modifiedCount = mc; } inline unsigned int getModifiedCount() const { return _modifiedCount; } /** Get the number that the Uniform's name maps to uniquely */ unsigned int getNameID() const; void apply(const GL2Extensions* ext, GLint location) const; protected: virtual ~Uniform(); Uniform& operator=(const Uniform&) { return *this; } bool isCompatibleType( Type t ) const; // for backward compatibility only // see getElement(index, osg::Matrixd &) // see setElement(index, osg::Matrixd &) bool isCompatibleType( Type t1, Type t2 ) const; bool isScalar() const { return _numElements==1; } void allocateDataArray(); void addParent(osg::StateSet* object); void removeParent(osg::StateSet* object); ParentList _parents; friend class osg::StateSet; Type _type; unsigned int _numElements; unsigned int _nameID; // The internal data for osg::Uniforms are stored as an array of // getInternalArrayType() of length getInternalArrayNumElements(). ref_ptr _floatArray; ref_ptr _doubleArray; ref_ptr _intArray; ref_ptr _uintArray; ref_ptr _updateCallback; ref_ptr _eventCallback; unsigned int _modifiedCount; }; } #endif