void APIENTRY FWGLExtension::initSampleCoverage(GLclampf value, GLboolean invert)
{
spSampleCoverage = (PFNGLSAMPLECOVERAGE)FW_GETGLPROC("glSampleCoverage");
if(!spSampleCoverage)
reportError("glSampleCoverage");
glSampleCoverage(value, invert);
}
static int SampleCoverage(lua_State *L)
{
GLfloat value = luaL_checknumber(L, 1);
GLboolean invert = checkboolean(L, 2);
glSampleCoverage(value, invert);
CheckError(L);
return 0;
}
inline void VL_glSampleCoverage( GLclampf value, GLboolean invert)
{
if (glSampleCoverage)
glSampleCoverage(value,invert);
else
if (glSampleCoverageARB)
glSampleCoverageARB(value,invert);
else
VL_UNSUPPORTED_FUNC();
}
void Renderer::renderRenderData(RenderState& rstate, RenderData* render_data) {
if (!rstate.render_mask || !render_data->render_mask())
return;
if (render_data->offset()) {
GL(glEnable (GL_POLYGON_OFFSET_FILL));
GL(glPolygonOffset(render_data->offset_factor(),
render_data->offset_units()));
}
if (!render_data->depth_test()) {
GL(glDisable (GL_DEPTH_TEST));
}
if (!render_data->alpha_blend()) {
GL(glDisable (GL_BLEND));
}
if( render_data->alpha_to_coverage()) {
GL(glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE));
GL(glSampleCoverage(render_data->sample_coverage(),render_data->invert_coverage_mask()));
}
if (render_data->mesh() != 0) {
GL(renderMesh(rstate, render_data));
}
// Restoring to Default.
// TODO: There's a lot of redundant state changes. If on every render face culling is being set there's no need to
// restore defaults. Possibly later we could add a OpenGL state wrapper to avoid redundant api calls.
if (render_data->cull_face() != RenderData::CullBack) {
GL(glEnable (GL_CULL_FACE));
GL(glCullFace (GL_BACK));
}
if (render_data->offset()) {
GL(glDisable (GL_POLYGON_OFFSET_FILL));
}
if (!render_data->depth_test()) {
GL(glEnable (GL_DEPTH_TEST));
}
if (!render_data->alpha_blend()) {
GL(glEnable (GL_BLEND));
}
if (render_data->alpha_to_coverage()) {
GL(glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE));
}
}
/**
* Set the render states for render data
*/
void GLRenderer::setRenderStates(RenderData* render_data, RenderState& rstate) {
if (!(rstate.render_mask & render_data->render_mask()))
return;
if (render_data->offset()) {
GL(glEnable (GL_POLYGON_OFFSET_FILL));
GL(
glPolygonOffset(render_data->offset_factor(),
render_data->offset_units()));
}
if (!render_data->depth_test()) {
GL(glDisable (GL_DEPTH_TEST));
}
if (!render_data->alpha_blend()) {
GL(glDisable (GL_BLEND));
}
if (render_data->alpha_to_coverage()) {
GL(glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE));
GL(
glSampleCoverage(render_data->sample_coverage(),
render_data->invert_coverage_mask()));
}
}
void StateSystem::SampleState::applyGL() const
{
glSampleCoverage(coverage,invert);
glSampleMaski(0,mask);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglSampleCoverage(JNIEnv *env, jclass clazz, jfloat value, jboolean invert, jlong function_pointer) {
glSampleCoveragePROC glSampleCoverage = (glSampleCoveragePROC)((intptr_t)function_pointer);
glSampleCoverage(value, invert);
}
void sample_coverage(gl::float_t value, gl::boolean_t invert) {
glSampleCoverage(value, invert);
}
void GraphicsContext3D::sampleCoverage(GC3Dclampf value, GC3Dboolean invert)
{
makeContextCurrent();
glSampleCoverage(value, invert);
}
void CG3DGraphicsGL::ApplySet(CG3DGlobalSet::SetType type)
{
switch (type) {
case CG3DGlobalSet::COLOUR: {
CG3DColourSet* set = (CG3DColourSet*)m_Stacks[type].m_Value;
if (set->m_DoClear)
m_ClearEnabled |= GL_COLOR_BUFFER_BIT;
else
m_ClearEnabled &= ~GL_COLOR_BUFFER_BIT;
CG3DVector4 cfloat = set->m_Clear.Get4f();
glClearColor(cfloat.x, cfloat.y, cfloat.z, cfloat.w);
glColorMask(set->m_UseR, set->m_UseG, set->m_UseB, set->m_UseA);
} break;
case CG3DGlobalSet::DEPTH: {
CG3DDepthSet* set = (CG3DDepthSet*)m_Stacks[type].m_Value;
if (set->m_DoClear)
m_ClearEnabled |= GL_DEPTH_BUFFER_BIT;
else
m_ClearEnabled &= ~GL_DEPTH_BUFFER_BIT;
glClearDepthf(set->m_Clear);
glDepthMask(set->m_WriteDepth);
switch (set->m_Test) {
case CG3DDepthSet::ALWAYS: glDisable(GL_DEPTH_TEST); break;
case CG3DDepthSet::NEVER: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_NEVER); break;
case CG3DDepthSet::LESS: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LESS); break;
case CG3DDepthSet::LEQUAL: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); break;
case CG3DDepthSet::EQUAL: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_EQUAL); break;
case CG3DDepthSet::GREATER: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_GREATER); break;
case CG3DDepthSet::GEQUAL: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_GEQUAL); break;
case CG3DDepthSet::NOTEQUAL: glEnable(GL_DEPTH_TEST); glDepthFunc(GL_NOTEQUAL); break;
}
} break;
case CG3DGlobalSet::STENCIL: {
CG3DStencilSet* set = (CG3DStencilSet*)m_Stacks[type].m_Value;
if (set->m_DoClear)
m_ClearEnabled |= GL_STENCIL_BUFFER_BIT;
else
m_ClearEnabled &= ~GL_STENCIL_BUFFER_BIT;
glClearStencil(set->m_Clear);
ApplyStencil(set);
} break;
case CG3DGlobalSet::CULL: {
CG3DCullSet* set = (CG3DCullSet*)m_Stacks[type].m_Value;
switch (set->m_Cull) {
case CG3DCullSet::CULL_NONE: glDisable(GL_CULL_FACE); break;
case CG3DCullSet::CULL_FRONT: glEnable(GL_CULL_FACE); glCullFace(GL_FRONT); break;
case CG3DCullSet::CULL_BACK: glEnable(GL_CULL_FACE); glCullFace(GL_BACK); break;
}
//if (set->m_FrontIsCCW != CG3DCullSet::NO)
glFrontFace(GL_CCW);
//else
// glFrontFace(GL_CW);
} break;
case CG3DGlobalSet::VIEWPORT: {
CG3DViewportSet* set = (CG3DViewportSet*)m_Stacks[type].m_Value;
glViewport((int)set->m_Rect.x, (int)set->m_Rect.y, (int)set->m_Rect.z, (int)set->m_Rect.w);
glDepthRangef(set->m_NearZ, set->m_FarZ);
} break;
case CG3DGlobalSet::SCISSOR: {
CG3DScissorSet* set = (CG3DScissorSet*)m_Stacks[type].m_Value;
if (set->m_Do)
glEnable(GL_SCISSOR_TEST);
else
glDisable(GL_SCISSOR_TEST);
glScissor((int)set->m_Rect.x, (int)set->m_Rect.y, (int)set->m_Rect.z, (int)set->m_Rect.w);
} break;
case CG3DGlobalSet::BLEND: {
CG3DBlendSet* set = (CG3DBlendSet*)m_Stacks[type].m_Value;
CG3DVector4 col = set->m_Colour.Get4f();
switch (set->m_Mode)
{
case CG3DBlendSet::OFF:
glDisable(GL_BLEND);
break;
case CG3DBlendSet::COMBINED:
glEnable(GL_BLEND);
glBlendEquation(GetBlendFunc(set->m_Func));
glBlendFunc(GetBlendParam(set->m_Src), GetBlendParam(set->m_Dest));
glBlendColor(col.x, col.y, col.z, col.w);
break;
case CG3DBlendSet::SEPARATE:
glEnable(GL_BLEND);
glBlendEquationSeparate(GetBlendFunc(set->m_Func), GetBlendFunc(set->m_FuncAlpha));
glBlendFuncSeparate(GetBlendParam(set->m_Src), GetBlendParam(set->m_Dest), GetBlendParam(set->m_SrcAlpha), GetBlendParam(set->m_DestAlpha));
glBlendColor(col.x, col.y, col.z, col.w);
break;
}
} break;
case CG3DGlobalSet::SAMPLE_COVERAGE: {
CG3DSampleCoverageSet* set = (CG3DSampleCoverageSet*)m_Stacks[type].m_Value;
if (set->m_Coverage)
glEnable(GL_SAMPLE_COVERAGE);
else
glDisable(GL_SAMPLE_COVERAGE);
if (set->m_AlphaCoverage)
glEnable(GL_SAMPLE_ALPHA_TO_COVERAGE);
else
glDisable(GL_SAMPLE_ALPHA_TO_COVERAGE);
glSampleCoverage(set->m_Value, set->m_Invert);
} break;
case CG3DGlobalSet::DITHER: {
CG3DDitherSet* set = (CG3DDitherSet*)m_Stacks[type].m_Value;
if (set->m_Dither)
glEnable(GL_DITHER);
else
glDisable(GL_DITHER);
} break;
case CG3DGlobalSet::POLYGON_OFFSET: {
CG3DPolygonOffsetSet* set = (CG3DPolygonOffsetSet*)m_Stacks[type].m_Value;
if (set->m_PolygonOffset)
glEnable(GL_POLYGON_OFFSET_FILL);
else
glDisable(GL_POLYGON_OFFSET_FILL);
glPolygonOffset(set->m_Factor, set->m_Units);
} break;
}
}
void GLWrapper::SampleCoverage(GLfloat param0, GLboolean param1)
{
GLLOG(glSampleCoverage(param0, param1));ERROR_CHECK;
}
void glSampleCoverageLogged(GLclampf value, GLboolean invert) {
printf("glSampleCoverage(%.2f, %u)\n", value, invert);
glSampleCoverage(value, invert);
}
GLboolean UtilResetState(void) {
// Do we need to delete textures, shaders, and programs?
#if 0
GLint i, val;
int windowWidth = atoi(flagWidthValue.cstring);
int windowHeight = atoi(flagHeightValue.cstring);
glGetIntegerv( GL_MAX_VERTEX_ATTRIBS, &val );
for( i = 0; i < val; ++i )
{
glDisableVertexAttribArray( i );
glVertexAttribPointer( i , 4, GL_FLOAT, GL_FALSE, 0, NULL );
}
glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
glBindBuffer( GL_ARRAY_BUFFER, 0 );
glViewport( 0, 0, windowWidth, windowHeight );
glDepthRangef( 0, 1 );
glLineWidth( 1.f );
glDisable( GL_CULL_FACE );
glCullFace( GL_BACK );
glFrontFace( GL_CCW );
glPolygonOffset( 0, 0 );
glDisable( GL_SAMPLE_ALPHA_TO_COVERAGE );
glDisable( GL_SAMPLE_COVERAGE );
glSampleCoverage( 1, GL_FALSE );
glGetIntegerv( GL_MAX_TEXTURE_IMAGE_UNITS, &val );
for ( i = 0; i < val; ++i ) {
glActiveTexture( GL_TEXTURE0+i );
glBindTexture( GL_TEXTURE_2D, 0 );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
//glBindTexture( GL_TEXTURE_3D, 0 ); // Need to check to see if extension is supported
//glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR );
//glTexParameteri( GL_TEXTURE_3D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
//glTexParameteri( GL_TEXTURE_3D, GL_WRAP_S, GL_REPEAT );
//glTexParameteri( GL_TEXTURE_3D, GL_WRAP_T, GL_REPEAT );
glBindTexture( GL_TEXTURE_CUBE_MAP, 0 );
glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, GL_NEAREST_MIPMAP_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameteri( GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, GL_REPEAT );
}
glActiveTexture( GL_TEXTURE0 );
glColorMask( GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE );
glDepthMask( GL_TRUE );
glStencilMaskSeparate( GL_FRONT_AND_BACK, 0xffffffff );
glClearColor( 0, 0, 0, 0 );
glClearDepthf( 1 );
glClearStencil( 0 );
glDisable( GL_SCISSOR_TEST );
glScissor( 0, 0, windowWidth, windowHeight );
glDisable( GL_STENCIL_TEST );
glStencilFuncSeparate( GL_FRONT_AND_BACK, GL_ALWAYS, 0, 0xffffffff );
glStencilOpSeparate( GL_FRONT_AND_BACK, GL_KEEP, GL_KEEP, GL_KEEP );
glDisable( GL_DEPTH_TEST );
glDepthFunc( GL_LESS );
glDisable( GL_BLEND );
glBlendFuncSeparate( GL_ONE, GL_ZERO, GL_ONE, GL_ZERO );
glBlendEquationSeparate( GL_FUNC_ADD, GL_FUNC_ADD );
glBlendColor( 0, 0, 0, 0 );
glEnable( GL_DITHER );
glPixelStorei( GL_UNPACK_ALIGNMENT, 4 );
glPixelStorei( GL_PACK_ALIGNMENT, 4 );
glUseProgram(0);
glGetError();
#endif
return GL_TRUE;
}
uintptr_t processFn(struct fnargs* args, char* parg) {
uintptr_t ret = 0;
switch (args->fn) {
case glfnUNDEFINED:
abort(); // bad glfn
break;
case glfnActiveTexture:
glActiveTexture((GLenum)args->a0);
break;
case glfnAttachShader:
glAttachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnBindAttribLocation:
glBindAttribLocation((GLint)args->a0, (GLint)args->a1, (GLchar*)args->a2);
break;
case glfnBindBuffer:
glBindBuffer((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnBindFramebuffer:
glBindFramebuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindRenderbuffer:
glBindRenderbuffer((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBindTexture:
glBindTexture((GLenum)args->a0, (GLint)args->a1);
break;
case glfnBlendColor:
glBlendColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnBlendEquation:
glBlendEquation((GLenum)args->a0);
break;
case glfnBlendEquationSeparate:
glBlendEquationSeparate((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFunc:
glBlendFunc((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnBlendFuncSeparate:
glBlendFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnBufferData:
glBufferData((GLenum)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg, (GLenum)args->a2);
break;
case glfnBufferSubData:
glBufferSubData((GLenum)args->a0, (GLint)args->a1, (GLsizeiptr)args->a2, (GLvoid*)parg);
break;
case glfnCheckFramebufferStatus:
ret = glCheckFramebufferStatus((GLenum)args->a0);
break;
case glfnClear:
glClear((GLenum)args->a0);
break;
case glfnClearColor:
glClearColor(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnClearDepthf:
glClearDepthf(*(GLfloat*)&args->a0);
break;
case glfnClearStencil:
glClearStencil((GLint)args->a0);
break;
case glfnColorMask:
glColorMask((GLboolean)args->a0, (GLboolean)args->a1, (GLboolean)args->a2, (GLboolean)args->a3);
break;
case glfnCompileShader:
glCompileShader((GLint)args->a0);
break;
case glfnCompressedTexImage2D:
glCompressedTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLsizeiptr)args->a6, (GLvoid*)parg);
break;
case glfnCompressedTexSubImage2D:
glCompressedTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLenum)args->a6, (GLsizeiptr)args->a7, (GLvoid*)parg);
break;
case glfnCopyTexImage2D:
glCopyTexImage2D((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCopyTexSubImage2D:
glCopyTexSubImage2D((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4, (GLint)args->a5, (GLint)args->a6, (GLint)args->a7);
break;
case glfnCreateProgram:
ret = glCreateProgram();
break;
case glfnCreateShader:
ret = glCreateShader((GLenum)args->a0);
break;
case glfnCullFace:
glCullFace((GLenum)args->a0);
break;
case glfnDeleteBuffer:
glDeleteBuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteFramebuffer:
glDeleteFramebuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteProgram:
glDeleteProgram((GLint)args->a0);
break;
case glfnDeleteRenderbuffer:
glDeleteRenderbuffers(1, (const GLuint*)(&args->a0));
break;
case glfnDeleteShader:
glDeleteShader((GLint)args->a0);
break;
case glfnDeleteTexture:
glDeleteTextures(1, (const GLuint*)(&args->a0));
break;
case glfnDepthFunc:
glDepthFunc((GLenum)args->a0);
break;
case glfnDepthMask:
glDepthMask((GLboolean)args->a0);
break;
case glfnDepthRangef:
glDepthRangef(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnDetachShader:
glDetachShader((GLint)args->a0, (GLint)args->a1);
break;
case glfnDisable:
glDisable((GLenum)args->a0);
break;
case glfnDisableVertexAttribArray:
glDisableVertexAttribArray((GLint)args->a0);
break;
case glfnDrawArrays:
glDrawArrays((GLenum)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnDrawElements:
glDrawElements((GLenum)args->a0, (GLint)args->a1, (GLenum)args->a2, (void*)args->a3);
break;
case glfnEnable:
glEnable((GLenum)args->a0);
break;
case glfnEnableVertexAttribArray:
glEnableVertexAttribArray((GLint)args->a0);
break;
case glfnFinish:
glFinish();
break;
case glfnFlush:
glFlush();
break;
case glfnFramebufferRenderbuffer:
glFramebufferRenderbuffer((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3);
break;
case glfnFramebufferTexture2D:
glFramebufferTexture2D((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnFrontFace:
glFrontFace((GLenum)args->a0);
break;
case glfnGenBuffer:
glGenBuffers(1, (GLuint*)&ret);
break;
case glfnGenFramebuffer:
glGenFramebuffers(1, (GLuint*)&ret);
break;
case glfnGenRenderbuffer:
glGenRenderbuffers(1, (GLuint*)&ret);
break;
case glfnGenTexture:
glGenTextures(1, (GLuint*)&ret);
break;
case glfnGenerateMipmap:
glGenerateMipmap((GLenum)args->a0);
break;
case glfnGetActiveAttrib:
glGetActiveAttrib(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetActiveUniform:
glGetActiveUniform(
(GLuint)args->a0,
(GLuint)args->a1,
(GLsizei)args->a2,
NULL,
(GLint*)&ret,
(GLenum*)args->a3,
(GLchar*)parg);
break;
case glfnGetAttachedShaders:
glGetAttachedShaders((GLuint)args->a0, (GLsizei)args->a1, (GLsizei*)&ret, (GLuint*)parg);
break;
case glfnGetAttribLocation:
ret = glGetAttribLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetBooleanv:
glGetBooleanv((GLenum)args->a0, (GLboolean*)parg);
break;
case glfnGetBufferParameteri:
glGetBufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetFloatv:
glGetFloatv((GLenum)args->a0, (GLfloat*)parg);
break;
case glfnGetIntegerv:
glGetIntegerv((GLenum)args->a0, (GLint*)parg);
break;
case glfnGetError:
ret = glGetError();
break;
case glfnGetFramebufferAttachmentParameteriv:
glGetFramebufferAttachmentParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLint*)&ret);
break;
case glfnGetProgramiv:
glGetProgramiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetProgramInfoLog:
glGetProgramInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetRenderbufferParameteriv:
glGetRenderbufferParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderiv:
glGetShaderiv((GLint)args->a0, (GLenum)args->a1, (GLint*)&ret);
break;
case glfnGetShaderInfoLog:
glGetShaderInfoLog((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetShaderPrecisionFormat:
glGetShaderPrecisionFormat((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg, &((GLint*)parg)[2]);
break;
case glfnGetShaderSource:
glGetShaderSource((GLuint)args->a0, (GLsizei)args->a1, 0, (GLchar*)parg);
break;
case glfnGetString:
ret = (uintptr_t)glGetString((GLenum)args->a0);
break;
case glfnGetTexParameterfv:
glGetTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetTexParameteriv:
glGetTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnGetUniformfv:
glGetUniformfv((GLuint)args->a0, (GLint)args->a1, (GLfloat*)parg);
break;
case glfnGetUniformiv:
glGetUniformiv((GLuint)args->a0, (GLint)args->a1, (GLint*)parg);
break;
case glfnGetUniformLocation:
ret = glGetUniformLocation((GLint)args->a0, (GLchar*)args->a1);
break;
case glfnGetVertexAttribfv:
glGetVertexAttribfv((GLuint)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnGetVertexAttribiv:
glGetVertexAttribiv((GLuint)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnHint:
glHint((GLenum)args->a0, (GLenum)args->a1);
break;
case glfnIsBuffer:
ret = glIsBuffer((GLint)args->a0);
break;
case glfnIsEnabled:
ret = glIsEnabled((GLenum)args->a0);
break;
case glfnIsFramebuffer:
ret = glIsFramebuffer((GLint)args->a0);
break;
case glfnIsProgram:
ret = glIsProgram((GLint)args->a0);
break;
case glfnIsRenderbuffer:
ret = glIsRenderbuffer((GLint)args->a0);
break;
case glfnIsShader:
ret = glIsShader((GLint)args->a0);
break;
case glfnIsTexture:
ret = glIsTexture((GLint)args->a0);
break;
case glfnLineWidth:
glLineWidth(*(GLfloat*)&args->a0);
break;
case glfnLinkProgram:
glLinkProgram((GLint)args->a0);
break;
case glfnPixelStorei:
glPixelStorei((GLenum)args->a0, (GLint)args->a1);
break;
case glfnPolygonOffset:
glPolygonOffset(*(GLfloat*)&args->a0, *(GLfloat*)&args->a1);
break;
case glfnReadPixels:
glReadPixels((GLint)args->a0, (GLint)args->a1, (GLsizei)args->a2, (GLsizei)args->a3, (GLenum)args->a4, (GLenum)args->a5, (void*)parg);
break;
case glfnReleaseShaderCompiler:
glReleaseShaderCompiler();
break;
case glfnRenderbufferStorage:
glRenderbufferStorage((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnSampleCoverage:
glSampleCoverage(*(GLfloat*)&args->a0, (GLboolean)args->a1);
break;
case glfnScissor:
glScissor((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnShaderSource:
#if defined(os_ios) || defined(os_osx)
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar *const *)args->a2, NULL);
#else
glShaderSource((GLuint)args->a0, (GLsizei)args->a1, (const GLchar **)args->a2, NULL);
#endif
break;
case glfnStencilFunc:
glStencilFunc((GLenum)args->a0, (GLint)args->a1, (GLuint)args->a2);
break;
case glfnStencilFuncSeparate:
glStencilFuncSeparate((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2, (GLuint)args->a3);
break;
case glfnStencilMask:
glStencilMask((GLuint)args->a0);
break;
case glfnStencilMaskSeparate:
glStencilMaskSeparate((GLenum)args->a0, (GLuint)args->a1);
break;
case glfnStencilOp:
glStencilOp((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2);
break;
case glfnStencilOpSeparate:
glStencilOpSeparate((GLenum)args->a0, (GLenum)args->a1, (GLenum)args->a2, (GLenum)args->a3);
break;
case glfnTexImage2D:
glTexImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLsizei)args->a3,
(GLsizei)args->a4,
0, // border
(GLenum)args->a5,
(GLenum)args->a6,
(const GLvoid*)parg);
break;
case glfnTexSubImage2D:
glTexSubImage2D(
(GLenum)args->a0,
(GLint)args->a1,
(GLint)args->a2,
(GLint)args->a3,
(GLsizei)args->a4,
(GLsizei)args->a5,
(GLenum)args->a6,
(GLenum)args->a7,
(const GLvoid*)parg);
break;
case glfnTexParameterf:
glTexParameterf((GLenum)args->a0, (GLenum)args->a1, *(GLfloat*)&args->a2);
break;
case glfnTexParameterfv:
glTexParameterfv((GLenum)args->a0, (GLenum)args->a1, (GLfloat*)parg);
break;
case glfnTexParameteri:
glTexParameteri((GLenum)args->a0, (GLenum)args->a1, (GLint)args->a2);
break;
case glfnTexParameteriv:
glTexParameteriv((GLenum)args->a0, (GLenum)args->a1, (GLint*)parg);
break;
case glfnUniform1f:
glUniform1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnUniform1fv:
glUniform1fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform1i:
glUniform1i((GLint)args->a0, (GLint)args->a1);
break;
case glfnUniform1iv:
glUniform1iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2f:
glUniform2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnUniform2fv:
glUniform2fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform2i:
glUniform2i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2);
break;
case glfnUniform2iv:
glUniform2iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3f:
glUniform3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnUniform3fv:
glUniform3fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform3i:
glUniform3i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
case glfnUniform3iv:
glUniform3iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4f:
glUniform4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnUniform4fv:
glUniform4fv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniform4i:
glUniform4i((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3, (GLint)args->a4);
break;
case glfnUniform4iv:
glUniform4iv((GLint)args->a0, (GLsizeiptr)args->a1, (GLvoid*)parg);
break;
case glfnUniformMatrix2fv:
glUniformMatrix2fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix3fv:
glUniformMatrix3fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUniformMatrix4fv:
glUniformMatrix4fv((GLint)args->a0, (GLsizeiptr)args->a1, 0, (GLvoid*)parg);
break;
case glfnUseProgram:
glUseProgram((GLint)args->a0);
break;
case glfnValidateProgram:
glValidateProgram((GLint)args->a0);
break;
case glfnVertexAttrib1f:
glVertexAttrib1f((GLint)args->a0, *(GLfloat*)&args->a1);
break;
case glfnVertexAttrib1fv:
glVertexAttrib1fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib2f:
glVertexAttrib2f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2);
break;
case glfnVertexAttrib2fv:
glVertexAttrib2fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib3f:
glVertexAttrib3f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3);
break;
case glfnVertexAttrib3fv:
glVertexAttrib3fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttrib4f:
glVertexAttrib4f((GLint)args->a0, *(GLfloat*)&args->a1, *(GLfloat*)&args->a2, *(GLfloat*)&args->a3, *(GLfloat*)&args->a4);
break;
case glfnVertexAttrib4fv:
glVertexAttrib4fv((GLint)args->a0, (GLfloat*)parg);
break;
case glfnVertexAttribPointer:
glVertexAttribPointer((GLuint)args->a0, (GLint)args->a1, (GLenum)args->a2, (GLboolean)args->a3, (GLsizei)args->a4, (const GLvoid*)args->a5);
break;
case glfnViewport:
glViewport((GLint)args->a0, (GLint)args->a1, (GLint)args->a2, (GLint)args->a3);
break;
}
return ret;
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL13_nglSampleCoverage(JNIEnv *__env, jclass clazz, jfloat value, jboolean invert, jlong __functionAddress) {
glSampleCoveragePROC glSampleCoverage = (glSampleCoveragePROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glSampleCoverage(value, invert);
}
inline void VL_glSampleCoverage( GLclampf value, GLboolean invert)
{
glSampleCoverage(value,invert);
}
