bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glm::mat4* Pointer = reinterpret_cast<glm::mat4*>(glMapNamedBufferRange(BufferName[buffer::TRANSFORM],
0, sizeof(glm::mat4), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT));
//glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, 640.f, 480.f, 0.1f, 100.0f);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapNamedBuffer(BufferName[buffer::TRANSFORM]);
}
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_UNSIGNED_BYTE, &glm::u8vec4(255, 255, 255, 255)[0]);
glClearTexImage(TextureName[texture::RENDERBUFFER], 0, GL_DEPTH_COMPONENT, GL_FLOAT, &glm::vec1(1.0)[0]);
glClearTexImage(TextureName[texture::INVOCATION_COUNT], 0, GL_RED_INTEGER, GL_UNSIGNED_INT, &glm::u32vec1(0)[0]);
glViewportIndexedf(0, 0, 0, WindowSize.x * FRAMEBUFFER_SCALE, WindowSize.y * FRAMEBUFFER_SCALE);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindImageTexture(0, TextureName[texture::INVOCATION_COUNT], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_R32UI);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 5, 0, 0);
glDisable(GL_DEPTH_TEST);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindImageTexture(0, TextureName[texture::INVOCATION_COUNT], 0, GL_FALSE, 0, GL_READ_ONLY, GL_R32UI);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
static void
clear_texture(GLuint tex)
{
/* Clear the entire texture to red */
glClearTexImage(tex,
0, /* level */
GL_RGBA,
GL_FLOAT,
red);
/* Clear two other sub-regions */
glClearTexSubImage(tex,
0, /* level */
ZERO_CLEAR_X, ZERO_CLEAR_Y, 0,
ZERO_CLEAR_WIDTH, ZERO_CLEAR_HEIGHT, 1,
GL_RGBA,
GL_UNSIGNED_BYTE,
NULL);
glClearTexSubImage(tex,
0, /* level */
VALUE_CLEAR_X, VALUE_CLEAR_Y, 0,
VALUE_CLEAR_WIDTH, VALUE_CLEAR_HEIGHT, 1,
GL_RGBA,
GL_FLOAT,
green);
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
// Make sure the uniform buffer is uploaded
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_FLOAT, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
// Bind rendering objects
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
for (std::size_t i = 0; i < this->Viewports.size(); ++i)
{
glViewportIndexedfv(0, &this->Viewports[i][0]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
glTextureBarrier();
}
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
enum piglit_result
piglit_display(void)
{
bool pass = true;
if (!piglit_check_gl_error(GL_NO_ERROR))
piglit_report_result(PIGLIT_FAIL);
/* Clear the whole first texture with green */
glClearTexImage(texture[0], 0, GL_RGB, GL_FLOAT, green);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* Clear the left half of the second texture with blue */
glClearTexSubImage(texture[1], 0,
0, 0, 0,
32, 64, 1,
GL_RGB, GL_FLOAT, blue);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* And the right half with yellow */
glClearTexSubImage(texture[1], 0,
32, 0, 0,
32, 64, 1,
GL_RGB, GL_FLOAT, yellow);
pass &= piglit_check_gl_error(GL_NO_ERROR);
/* Render both textures to the screen */
piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);
glBindFramebufferEXT(GL_FRAMEBUFFER_EXT, piglit_winsys_fbo);
glEnable(GL_TEXTURE_2D);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glBindTexture(GL_TEXTURE_2D, texture[0]);
piglit_draw_rect_tex(0, 0, 64, 64, 0, 0, 1, 1);
glBindTexture(GL_TEXTURE_2D, texture[1]);
piglit_draw_rect_tex(64, 0, 64, 64, 0, 0, 1, 1);
glDisable(GL_TEXTURE_2D);
glDeleteTextures(2, texture);
/* Check for the 3 separate regions */
pass &= piglit_probe_rect_rgb(0, 0, 64, 64, green);
pass &= piglit_probe_rect_rgb(64, 0, 32, 64, blue);
pass &= piglit_probe_rect_rgb(96, 0, 32, 64, yellow);
piglit_present_results();
return pass ? PIGLIT_PASS : PIGLIT_FAIL;
}
bool render()
{
glm::vec2 WindowSize(this->getWindowSize());
{
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(
GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4),
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspectiveFov(glm::pi<float>() * 0.25f, WindowSize.x, WindowSize.y, 0.1f, 100.0f);
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * this->view() * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
// Render
glClearTexImage(TextureName[texture::COLORBUFFER], 0, GL_RGBA, GL_FLOAT, &glm::vec4(1.0f, 0.5f, 0.0f, 1.0f)[0]);
glViewportIndexedf(0, 0, 0, WindowSize.x * this->Supersampling, WindowSize.y * this->Supersampling);
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
glBindSampler(0, this->SamplerName[pipeline::RENDER]);
glBindVertexArray(this->VertexArrayName[pipeline::RENDER]);
glBindProgramPipeline(PipelineName[pipeline::RENDER]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindImageTexture(semantic::image::DIFFUSE, TextureName[texture::COLORBUFFER], 0, GL_FALSE, 0, GL_WRITE_ONLY, GL_RGBA8);
glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glBindBufferBase(GL_SHADER_STORAGE_BUFFER, semantic::storage::VERTEX, BufferName[buffer::VERTEX]);
glDrawElementsInstancedBaseVertexBaseInstance(GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 1, 0, 0);
// Splash
glViewportIndexedf(0, 0, 0, WindowSize.x, WindowSize.y);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindSampler(0, this->SamplerName[pipeline::SPLASH]);
glBindVertexArray(this->VertexArrayName[pipeline::SPLASH]);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, 3, 1, 0);
return true;
}
void display()
{
{
// Compute the MVP (Model View Projection matrix)
float Aspect = (Window.Size.x * 0.50f) / (Window.Size.y * 0.50f);
glm::mat4 Projection = glm::perspective(45.0f, Aspect, 0.1f, 100.0f);
glm::mat4 ViewTranslateZ = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslateZ, Window.RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 ViewRotateY = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 View = ViewRotateY;
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
*UniformPointer = MVP;
}
glFlushMappedBufferRange(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4));
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
glViewportIndexedf(0, 0, 0, GLfloat(Window.Size.x), GLfloat(Window.Size.y));
glBindFramebuffer(GL_FRAMEBUFFER, FramebufferName);
float Depth(1.0f);
glm::u8vec4 ColorClear(255, 127, 0, 255);
glm::u8vec4 ColorTex(0, 127, 255, 255);
glClearBufferfv(GL_DEPTH , 0, &Depth);
glClearTexImage(TextureName[texture::COLORBUFFER], 0,
GL_RGBA, GL_UNSIGNED_BYTE, &ColorClear);
glClearTexSubImage(TextureName[texture::COLORBUFFER], 0,
64, 64, 0,
64, 64, 1,
GL_RGBA, GL_UNSIGNED_BYTE, &ColorTex);
glClearTexSubImage(TextureName[texture::COLORBUFFER], 0,
256, 0, 0,
64, 64, 1,
GL_RGBA, GL_UNSIGNED_BYTE, &ColorTex);
glClearTexSubImage(TextureName[texture::COLORBUFFER], 0,
128, 384, 0,
64, 64, 1,
GL_RGBA, GL_UNSIGNED_BYTE, &ColorTex);
glClearTexSubImage(TextureName[texture::COLORBUFFER], 0,
512, 256, 0,
64, 64, 1,
GL_RGBA, GL_UNSIGNED_BYTE, &ColorTex);
// Bind rendering objects
glBindProgramPipeline(PipelineName[pipeline::TEXTURE]);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::DIFFUSE]);
glBindVertexArray(VertexArrayName[pipeline::TEXTURE]);
glBindVertexBuffer(glf::semantic::buffer::STATIC, BufferName[buffer::VERTEX], 0, GLsizei(sizeof(glf::vertex_v2fv2f)));
glBindBufferBase(GL_UNIFORM_BUFFER, glf::semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]);
glDrawElementsInstancedBaseVertexBaseInstance(
GL_TRIANGLES, ElementCount, GL_UNSIGNED_SHORT, 0, 2, 0, 0);
glDisable(GL_DEPTH_TEST);
glBindFramebuffer(GL_FRAMEBUFFER, 0);
glBindProgramPipeline(PipelineName[pipeline::SPLASH]);
glActiveTexture(GL_TEXTURE0);
glBindVertexArray(VertexArrayName[pipeline::SPLASH]);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::COLORBUFFER]);
glDrawArraysInstanced(GL_TRIANGLES, 0, 3, 1);
glf::swapBuffers();
}
void Texture::clearImage(const GLint level, const GLenum format, const GLenum type, const void * data)
{
glClearTexImage(id(), level, format, type, data);
}
void GLTextureCubeMap::clear( const Vector4f& clearValue )
{
glClearTexImage( id(), 0, GL_RGBA, GL_FLOAT, &clearValue );
}
void GLTextureCubeMap::clear( float clearValue, GLImageFormat format )
{
glClearTexImage( id(), 0, static_cast< GLenum >( format ), GL_FLOAT,
&clearValue );
}
void GLTextureCubeMap::clear( const uint8x4& clearValue )
{
glClearTexImage( id(), 0, GL_RGBA, GL_UNSIGNED_BYTE, &clearValue );
}
void GSTextureOGL::Clear(const void* data)
{
glClearTexImage(m_texture_id, GL_TEX_LEVEL_0, m_int_format, m_int_type, data);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL44_nglClearTexImage(JNIEnv *env, jclass clazz, jint texture, jint level, jint format, jint type, jlong data, jlong function_pointer) {
const GLvoid *data_address = (const GLvoid *)(intptr_t)data;
glClearTexImagePROC glClearTexImage = (glClearTexImagePROC)((intptr_t)function_pointer);
glClearTexImage(texture, level, format, type, data_address);
}