void Texture::getParami(GLenum pname, GLint *value)
{
glGetTexParameteriv(target, pname, value);
}
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;
}
void GraphicsContext3D::getTexParameteriv(GC3Denum target, GC3Denum paramName, GC3Dint* value)
{
makeContextCurrent();
glGetTexParameteriv(target, paramName, value);
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLuint tex[4];
GLint level;
/* The GL ES 3.0 spec says:
*
* "The [initial] value of TEXTURE_IMMUTABLE_LEVELS is 0."
*/
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
if (level != 0) {
printf("Expected 0 levels initially, but glGetTexParameteriv "
"returned %d for GL_TEXTURE_1D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glGenTextures(4, tex);
glBindTexture(GL_TEXTURE_2D, tex[0]);
glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 3) {
printf("Expected 3 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_2D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_3D, tex[1]);
glTexStorage3D(GL_TEXTURE_3D, 3, GL_RGBA8, 32, 32, 32);
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 3) {
printf("Expected 3 levels, but glGetTexParameterfv returned "
"%d for GL_TEXTURE_3D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_2D, tex[2]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 0) {
printf("Expected 0 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_2D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_3D, tex[3]);
glTexImage2D(GL_TEXTURE_3D, 0, GL_RGBA, 32, 32, 32, GL_RGBA, GL_FLOAT, NULL);
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 0) {
printf("Expected 0 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_3D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glDeleteTextures(4, tex);
piglit_report_result(PIGLIT_PASS);
return 0;
}
void gl4es_glGetMultiTexParameteriv(GLenum texunit, GLenum target, GLenum pname, GLint *params) {
text(glGetTexParameteriv(target, pname, params));
}
bool CFXTransExplodingCubes::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
CVarFloat::CValueFloat valueTime;
CVarFloat::CValueFloat valueScaleX;
CVarFloat::CValueFloat valueScaleY;
CVarCombo::CValueCombo valueFiltering;
CVarColor::CValueColor valueColor;
EvaluateVar("Time (0-1)", fEffectTime, &valueTime);
EvaluateVar("Tex Scale X", fEffectTime, &valueScaleX);
EvaluateVar("Tex Scale Y", fEffectTime, &valueScaleY);
EvaluateVar("Filtering", fEffectTime, &valueFiltering);
EvaluateVar("Flat Color", fEffectTime, &valueColor);
m_v4FlatColor = valueColor.GetValue();
// Change filter mode
GLint minFilter, magFilter;
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
m_textureRTT.SetActive();
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter);
if(valueFiltering.GetValue() == "Yes")
{
// If it's point filtering, change it to linear, otherwise leave it as it is
if(minFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if(magFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
// Framebuffer to texture
m_textureRTT.CopyFromFramebuffer(0, 0, 0, 0, m_textureRTT.GetWidth(), m_textureRTT.GetHeight());
// Restore demo viewport
pDemo->SetDemoViewport();
// Clear framebuffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
// States
UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
UtilGL::States::Set (UtilGL::States::STENCILBUFFER, UtilGL::States::ENABLED);
glStencilFunc(GL_ALWAYS, 1, 1);
glStencilOp (GL_REPLACE, GL_REPLACE, GL_REPLACE);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, 1.33f, 1.0f, 100.0f);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_WORLD);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_VIEW);
CMatrix mtxTex;
mtxTex.BuildScaling(valueScaleX.GetValue(), valueScaleY.GetValue(), 1.0f);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_TEXTURE, mtxTex);
// Render:
VECCUBES::iterator it;
for(it = m_vecCubes.begin(); it != m_vecCubes.end(); ++it)
{
float fTime = valueTime.GetValue() - it->fStartTime;
if(fTime < 0.0f) fTime = 0.0f;
DrawCube(*it, fTime);
}
glStencilFunc(GL_NOTEQUAL, 1, 1);
glStencilOp (GL_KEEP, GL_KEEP, GL_KEEP);
// Restore
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_TEXTURE);
return true;
}
void gld_BindPatch(GLTexture *gltexture, int cm)
{
const rpatch_t *patch;
int i;
unsigned char *buffer;
if ((gltexture==last_gltexture) && (cm==last_cm))
return;
last_gltexture=gltexture;
last_cm=cm;
if (!gltexture)
return;
if (gltexture->textype!=GLDT_PATCH)
{
glBindTexture(GL_TEXTURE_2D, 0);
last_gltexture = NULL;
last_cm = -1;
return;
}
if (gltexture->glTexID[cm]!=0)
{
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[cm]);
glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_RESIDENT,&i);
#ifdef _DEBUG
if (i!=GL_TRUE)
lprintf(LO_INFO, "glGetTexParam: %i\n", i);
#endif
if (i==GL_TRUE)
return;
}
patch=R_CachePatchNum(gltexture->index);
buffer=(unsigned char*)Z_Malloc(gltexture->buffer_size,PU_STATIC,0);
if (gl_paletted_texture)
memset(buffer,transparent_pal_index,gltexture->buffer_size);
else
memset(buffer,0,gltexture->buffer_size);
gld_AddPatchToTexture(gltexture, buffer, patch, 0, 0, cm, gl_paletted_texture);
if (gltexture->glTexID[cm]==0)
glGenTextures(1,&gltexture->glTexID[cm]);
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[cm]);
#ifdef USE_GLU_IMAGESCALE
if ((gltexture->buffer_width>gltexture->tex_width) ||
(gltexture->buffer_height>gltexture->tex_height)
)
{
unsigned char *scaledbuffer;
scaledbuffer=(unsigned char*)Z_Malloc(gltexture->tex_width*gltexture->tex_height*4,PU_STATIC,0);
if (scaledbuffer)
{
gluScaleImage(GL_RGBA,
gltexture->buffer_width, gltexture->buffer_height,
GL_UNSIGNED_BYTE,buffer,
gltexture->tex_width, gltexture->tex_height,
GL_UNSIGNED_BYTE,scaledbuffer);
Z_Free(buffer);
buffer=scaledbuffer;
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->tex_width, gltexture->tex_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
else
#endif /* USE_GLU_IMAGESCALE */
{
if (gl_paletted_texture) {
I_Error("Paletted textures not supported");
/*
gld_SetTexturePalette(GL_TEXTURE_2D);
glTexImage2D( GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, buffer); */
} else {
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
// Vladimir i ->x
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_tex_filter);
Z_Free(buffer);
R_UnlockPatchNum(gltexture->index);
}
void glGetTexParameterivLogged(GLenum target, GLenum pname, GLint *params) {
printf("glGetTexParameteriv(%s, %s, %p)\n", GLEnumName(target), GLEnumName(pname), params);
glGetTexParameteriv(target, pname, params);
}
/**
* This tests min_levels, num_levels, immutable_levels and imutable_format.
* note: see params test for more min/num level query testing
*
* In OpenGL Core 4.3 spec see section 8.18:
* "The minlevel and minlayer parameters are relative to the view of
* origtexture. If numlayers or numlevels extend beyond origtexture, they
* are clamped to the maximum extent of the original texture.
* If the command is successful, the texture parameters in <texture> are
* updated as follows:
* - TEXTURE_IMMUTABLE_FORMAT is set to TRUE.
*
* - TEXTURE_IMMUTABLE_LEVELS is set to the value of
* TEXTURE_IMMUTABLE_LEVELS from the original texture.
*
* - TEXTURE_VIEW_MIN_LEVEL is set to <minlevel> plus the value of
* TEXTURE_VIEW_MIN_LEVEL from the original texture.
*
* - TEXTURE_VIEW_NUM_LEVELS is set to the lesser of numlevels and the
* value of TEXTURE_VIEW_NUM_LEVELS for origtexture minus minlevels."
* In the ARB_texture_view extension registry spec see this for chained views:
* "(3) Is it possible to create a texture view using an original texture
* which is itself a view? And if so, how are the level/layer values
* interpreted?
*
* RESOLVED: It is legal. For example, let's say texture 1 is a 2D_ARRAY
* texture with 200 layers. It will have TEXTURE_VIEW_MIN_LAYER=0,
* TEXTURE_VIEW_NUM_LAYERS=200. Then we create texture 2 from texture 1 using
* <minlayer>=100, <numlayers>=100. It will have TEXTURE_VIEW_MIN_LAYER=100,
* TEXTURE_VIEW_NUM_LAYERS=100. Then we create texture 3 from texture 2 using
* <minlayer>=50, <numlayers>=50. It will have TEXTURE_VIEW_MIN_LAYER=150,
* TEXTURE_VIEW_NUM_LAYERS=50."
*/
static bool
query_levels_test(void)
{
GLuint tex[2], viewtex, l;
GLint param;
bool pass = true;
glGenTextures(2, tex);
/* test the view causes immutable_format to be set */
glBindTexture(GL_TEXTURE_2D, tex[0]);
glTexStorage2D(GL_TEXTURE_2D, 6, GL_R32F, 16, 32);
glTextureView(tex[1], GL_TEXTURE_2D, tex[0], GL_RG16F, 0, 1, 0, 1);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTexture(GL_TEXTURE_2D, tex[1]);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_FORMAT, ¶m);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
if (param != GL_TRUE) {
printf("bad query of immutable_format\n");
pass = false;
}
glDeleteTextures(2,tex);
/**
* test min_levels are additive using chained views
* test immutable_levels get set correctly based on origtexture
* test num_levels are correct for chained views
*/
glGenTextures(2,tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex[0]);
glTexStorage2D(GL_TEXTURE_CUBE_MAP, 7, GL_R32F, 64, 64);
glTextureView(tex[1], GL_TEXTURE_CUBE_MAP,tex[0], GL_RG16I, 2, 4, 0, 6);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
glBindTexture(GL_TEXTURE_CUBE_MAP, tex[1]);
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_LEVELS,
¶m);
if (param != 7) {
printf("bad query of immutable_levels, expected 7 got %u\n",
param);
pass = false;
}
for (l = 0; l < 4; l++) {
glGenTextures(1, &viewtex);
glTextureView(viewtex, GL_TEXTURE_CUBE_MAP, tex[1], GL_RG16F,
l, 4, 0, 6);
glBindTexture(GL_TEXTURE_CUBE_MAP, viewtex);
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_VIEW_MIN_LEVEL, ¶m);
if (param != (2 + l)) {
glDeleteTextures(1, &viewtex);
printf("bad query of view_min_level expected %u got %u\n",
2+l, param);
pass = false;
break;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_IMMUTABLE_LEVELS, ¶m);
if (param != 7) {
glDeleteTextures(1, &viewtex);
printf("query of immutable_levels not tracking orig, expected 7 got %u\n",
param);
pass = false;
break;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP,
GL_TEXTURE_VIEW_NUM_LEVELS, ¶m);
if (param != (4 - l)) {
glDeleteTextures(1, &viewtex);
printf("bad query of view_num_levels expected %u got %u\n",
4 - l, param);
pass = false;
break;
}
glDeleteTextures(1, &viewtex);
}
glDeleteTextures(2, tex);
pass = piglit_check_gl_error(GL_NO_ERROR) && pass;
return pass;
}
PIGLIT_GL_TEST_CONFIG_END
/**
* make sure default intial state is correct for textureView
* In OpenGL Core 4.3 spec see table 23.15 for default values.
*/
static bool
query_default_state(void)
{
bool pass = true;
GLuint tex[2];
GLint param;
glGenTextures(2,tex);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex[0]);
glTexStorage2D(GL_TEXTURE_CUBE_MAP, 7, GL_R32F, 64, 64);
glTextureView(tex[1], GL_TEXTURE_CUBE_MAP, tex[0], GL_RG16I, 2, 4, 0, 6);
glBindTexture(GL_TEXTURE_CUBE_MAP, tex[1]);
glDeleteTextures(1, &tex[1]);
/* tex[1] which is bound to GL_TEXTURE_CUBE_MAP is deleted */
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_VIEW_MIN_LEVEL,
¶m);
if (param != 0) {
printf("bad default of min_level, expected 0 got %u\n", param);
pass = false;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_VIEW_NUM_LEVELS,
¶m);
if (param != 0) {
printf("bad default of num_levels, expected 0 got %u\n", param);
pass = false;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_VIEW_MIN_LAYER,
¶m);
if (param != 0) {
printf("bad default of min_layer, expected 0 got %u\n", param);
pass = false;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_VIEW_NUM_LAYERS,
¶m);
if (param != 0) {
printf("bad default of num_layers, expected 0 got %u\n", param);
pass = false;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_FORMAT,
¶m);
if (param != 0) {
printf("bad default of immutable_format, expected 0 got %u\n",
param);
pass = false;
}
glGetTexParameteriv(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_IMMUTABLE_LEVELS,
¶m);
if (param != 0) {
printf("bad default of immutable_levels, expected 0 got %u\n",
param);
pass = false;
}
glDeleteTextures(1, tex);
return pass;
}
M(void, glGetTexParameteriv, jint target, jint pname, jobject params) {
glGetTexParameteriv(target, pname, BUFF(GLint, params));
}
void _glGetTexParameteriv( int target,int pname,Array<int> params,int offset ) {
glGetTexParameteriv( target,pname,¶ms[offset] );
}
void gles2_glGetTexParameteriv(void *_glfuncs, GLenum target, GLenum pname, GLint* params)
{
glGetTexParameteriv(target, pname, params);
}
PIGLIT_GL_TEST_CONFIG_END
enum piglit_result
piglit_display(void)
{
GLuint tex[5];
GLint level;
GLint num_level;
/* The GL ES 3.0 spec says:
*
* "The [initial] value of TEXTURE_IMMUTABLE_LEVELS is 0."
*/
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (!piglit_check_gl_error(GL_NO_ERROR)) {
piglit_report_result(PIGLIT_FAIL);
}
if (level != 0) {
printf("Expected 0 levels initially, but glGetTexParameteriv "
"returned %d for GL_TEXTURE_1D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glGenTextures(ARRAY_SIZE(tex), tex);
#ifdef PIGLIT_USE_OPENGL
glBindTexture(GL_TEXTURE_1D, tex[0]);
glTexStorage1D(GL_TEXTURE_1D, 3, GL_RGBA8, 32);
glGetTexParameteriv(GL_TEXTURE_1D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
glGetTexParameteriv(GL_TEXTURE_1D, GL_TEXTURE_VIEW_NUM_LEVELS, &num_level);
if (level != 3) {
printf("Expected 3 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_1D.\n", level);
piglit_report_result(PIGLIT_FAIL);
} else if (level != num_level) {
printf("Expected queries of TEXTURE_IMMUTABLE_LEVELS and "
"TEXTURE_VIEW_NUM_LEVELS to return identical results.");
piglit_report_result(PIGLIT_FAIL);
}
#endif
glBindTexture(GL_TEXTURE_2D, tex[1]);
glTexStorage2D(GL_TEXTURE_2D, 3, GL_RGBA8, 32, 32);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_VIEW_NUM_LEVELS, &num_level);
if (level != 3) {
printf("Expected 3 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_2D.\n", level);
piglit_report_result(PIGLIT_FAIL);
} else if (level != num_level) {
printf("Expected queries of TEXTURE_IMMUTABLE_LEVELS and "
"TEXTURE_VIEW_NUM_LEVELS to return identical results.");
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_3D, tex[2]);
glTexStorage3D(GL_TEXTURE_3D, 3, GL_RGBA8, 32, 32, 32);
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_VIEW_NUM_LEVELS, &num_level);
if (level != 3) {
printf("Expected 3 levels, but glGetTexParameterfv returned "
"%d for GL_TEXTURE_3D.\n", level);
piglit_report_result(PIGLIT_FAIL);
} else if (level != num_level) {
printf("Expected queries of TEXTURE_IMMUTABLE_LEVELS and "
"TEXTURE_VIEW_NUM_LEVELS to return identical results.");
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_2D, tex[3]);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 32, 32, 0, GL_RGBA, GL_FLOAT, NULL);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 0) {
printf("Expected 0 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_2D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glBindTexture(GL_TEXTURE_3D, tex[4]);
glTexImage2D(GL_TEXTURE_3D, 0, GL_RGBA, 32, 32, 32, GL_RGBA, GL_FLOAT, NULL);
glGetTexParameteriv(GL_TEXTURE_3D, GL_TEXTURE_IMMUTABLE_LEVELS, &level);
if (level != 0) {
printf("Expected 0 levels, but glGetTexParameteriv returned "
"%d for GL_TEXTURE_3D.\n", level);
piglit_report_result(PIGLIT_FAIL);
}
glDeleteTextures(5, tex);
piglit_report_result(PIGLIT_PASS);
return 0;
}
void gld_BindFlat(GLTexture *gltexture)
{
const unsigned char *flat;
int i;
unsigned char *buffer;
if (gltexture==last_gltexture)
return;
last_gltexture=gltexture;
if (!gltexture)
return;
if (gltexture->textype!=GLDT_FLAT)
{
glBindTexture(GL_TEXTURE_2D, 0);
last_gltexture = NULL;
last_cm = -1;
return;
}
if (gltexture->glTexID[CR_DEFAULT]!=0)
{
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[CR_DEFAULT]);
glGetTexParameteriv(GL_TEXTURE_2D,GL_TEXTURE_RESIDENT,&i);
#ifdef _DEBUG
if (i!=GL_TRUE)
lprintf(LO_INFO, "glGetTexParam: %i\n", i);
#endif
if (i==GL_TRUE)
return;
}
flat=W_CacheLumpNum(gltexture->index);
buffer=(unsigned char*)Z_Malloc(gltexture->buffer_size,PU_STATIC,0);
if (!(gltexture->mipmap & use_mipmapping) & gl_paletted_texture)
memset(buffer,transparent_pal_index,gltexture->buffer_size);
else
memset(buffer,0,gltexture->buffer_size);
gld_AddFlatToTexture(gltexture, buffer, flat, !(gltexture->mipmap & use_mipmapping) & gl_paletted_texture);
if (gltexture->glTexID[CR_DEFAULT]==0)
glGenTextures(1,&gltexture->glTexID[CR_DEFAULT]);
glBindTexture(GL_TEXTURE_2D, gltexture->glTexID[CR_DEFAULT]);
#ifdef USE_GLU_MIPMAP
if (gltexture->mipmap & use_mipmapping)
{
gluBuild2DMipmaps(GL_TEXTURE_2D, gl_tex_format,
gltexture->buffer_width, gltexture->buffer_height,
GL_RGBA, GL_UNSIGNED_BYTE, buffer);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_mipmap_filter);
if (gl_texture_filter_anisotropic)
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 2.0);
}
else
#endif /* USE_GLU_MIPMAP */
{
#ifdef USE_GLU_IMAGESCALE
if ((gltexture->buffer_width!=gltexture->tex_width) ||
(gltexture->buffer_height!=gltexture->tex_height)
)
{
unsigned char *scaledbuffer;
scaledbuffer=(unsigned char*)Z_Malloc(gltexture->tex_width*gltexture->tex_height*4,PU_STATIC,0);
if (scaledbuffer)
{
gluScaleImage(GL_RGBA,
gltexture->buffer_width, gltexture->buffer_height,
GL_UNSIGNED_BYTE,buffer,
gltexture->tex_width, gltexture->tex_height,
GL_UNSIGNED_BYTE,scaledbuffer);
Z_Free(buffer);
buffer=scaledbuffer;
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->tex_width, gltexture->tex_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
else
#endif /* USE_GLU_IMAGESCALE */
{
if (gl_paletted_texture) {
I_Error("Paletted textures not supported");
/*
gld_SetTexturePalette(GL_TEXTURE_2D);
glTexImage2D( GL_TEXTURE_2D, 0, GL_COLOR_INDEX8_EXT,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_COLOR_INDEX, GL_UNSIGNED_BYTE, buffer); */
} else {
glTexImage2D( GL_TEXTURE_2D, 0, gl_tex_format,
gltexture->buffer_width, gltexture->buffer_height,
0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
}
}
// Vladimir i -> x
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, gl_tex_filter);
glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, gl_tex_filter);
}
Z_Free(buffer);
W_UnlockLumpNum(gltexture->index);
}
void GL::getTexParameteriv(Enum target, Enum pname, Int * params)
{
glGetTexParameteriv(target, pname, params);
CHECK_GL_ERROR3(glGetTexParameteriv, target, pname, params);
}
bool CFXMosaic::DoFrame(CDemo* pDemo, float fEffectTime, float fDemoTime)
{
assert(pDemo);
if(!m_pResTexture)
{
FXRuntimeError("Texture resource not found");
return false;
}
UtilGL::Texturing::CTexture2D* pTexture = const_cast<UtilGL::Texturing::CTexture2D*>(((CResourceTexture2D*)m_pResTexture)->GetTexture2D());
if(!pTexture)
{
FXRuntimeError("WARNING: Texture not available");
return false;
}
if(m_vecTiles.size() < 1)
{
FXRuntimeError("WARNING: No tiles available");
return false;
}
CVarFloat::CValueFloat valuePosX;
CVarFloat::CValueFloat valuePosY;
CVarFloat::CValueFloat valueWidth;
CVarFloat::CValueFloat valueHeight;
CVarFloat::CValueFloat valueScale;
CVarFloat::CValueFloat valueAlpha;
CVarFloat::CValueFloat valueAngle;
CVarCombo::CValueCombo valueBlendMode;
CVarCombo::CValueCombo valueFiltering;
CVarInt::CValueInt valueTilesX;
CVarInt::CValueInt valueTilesY;
CVarInt::CValueInt valueTileSourceWidth;
CVarInt::CValueInt valueTileSourceHeight;
CVarFloat::CValueFloat valueChangeFrequency;
CVarFloat::CValueFloat valueChangeFreqVariation;
EvaluateVar("X Position", fEffectTime, &valuePosX);
EvaluateVar("Y Position", fEffectTime, &valuePosY);
EvaluateVar("Width", fEffectTime, &valueWidth);
EvaluateVar("Height", fEffectTime, &valueHeight);
EvaluateVar("Scale", fEffectTime, &valueScale);
EvaluateVar("Alpha", fEffectTime, &valueAlpha);
EvaluateVar("Angle", fEffectTime, &valueAngle);
EvaluateVar("Blend Mode", fEffectTime, &valueBlendMode);
EvaluateVar("Filtering", fEffectTime, &valueFiltering);
EvaluateVar("Tiles X", fEffectTime, &valueTilesX);
EvaluateVar("Tiles Y", fEffectTime, &valueTilesY);
EvaluateVar("Tile Source Width", fEffectTime, &valueTileSourceWidth);
EvaluateVar("Tile Source Height", fEffectTime, &valueTileSourceHeight);
EvaluateVar("Change Frequency", fEffectTime, &valueChangeFrequency);
EvaluateVar("Change Freq Variation", fEffectTime, &valueChangeFreqVariation);
// Change filter mode
GLint minFilter, magFilter;
GLfloat fMaxAnisotropy;
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::ENABLED);
pTexture->SetActive();
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter);
if(UtilGL::Extensions::GetAvailableExtensions()->EXT_texture_filter_anisotropic)
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fMaxAnisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, 1.0f);
}
if(valueFiltering.GetValue() == "Yes")
{
// If it's point filtering, change it to linear, otherwise leave it as it is
if(minFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
if(magFilter == GL_NEAREST) glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}
else
{
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
}
CVarFloat* pVarAngle = reinterpret_cast<CVarFloat*>(GetVar("Angle"));
assert(pVarAngle);
float fAlpha = valueAlpha.GetValue() > 1.0f ? 1.0f : valueAlpha.GetValue();
if(fAlpha < ALMOST_ZERO)
{
return true;
}
CVector4 v4Color(1.0f, 1.0f, 1.0f, fAlpha);
UtilGL::States::SetColor(v4Color);
float fAngle = valueAngle.GetValue();
if(IS_ZERO(fAngle) && !pVarAngle->IsConstant())
{
// Avoid aspect ratio problem (see UtilGL::Rendering::DrawRect())
fAngle = fAngle < 0.0f ? fAngle - (ALMOST_ZERO * 2.0f) : fAngle + (ALMOST_ZERO * 2.0f);
}
int nSrcBlend = UtilGL::States::BLEND_SRCALPHA;
int nDstBlend = UtilGL::States::BLEND_INVSRCALPHA;
if(valueBlendMode.GetValue() == "Add") nDstBlend = UtilGL::States::BLEND_ONE;
else if(valueBlendMode.GetValue() == "Mult") nDstBlend = UtilGL::States::BLEND_INVSRCALPHA;
else if(valueBlendMode.GetValue() == "Color Mult")
{
nSrcBlend = UtilGL::States::BLEND_DSTCOLOR;
nDstBlend = UtilGL::States::BLEND_ZERO;
}
if(ARE_EQUAL(fAlpha, 1.0f) && valueBlendMode.GetValue() == "Mult" && !pTexture->HasAlpha())
{
nSrcBlend = UtilGL::States::BLEND_ONE;
nDstBlend = UtilGL::States::BLEND_ZERO;
}
if(!((nSrcBlend == UtilGL::States::BLEND_ONE && nDstBlend == UtilGL::States::BLEND_ZERO) ||
(nSrcBlend == UtilGL::States::BLEND_ZERO && nDstBlend == UtilGL::States::BLEND_ONE)))
{
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::ENABLED);
UtilGL::States::Set(UtilGL::States::SRCBLEND, nSrcBlend);
UtilGL::States::Set(UtilGL::States::DSTBLEND, nDstBlend);
}
else
{
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
}
UtilGL::States::Set(UtilGL::States::LIGHTING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFER, UtilGL::States::DISABLED);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_WORLD);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_VIEW);
UtilGL::Transforming::ClearMatrix(UtilGL::Transforming::MATRIX_PROJECTION);
glMatrixMode(GL_PROJECTION);
glOrtho(0, pTexture->GetWidth(), pTexture->GetHeight(), 0, 0.0f, 10.0f);
// Update ***********
int nImgTilesX = pTexture && valueTileSourceWidth.GetValue() > 0 ? pTexture->GetWidth() / valueTileSourceWidth.GetValue() : 1;
int nImgTilesY = pTexture && valueTileSourceHeight.GetValue() > 0 ? pTexture->GetHeight() / valueTileSourceHeight.GetValue() : 1;
float fChangePeriod = IS_ZERO(valueChangeFrequency.GetValue()) ? FLOAT_MAX : 1.0f / valueChangeFrequency.GetValue();
if(fChangePeriod < 0.0001f) fChangePeriod = 0.0001f;
while(MYFABSF(m_fLastUpdate - fEffectTime) > fChangePeriod)
{
int nRandTile = rand() % m_vecTiles.size();
m_vecTiles[nRandTile].nImgTileX = rand() % nImgTilesX;
m_vecTiles[nRandTile].nImgTileY = rand() % nImgTilesY;
if(fEffectTime < m_fLastUpdate)
{
m_fLastUpdate -= fChangePeriod;
}
else
{
m_fLastUpdate += fChangePeriod;
}
}
// Render ***********
VECTILES::iterator it;
float fUTileWidth = (float)valueTileSourceWidth.GetValue() / (float)pTexture->GetWidth();
float fVTileHeight = (float)valueTileSourceHeight.GetValue() / (float)pTexture->GetHeight();
int nTilesX = valueTilesX.GetValue() < 1 ? 1 : valueTilesX.GetValue();
int nTilesY = valueTilesY.GetValue() < 1 ? 1 : valueTilesY.GetValue();
for(it = m_vecTiles.begin(); it < m_vecTiles.end(); ++it)
{
STile tile = *it;
float fTileWidth = pTexture->GetWidth() / (float)nTilesX;
float fTileHeight = pTexture->GetHeight() / (float)nTilesY;
float fPosX = ((valuePosX.GetValue() - 0.5f) * pTexture->GetWidth()) + (fTileWidth * tile.nX);
float fPosY = ((valuePosY.GetValue() - 0.5f) * pTexture->GetHeight()) + (fTileHeight * tile.nY);
float fScaleX = valueWidth.GetValue() * valueScale.GetValue();
float fScaleY = valueHeight.GetValue() * valueScale.GetValue();
float fU = tile.nImgTileX * fUTileWidth;
float fV = 1.0f - (tile.nImgTileY * fVTileHeight);
float fU2 = fU + fUTileWidth;
float fV2 = fV - fVTileHeight;
CVector3 v3Center(pTexture->GetWidth() * 0.5f, pTexture->GetHeight() * 0.5f, -5.0f);
CMatrix worldMtx;
worldMtx.SetIdentity();
worldMtx.Translate(fPosX, fPosY, 0.0f);
worldMtx.Translate(-v3Center.X(), -v3Center.Y(), 0.0f);
worldMtx.Scale (fScaleX, fScaleY, 1.0f);
worldMtx.RotateZ (fAngle);
worldMtx.Translate(+v3Center.X(), +v3Center.Y(), 0.0f);
UtilGL::Transforming::SetMatrix(UtilGL::Transforming::MATRIX_WORLD, worldMtx);
glBegin(GL_QUADS);
glTexCoord2f(fU, fV);
glVertex3f(0.0f, 0.0f, -5.0f);
glTexCoord2f(fU, fV2);
glVertex3f(0.0f, fTileHeight, -5.0f);
glTexCoord2f(fU2, fV2);
glVertex3f(fTileWidth, fTileHeight, -5.0f);
glTexCoord2f(fU2, fV);
glVertex3f(fTileWidth, 0.0f, -5.0f);
glEnd();
}
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(60.0f, pDemo->GetAspect(), 1.0f, 1000.0f);
// Restore filtering
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
if(UtilGL::Extensions::GetAvailableExtensions()->EXT_texture_filter_anisotropic)
{
glGetFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fMaxAnisotropy);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fMaxAnisotropy);
}
UtilGL::States::Set(UtilGL::States::TEXTURE2D, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::BLENDING, UtilGL::States::DISABLED);
UtilGL::States::Set(UtilGL::States::ZBUFFER, UtilGL::States::ENABLED);
return true;
}
void SoXipDrawQuad::GLRender(SoGLRenderAction* action) {
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
glDisable(GL_LIGHTING);
if (blend.getValue()) {
glEnable(GL_BLEND);
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
//glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ONE);
}
if (enableTexture.getValue()) {
glEnable(GL_TEXTURE_2D);
}
GLint minFilter, magFilter;
GLint texFilter = filter.getValue();
if (texFilter != SAME) {
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, &minFilter);
glGetTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, &magFilter);
if (texFilter != minFilter)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, texFilter);
if (texFilter != magFilter)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, texFilter);
}
SbVec3f cornerColors[4];
const SbVec3f *pColors = colors.getValues(0);
if (colors.getNum() >= 4) {
cornerColors[0] = pColors[0];
cornerColors[1] = pColors[1];
cornerColors[2] = pColors[2];
cornerColors[3] = pColors[3];
}
else if (colors.getNum() >= 2) {
cornerColors[0] = pColors[0];
cornerColors[1] = pColors[0];
cornerColors[2] = pColors[1];
cornerColors[3] = pColors[1];
}
else if (colors.getNum() == 1) {
cornerColors[0] = pColors[0];
cornerColors[1] = pColors[0];
cornerColors[2] = pColors[0];
cornerColors[3] = pColors[0];
}
else {
cornerColors[0] = SbVec3f(0.0, 0.0, 0.0);
cornerColors[1] = SbVec3f(0.0, 0.0, 0.0);
cornerColors[2] = SbVec3f(0.0, 0.0, 0.0);
cornerColors[3] = SbVec3f(0.0, 0.0, 0.0);
}
glBegin(GL_TRIANGLE_STRIP);
glColor3fv(&(cornerColors[0][0]));
glTexCoord2f(0, 0);
glVertex3f(-1, -1, 0);
glColor3fv(&(cornerColors[1][0]));
glTexCoord2f(1, 0);
glVertex3f(1, -1, 0);
glColor3fv(&(cornerColors[2][0]));
glTexCoord2f(0, 1);
glVertex3f(-1, 1, 0);
glColor3fv(&(cornerColors[3][0]));
glTexCoord2f(1, 1);
glVertex3f(1, 1, 0);
glEnd();
if (texFilter != SAME) {
if (texFilter != minFilter)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter);
if (texFilter != magFilter)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter);
}
glPopAttrib();
}
void gl4es_glGetTextureParameteriv(GLuint texture, GLenum target, GLenum pname, GLint *params) {
text(glGetTexParameteriv(target, pname, params));
}
