| OZ++ Class: OpenGLVertexAttribute |
/******************************************************************************
*
* Copyright (c) 2016 Antillia.com TOSHIYUKI ARAI. ALL RIGHTS RESERVED.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer.
*
* 2. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*
* OpenGLVertexAttribute.h
*
*****************************************************************************/
#pragma once
#include <oz++/opengl/OpenGLObject.h>
#include <oz++/opengl2/OpenGLProgram.h>
namespace OZ {
class OpenGLVertexAttribute : public OpenGLObject {
#ifdef GL_VERSION_2_0
private:
GLuint index;
bool enable;
public:
OpenGLVertexAttribute(GLuint in, bool onoff=true)
:OpenGLObject(),
index(in),
enable(onoff)
{
if (index < 0) {
throw IException("Invalid attribute index:%d", index);
}
if (enable) {
enableArray();
}
}
~OpenGLVertexAttribute()
{
if (enable) {
disableArray();
}
}
public:
void disableArray()
{
static PFNGLDISABLEVERTEXATTRIBARRAYPROC glDisableVertexAttribArray = NULL;
if (glDisableVertexAttribArray == NULL) {
glDisableVertexAttribArray = (PFNGLDISABLEVERTEXATTRIBARRAYPROC)load("glDisableVertexAttribArray");
}
glDisableVertexAttribArray(index);
}
//PFNGLDRAWBUFFERSPROC GlewBuffers::glDrawBuffers; //(GLsizei n, const GLenum* bufs);
void enableArray()
{
static PFNGLENABLEVERTEXATTRIBARRAYPROC glEnableVertexAttribArray = NULL;
if (glEnableVertexAttribArray == NULL) {
glEnableVertexAttribArray = (PFNGLENABLEVERTEXATTRIBARRAYPROC)load("glEnableVertexAttribArray");
}
glEnableVertexAttribArray(index);
}
void getPointer(GLenum pname, void** pointer)
{
if (pointer == NULL) {
throw IException("Invalid pointer parameter.");
}
static PFNGLGETVERTEXATTRIBPOINTERVPROC glGetVertexAttribPointerv = NULL;
if (glGetVertexAttribPointerv == NULL) {
glGetVertexAttribPointerv = (PFNGLGETVERTEXATTRIBPOINTERVPROC)load("glGetVertexAttribPointerv");
}
glGetVertexAttribPointerv(index, pname, pointer);
}
void get(GLenum pname, GLdouble* params)
{
if (params == NULL) {
throw IException("Invalid parameter.");
}
static PFNGLGETVERTEXATTRIBDVPROC glGetVertexAttribdv = NULL;
if (glGetVertexAttribdv == NULL) {
glGetVertexAttribdv = (PFNGLGETVERTEXATTRIBDVPROC)load("glGetVertexAttribdv");
}
glGetVertexAttribdv(index, pname, params);
}
void get(GLenum pname, GLfloat* params)
{
if (params == NULL) {
throw IException("Invalid parameter.");
}
static PFNGLGETVERTEXATTRIBFVPROC glGetVertexAttribfv = NULL;
if (glGetVertexAttribfv == NULL) {
glGetVertexAttribfv = (PFNGLGETVERTEXATTRIBFVPROC)load("glGetVertexAttribfv");
}
glGetVertexAttribfv(index, pname, params);
}
void get(GLenum pname, GLint* params)
{
if (params == NULL) {
throw IException("Invalid parameter.");
}
static PFNGLGETVERTEXATTRIBIVPROC glGetVertexAttribiv = NULL;
if (glGetVertexAttribiv == NULL) {
glGetVertexAttribiv = (PFNGLGETVERTEXATTRIBIVPROC)load("glGetVertexAttribiv");
}
glGetVertexAttribiv(index, pname, params);
}
void set(GLdouble x)
{
static PFNGLVERTEXATTRIB1DPROC glVertexAttrib1d = NULL;
if (glVertexAttrib1d == NULL) {
glVertexAttrib1d = (PFNGLVERTEXATTRIB1DPROC)load("glVertexAttrib1d");
}
glVertexAttrib1d(index, x);
}
//<added date="2016/08/20">
void set(const GLdouble* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size < 1 || size > 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 1:
set1(v);
break;
case 2:
set2(v);
break;
case 3:
set3(v);
break;
case 4:
set4(v);
break;
}
}
void set(const GLfloat* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size < 1 || size > 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 1:
set1(v);
break;
case 2:
set2(v);
break;
case 3:
set3(v);
break;
case 4:
set4(v);
break;
}
}
void set(const GLbyte* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
set4(v);
break;
}
}
void set(const GLubyte* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
set4(v);
break;
}
}
void set(const GLushort* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
set4(v);
break;
}
}
void set(const GLshort* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size < 1 || size > 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 1:
set1(v);
break;
case 2:
set2(v);
break;
case 3:
set3(v);
break;
case 4:
set4(v);
break;
}
}
void set(const GLint* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
set4(v);
break;
}
}
//</added>
void set1(const GLdouble* v)
{
static PFNGLVERTEXATTRIB1DVPROC glVertexAttrib1dv = NULL;
if (glVertexAttrib1dv == NULL) {
glVertexAttrib1dv = (PFNGLVERTEXATTRIB1DVPROC)load("glVertexAttrib1dv");
}
glVertexAttrib1dv(index, v);
}
void set(GLfloat x)
{
static PFNGLVERTEXATTRIB1FPROC glVertexAttrib1f = NULL;
if (glVertexAttrib1f == NULL) {
glVertexAttrib1f = (PFNGLVERTEXATTRIB1FPROC)load("glVertexAttrib1f");
}
glVertexAttrib1f(index, x);
}
void set1(const GLfloat* v)
{
static PFNGLVERTEXATTRIB1FVPROC glVertexAttrib1fv = NULL;
if (glVertexAttrib1fv == NULL) {
glVertexAttrib1fv = (PFNGLVERTEXATTRIB1FVPROC)load("glVertexAttrib1fv");
}
glVertexAttrib1fv(index, v);
}
void set(GLshort x)
{
static PFNGLVERTEXATTRIB1SPROC glVertexAttrib1s = NULL;
if (glVertexAttrib1s == NULL) {
glVertexAttrib1s = (PFNGLVERTEXATTRIB1SPROC)load("glVertexAttrib1s");
}
glVertexAttrib1s(index, x);
}
void set1(const GLshort* v)
{
static PFNGLVERTEXATTRIB1SVPROC glVertexAttrib1sv = NULL;
if (glVertexAttrib1sv == NULL) {
glVertexAttrib1sv = (PFNGLVERTEXATTRIB1SVPROC)load("glVertexAttrib1sv");
}
glVertexAttrib1sv(index, v);
}
void set(GLdouble x, GLdouble y)
{
static PFNGLVERTEXATTRIB2DPROC glVertexAttrib2d = NULL;
if (glVertexAttrib2d == NULL) {
glVertexAttrib2d = (PFNGLVERTEXATTRIB2DPROC)load("glVertexAttrib2d");
}
glVertexAttrib2d(index, x, y);
}
void set2(const GLdouble* v)
{
static PFNGLVERTEXATTRIB2DVPROC glVertexAttrib2dv = NULL;
if (glVertexAttrib2dv == NULL) {
glVertexAttrib2dv = (PFNGLVERTEXATTRIB2DVPROC)load("glVertexAttrib2dv");
}
glVertexAttrib2dv(index, v);
}
void set(GLfloat x, GLfloat y)
{
static PFNGLVERTEXATTRIB2FPROC glVertexAttrib2f = NULL;
if (glVertexAttrib2f = NULL) {
glVertexAttrib2f = (PFNGLVERTEXATTRIB2FPROC)load("glVertexAttrib2f");
}
glVertexAttrib2f(index, x, y);
}
void set2(const GLfloat* v)
{
static PFNGLVERTEXATTRIB2FVPROC glVertexAttrib2fv = NULL;
if (glVertexAttrib2fv == NULL) {
glVertexAttrib2fv = (PFNGLVERTEXATTRIB2FVPROC)load("glVertexAttrib2fv");
}
glVertexAttrib2fv(index, v);
}
void set(GLshort x, GLshort y)
{
static PFNGLVERTEXATTRIB2SPROC glVertexAttrib2s = NULL;
if (glVertexAttrib2s == NULL) {
glVertexAttrib2s = (PFNGLVERTEXATTRIB2SPROC)load("glVertexAttrib2s");
}
glVertexAttrib2s(index, x, y);
}
void set2(const GLshort* v)
{
static PFNGLVERTEXATTRIB2SVPROC glVertexAttrib2sv = NULL;
if (glVertexAttrib2sv == NULL) {
glVertexAttrib2sv = (PFNGLVERTEXATTRIB2SVPROC)load("glVertexAttrib2sv");
}
glVertexAttrib2sv(index, v);
}
void set(GLdouble x, GLdouble y, GLdouble z)
{
static PFNGLVERTEXATTRIB3DPROC glVertexAttrib3d = NULL;
if (glVertexAttrib3d == NULL) {
glVertexAttrib3d = (PFNGLVERTEXATTRIB3DPROC)load("glVertexAttrib3d");
}
glVertexAttrib3d(index, x, y, z);
}
void set3(const GLdouble* v)
{
static PFNGLVERTEXATTRIB3DVPROC glVertexAttrib3dv = NULL;
if (glVertexAttrib3dv == NULL) {
glVertexAttrib3dv = (PFNGLVERTEXATTRIB3DVPROC)load("glVertexAttrib3dv");
}
glVertexAttrib3dv(index, v);
}
void set(GLfloat x, GLfloat y, GLfloat z)
{
static PFNGLVERTEXATTRIB3FPROC glVertexAttrib3f = NULL;
if (glVertexAttrib3f == NULL) {
glVertexAttrib3f = (PFNGLVERTEXATTRIB3FPROC)load("glVertexAttrib3f");
}
glVertexAttrib3f(index, x, y, z);
}
void set3(const GLfloat* v)
{
static PFNGLVERTEXATTRIB3FVPROC glVertexAttrib3fv = NULL;
if (glVertexAttrib3fv == NULL) {
glVertexAttrib3fv = (PFNGLVERTEXATTRIB3FVPROC)load("glVertexAttrib3fv");
}
glVertexAttrib3fv(index, v);
}
void set(GLshort x, GLshort y, GLshort z)
{
static PFNGLVERTEXATTRIB3SPROC glVertexAttrib3s = NULL;
if (glVertexAttrib3s == NULL) {
glVertexAttrib3s = (PFNGLVERTEXATTRIB3SPROC)load("glVertexAttrib3s");
}
glVertexAttrib3s(index, x, y, z);
}
void set3(const GLshort* v)
{
static PFNGLVERTEXATTRIB3SVPROC glVertexAttrib3sv = NULL;
if (glVertexAttrib3sv == NULL) {
glVertexAttrib3sv = (PFNGLVERTEXATTRIB3SVPROC)load("glVertexAttrib3sv");
}
glVertexAttrib3sv(index, v);
}
void set4N(const GLbyte* v)
{
static PFNGLVERTEXATTRIB4NBVPROC glVertexAttrib4Nbv = NULL;
if (glVertexAttrib4Nbv == NULL) {
glVertexAttrib4Nbv = (PFNGLVERTEXATTRIB4NBVPROC)load("glVertexAttrib4Nbv");
}
glVertexAttrib4Nbv(index, v);
}
void set4N(const GLint* v)
{
static PFNGLVERTEXATTRIB4NIVPROC glVertexAttrib4Niv = NULL;
if (glVertexAttrib4Niv == NULL) {
glVertexAttrib4Niv = (PFNGLVERTEXATTRIB4NIVPROC)load("glVertexAttrib4Niv");
}
glVertexAttrib4Niv(index, v);
}
void set4N(const GLshort* v)
{
static PFNGLVERTEXATTRIB4NSVPROC glVertexAttrib4Nsv = NULL;
if (glVertexAttrib4Nsv == NULL) {
glVertexAttrib4Nsv = (PFNGLVERTEXATTRIB4NSVPROC)load("glVertexAttrib4Nsv");
}
glVertexAttrib4Nsv(index, v);
}
void set(GLubyte x, GLubyte y, GLubyte z, GLubyte w)
{
static PFNGLVERTEXATTRIB4NUBPROC glVertexAttrib4Nub = NULL;
if (glVertexAttrib4Nub == NULL) {
glVertexAttrib4Nub = (PFNGLVERTEXATTRIB4NUBPROC)load("glVertexAttrib4Nub");
}
glVertexAttrib4Nub(index, x, y, z, w);
}
void set4N(const GLubyte* v)
{
static PFNGLVERTEXATTRIB4NUBVPROC glVertexAttrib4Nubv = NULL;
if (glVertexAttrib4Nubv == NULL) {
glVertexAttrib4Nubv = (PFNGLVERTEXATTRIB4NUBVPROC)load("glVertexAttrib4Nubv");
}
glVertexAttrib4Nubv(index, v);
}
void set4N(const GLuint* v)
{
static PFNGLVERTEXATTRIB4NUIVPROC glVertexAttrib4Nuiv = NULL;
if (glVertexAttrib4Nuiv == NULL) {
glVertexAttrib4Nuiv = (PFNGLVERTEXATTRIB4NUIVPROC)load("glVertexAttrib4Nuiv");
}
glVertexAttrib4Nuiv(index, v);
}
void set4N(const GLushort* v)
{
static PFNGLVERTEXATTRIB4NUSVPROC glVertexAttrib4Nusv = NULL;
if (glVertexAttrib4Nusv == NULL) {
glVertexAttrib4Nusv = (PFNGLVERTEXATTRIB4NUSVPROC)load("glVertexAttrib4Nusv");
}
glVertexAttrib4Nusv(index, v);
}
void set4(const GLbyte* v)
{
static PFNGLVERTEXATTRIB4BVPROC glVertexAttrib4bv = NULL;
if (glVertexAttrib4bv == NULL) {
glVertexAttrib4bv = (PFNGLVERTEXATTRIB4BVPROC)load("glVertexAttrib4bv");
}
glVertexAttrib4bv(index, v);
}
void set(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
static PFNGLVERTEXATTRIB4DPROC glVertexAttrib4d = NULL;
if (glVertexAttrib4d == NULL) {
glVertexAttrib4d = (PFNGLVERTEXATTRIB4DPROC)load("glVertexAttrib4d");
}
glVertexAttrib4d(index, x, y, z, w);
}
void set4(const GLdouble* v)
{
static PFNGLVERTEXATTRIB4DVPROC glVertexAttrib4dv = NULL;
if (glVertexAttrib4dv == NULL) {
glVertexAttrib4dv = (PFNGLVERTEXATTRIB4DVPROC)load("glVertexAttrib4dv");
}
glVertexAttrib4dv(index, v);
}
void set(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
static PFNGLVERTEXATTRIB4FPROC glVertexAttrib4f = NULL;
if (glVertexAttrib4f == NULL) {
glVertexAttrib4f = (PFNGLVERTEXATTRIB4FPROC)load("glVertexAttrib4f");
}
glVertexAttrib4f(index, x, y, z, w);
}
void set4(const GLfloat* v)
{
static PFNGLVERTEXATTRIB4FVPROC glVertexAttrib4fv = NULL;
if (glVertexAttrib4fv == NULL) {
glVertexAttrib4fv = (PFNGLVERTEXATTRIB4FVPROC)load("glVertexAttrib4fv");
}
glVertexAttrib4fv(index, v);
}
void set4(const GLint* v)
{
static PFNGLVERTEXATTRIB4IVPROC glVertexAttrib4iv = NULL;
if (glVertexAttrib4iv == NULL) {
glVertexAttrib4iv = (PFNGLVERTEXATTRIB4IVPROC)load("glVertexAttrib4iv");
}
glVertexAttrib4iv(index, v);
}
void set(GLshort x, GLshort y, GLshort z, GLshort w)
{
static PFNGLVERTEXATTRIB4SPROC glVertexAttrib4s = NULL;
if (glVertexAttrib4s == NULL) {
glVertexAttrib4s = (PFNGLVERTEXATTRIB4SPROC)load("glVertexAttrib4s");
}
glVertexAttrib4s(index, x, y, z, w);
}
void set4(const GLshort* v)
{
static PFNGLVERTEXATTRIB4SVPROC glVertexAttrib4sv = NULL;
if (glVertexAttrib4sv == NULL) {
glVertexAttrib4sv = (PFNGLVERTEXATTRIB4SVPROC)load("glVertexAttrib4sv");
}
glVertexAttrib4sv(index, v);
}
void set4(const GLubyte* v)
{
static PFNGLVERTEXATTRIB4UBVPROC glVertexAttrib4ubv = NULL;
if (glVertexAttrib4ubv == NULL) {
glVertexAttrib4ubv = (PFNGLVERTEXATTRIB4UBVPROC)load("glVertexAttrib4ubv");
}
glVertexAttrib4ubv(index, v);
}
void set4(const GLuint* v)
{
static PFNGLVERTEXATTRIB4UIVPROC glVertexAttrib4uiv = NULL;
if (glVertexAttrib4uiv == NULL) {
glVertexAttrib4uiv = (PFNGLVERTEXATTRIB4UIVPROC)load("glVertexAttrib4uiv");
}
glVertexAttrib4uiv(index, v);
}
void set4(const GLushort* v)
{
static PFNGLVERTEXATTRIB4USVPROC glVertexAttrib4usv = NULL;
if (glVertexAttrib4usv == NULL) {
glVertexAttrib4usv = (PFNGLVERTEXATTRIB4USVPROC)load("glVertexAttrib4usv");
}
glVertexAttrib4usv(index, v);
}
void setPointer(GLint size, GLenum type, GLboolean normalized, GLsizei stride, const void* pointer)
{
static PFNGLVERTEXATTRIBPOINTERPROC glVertexAttribPointer = NULL;
if (glVertexAttribPointer == NULL) {
glVertexAttribPointer = (PFNGLVERTEXATTRIBPOINTERPROC)load("glVertexAttribPointer");
}
glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}
#endif
//<added date="2016/08/20">
#ifdef GL_VERSION_3_0
void getI(GLenum pname, GLint* params)
{
static PFNGLGETVERTEXATTRIBIIVPROC glGetVertexAttribIiv = NULL;
if (glGetVertexAttribIiv == NULL) {
glGetVertexAttribIiv = (PFNGLGETVERTEXATTRIBIIVPROC)load("glGetVertexAttribIiv");
}
glGetVertexAttribIiv(index, pname, params);
}
void getI(GLenum pname, GLuint* params)
{
static PFNGLGETVERTEXATTRIBIUIVPROC glGetVertexAttribIuiv = NULL;
if (glGetVertexAttribIuiv == NULL) {
glGetVertexAttribIuiv = (PFNGLGETVERTEXATTRIBIUIVPROC)load("glGetVertexAttribIuiv");
}
glGetVertexAttribIuiv(index, pname, params);
}
void setI(const GLint* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size <= 0 || size >4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 1:
setI1(v);
break;
case 2:
setI2(v);
break;
case 3:
setI3(v);
break;
case 4:
setI4(v);
break;
default:
break;
}
}
void setI(const GLuint* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size <= 0 || size >4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 1:
setI1(v);
break;
case 2:
setI2(v);
break;
case 3:
setI3(v);
break;
case 4:
setI4(v);
break;
default:
break;
}
}
void setI(const GLushort* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
setI4(v);
break;
default:
break;
}
}
void setI(const GLshort* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
setI4(v);
break;
default:
break;
}
}
void setI(const GLubyte* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
setI4(v);
break;
default:
break;
}
}
void setI(const GLbyte* v, size_t size)
{
if (v == NULL) {
throw IException("Invalid value parameter.");
}
if (size != 4) {
throw IException("Invalid size parameter.");
}
switch(size) {
case 4:
setI4(v);
break;
default:
break;
}
}
void setI1(GLint v0)
{
static PFNGLVERTEXATTRIBI1IPROC glVertexAttribI1i = NULL;
if (glVertexAttribI1i == NULL) {
glVertexAttribI1i = (PFNGLVERTEXATTRIBI1IPROC)load("glVertexAttribI1i");
}
glVertexAttribI1i(index, v0);
}
void setI1(const GLint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI1IVPROC glVertexAttribI1iv = NULL;
if (glVertexAttribI1iv == NULL) {
glVertexAttribI1iv = (PFNGLVERTEXATTRIBI1IVPROC)load("glVertexAttribI1iv");
}
glVertexAttribI1iv(index, v0);
}
void setI1(GLuint v0)
{
static PFNGLVERTEXATTRIBI1UIPROC glVertexAttribI1ui = NULL;
if (glVertexAttribI1ui == NULL) {
glVertexAttribI1ui = (PFNGLVERTEXATTRIBI1UIPROC)load("glVertexAttribI1ui");
}
glVertexAttribI1ui(index, v0);
}
void setI1(const GLuint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI1UIVPROC glVertexAttribI1uiv = NULL;
if (glVertexAttribI1uiv == NULL) {
glVertexAttribI1uiv = (PFNGLVERTEXATTRIBI1UIVPROC)load("glVertexAttribI1uiv");
}
glVertexAttribI1uiv(index, v0);
}
void setI2(GLint v0, GLint v1)
{
static PFNGLVERTEXATTRIBI2IPROC glVertexAttribI2i = NULL;
if (glVertexAttribI2i == NULL) {
glVertexAttribI2i = (PFNGLVERTEXATTRIBI2IPROC)load("glVertexAttribI2i");
}
glVertexAttribI2i(index, v0, v1);
}
void setI2(const GLint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI2IVPROC glVertexAttribI2iv = NULL;
if (glVertexAttribI2iv == NULL) {
glVertexAttribI2iv = (PFNGLVERTEXATTRIBI2IVPROC)load("glVertexAttribI2iv");
}
glVertexAttribI2iv(index, v0);
}
void setI2(GLuint v0, GLuint v1)
{
static PFNGLVERTEXATTRIBI2UIPROC glVertexAttribI2u = NULL;
if (glVertexAttribI2u == NULL) {
glVertexAttribI2u = (PFNGLVERTEXATTRIBI2UIPROC)load("glVertexAttribI2u");
}
glVertexAttribI2u(index, v0, v1);
}
void setI2(const GLuint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI2UIVPROC glVertexAttribI2uiv = NULL;
if (glVertexAttribI2uiv == NULL) {
glVertexAttribI2uiv = (PFNGLVERTEXATTRIBI2UIVPROC)load("glVertexAttribI2uiv");
}
glVertexAttribI2uiv(index, v0);
}
void setI3(GLint v0, GLint v1, GLint v2)
{
static PFNGLVERTEXATTRIBI3IPROC glVertexAttribI3i = NULL;
if (glVertexAttribI3i == NULL) {
glVertexAttribI3i = (PFNGLVERTEXATTRIBI3IPROC)load("glVertexAttribI3i");
}
glVertexAttribI3i(index, v0, v1, v2);
}
void setI3(const GLint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI3IVPROC glVertexAttribI3iv = NULL;
if (glVertexAttribI3iv == NULL) {
glVertexAttribI3iv = (PFNGLVERTEXATTRIBI3IVPROC)load("glVertexAttribI3iv");
}
glVertexAttribI3iv(index, v0);
}
void setI3(GLuint v0, GLuint v1, GLuint v2)
{
static PFNGLVERTEXATTRIBI3UIPROC glVertexAttribI3ui = NULL;
if (glVertexAttribI3ui == NULL) {
glVertexAttribI3ui = (PFNGLVERTEXATTRIBI3UIPROC)load("glVertexAttribI3ui");
}
glVertexAttribI3ui(index, v0, v1, v2);
}
void setI3(const GLuint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI3UIVPROC glVertexAttribI3uiv = NULL;
if (glVertexAttribI3uiv == NULL) {
glVertexAttribI3uiv = (PFNGLVERTEXATTRIBI3UIVPROC)load("glVertexAttribI3uiv");
}
glVertexAttribI3uiv(index, v0);
}
void setI4(const GLbyte* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI4BVPROC glVertexAttribI4bv = NULL;
if (glVertexAttribI4bv == NULL) {
glVertexAttribI4bv = (PFNGLVERTEXATTRIBI4BVPROC)load("glVertexAttribI4bv");
}
glVertexAttribI4bv(index, v0);
}
void setI4(GLint v0, GLint v1, GLint v2, GLint v3)
{
static PFNGLVERTEXATTRIBI4IPROC glVertexAttribI4i = NULL;
if (glVertexAttribI4i == NULL) {
glVertexAttribI4i = (PFNGLVERTEXATTRIBI4IPROC)load("glVertexAttribI4i");
}
glVertexAttribI4i(index, v0, v1, v2, v3);
}
void setI4(const GLint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI4IVPROC glVertexAttribI4iv = NULL;
if (glVertexAttribI4iv == NULL) {
glVertexAttribI4iv = (PFNGLVERTEXATTRIBI4IVPROC)load("glVertexAttribI4iv");
}
glVertexAttribI4iv(index, v0);
}
void setI4(const GLshort* v0)
{
static PFNGLVERTEXATTRIBI4SVPROC glVertexAttribI4sv = NULL;
if (glVertexAttribI4sv == NULL) {
glVertexAttribI4sv = (PFNGLVERTEXATTRIBI4SVPROC)load("glVertexAttribI4sv");
}
glVertexAttribI4sv(index, v0);
}
void setI4(const GLubyte* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI4UBVPROC glVertexAttribI4ubv = NULL;
if (glVertexAttribI4ubv == NULL) {
glVertexAttribI4ubv = (PFNGLVERTEXATTRIBI4UBVPROC)load("glVertexAttribI4ubv");
}
glVertexAttribI4ubv(index, v0);
}
void setI4(GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
static PFNGLVERTEXATTRIBI4UIPROC glVertexAttribI4ui = NULL;
if (glVertexAttribI4ui == NULL) {
glVertexAttribI4ui = (PFNGLVERTEXATTRIBI4UIPROC)load("glVertexAttribI4ui");
}
glVertexAttribI4ui(index, v0, v1, v2, v3);
}
void setI4(const GLuint* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
\
static PFNGLVERTEXATTRIBI4UIVPROC glVertexAttribI4uiv = NULL;
if (glVertexAttribI4uiv == NULL) {
glVertexAttribI4uiv = (PFNGLVERTEXATTRIBI4UIVPROC)load("glVertexAttribI4uiv");
}
glVertexAttribI4uiv(index, v0);
}
void setI4(const GLushort* v0)
{
if (v0 == NULL) {
throw IException("Invalid value parameter.");
}
static PFNGLVERTEXATTRIBI4USVPROC glVertexAttribI4usv = NULL;
if (glVertexAttribI4usv == NULL) {
glVertexAttribI4usv = (PFNGLVERTEXATTRIBI4USVPROC)load("glVertexAttribI4usv");
}
glVertexAttribI4usv(index, v0);
}
void setPointer(GLint size, GLenum type, GLsizei stride, const void* pointer)
{
if (pointer == NULL) {
throw IException("Invalid pointer parameter.");
}
static PFNGLVERTEXATTRIBIPOINTERPROC glVertexAttribIPointer = NULL;
if (glVertexAttribIPointer == NULL) {
glVertexAttribIPointer = (PFNGLVERTEXATTRIBIPOINTERPROC)load("glVertexAttribIPointer");
}
glVertexAttribIPointer(index, size, type, stride, pointer);
}
//</added>
#endif
#ifdef GL_VERSION_3_3
void divisor(GLuint div)
{
static PFNGLVERTEXATTRIBDIVISORPROC glVertexAttribDivisor = NULL;
if (glVertexAttribDivisor == NULL) {
glVertexAttribDivisor = (PFNGLVERTEXATTRIBDIVISORPROC)load("glVertexAttribDivisor");
}
glVertexAttribDivisor(index, div);
}
#endif
};
}