void multidrawindirect_app::render(double currentTime)
{
int j;
static const float one = 1.0f;
static const float black[] = { 0.0f, 0.0f, 0.0f, 0.0f };
static double last_time = 0.0;
static double total_time = 0.0;
if (!paused)
total_time += (currentTime - last_time);
last_time = currentTime;
float t = float(total_time);
int i = int(total_time * 3.0f);
glViewport(0, 0, info.windowWidth, info.windowHeight);
glClearBufferfv(GL_COLOR, 0, black);
glClearBufferfv(GL_DEPTH, 0, &one);
const vmath::mat4 view_matrix = vmath::lookat(vmath::vec3(100.0f * cosf(t * 0.023f), 100.0f * cosf(t * 0.023f), 300.0f * sinf(t * 0.037f) - 600.0f),
vmath::vec3(0.0f, 0.0f, 260.0f),
vmath::normalize(vmath::vec3(0.1f - cosf(t * 0.1f) * 0.3f, 1.0f, 0.0f)));
const vmath::mat4 proj_matrix = vmath::perspective(50.0f,
(float)info.windowWidth / (float)info.windowHeight,
1.0f,
2000.0f);
glUseProgram(render_program);
glUniform1f(uniforms.time, t);
glUniformMatrix4fv(uniforms.view_matrix, 1, GL_FALSE, view_matrix);
glUniformMatrix4fv(uniforms.proj_matrix, 1, GL_FALSE, proj_matrix);
glUniformMatrix4fv(uniforms.viewproj_matrix, 1, GL_FALSE, proj_matrix * view_matrix);
glBindVertexArray(object.get_vao());
if (mode == MODE_MULTIDRAW)
{
glMultiDrawArraysIndirect(GL_TRIANGLES, NULL, NUM_DRAWS, 0);
}
else if (mode == MODE_SEPARATE_DRAWS)
{
for (j = 0; j < NUM_DRAWS; j++)
{
GLuint first, count;
object.get_sub_object_info(j % object.get_sub_object_count(), first, count);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES,
first,
count,
1, j);
}
}
}
bool testDrawArrays::render()
{
glm::vec2 const WindowSize(this->getWindowSize());
float Depth(1.0f);
glClearBufferfv(GL_DEPTH, 0, &Depth);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
{
glBindBuffer(GL_UNIFORM_BUFFER, this->BufferName[buffer::BUFFER_FRAME]);
glm::mat4* Pointer = reinterpret_cast<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, 1000.0f);
glm::mat4 View = this->view();
glm::mat4 Model = glm::mat4(1.0f);
glm::mat4 MVP = Projection * View * Model;
*Pointer = Projection * View * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedfv(0, &glm::vec4(0, 0, WindowSize)[0]);
this->beginTimer();
switch(this->DrawType)
{
case INSTANCED:
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, static_cast<GLsizei>(DrawCount), 0);
break;
case MULTI_DISCARD:
case MULTI_DRAW:
for(int i = 0; i < 2; ++i)
glMultiDrawArraysIndirect(GL_TRIANGLES, 0, static_cast<GLsizei>(DrawCount / 2), 0);
break;
case DRAW_PACKED:
for(std::size_t DrawIndex(0); DrawIndex < DrawCount; ++DrawIndex)
{
if(this->UniformUpdate != testDrawArrays::CONSTANT_UNIFORM && this->UniformUpdate != testDrawArrays::NO_UNIFORM)
::updateUniform(this->ProgramName, DrawIndex, this->UniformUpdate);
glDrawArrays(GL_TRIANGLES, static_cast<GLint>(this->VertexDataType == SEPARATED_VERTEX_DATA ? VertexCount * DrawIndex : 0), VertexCount);
}
break;
case DRAW_PARAMS:
for(std::size_t DrawIndex(0); DrawIndex < DrawCount; ++DrawIndex)
{
if(this->UniformUpdate != testDrawArrays::CONSTANT_UNIFORM && this->UniformUpdate != testDrawArrays::NO_UNIFORM)
::updateUniform(this->ProgramName, DrawIndex, this->UniformUpdate);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, static_cast<GLint>(this->VertexDataType == SEPARATED_VERTEX_DATA ? VertexCount * DrawIndex : 0), VertexCount, 1, 0);
}
break;
default:
assert(0);
break;
}
this->endTimer();
return true;
}
void render_big_ubo_indirect(double currentTime)
{
static const GLfloat purple[] = { 0.25f, 0.0f, 0.25f, 1.0f };
static const GLfloat one = 1.0f;
int i;
int j;
float f = (float)currentTime * 0.3f;
glViewport(0, 0, info.windowWidth, info.windowHeight);
glClearBufferfv(GL_COLOR, 0, purple);
glClearBufferfv(GL_DEPTH, 0, &one);
glUseProgram(ubo_plus_base_instance_program);
glBindBufferBase(GL_UNIFORM_BUFFER, 0, transform_ubo);
transform_t * transform = (transform_t *)glMapBufferRange(GL_UNIFORM_BUFFER, 0, NUM_CUBES * sizeof(transform_t), GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
for (i = 0; i < NUM_CUBES; i++)
{
float fi = 4.0f * (float)i / (float)NUM_CUBES;
fi = 0.0f;
transform[i].proj_matrix = vmath::perspective(50.0f,
(float)info.windowWidth / (float)info.windowHeight,
0.1f,
1000.0f);
transform[i].mv_matrix = vmath::translate(0.0f, 0.0f, -4.0f) *
vmath::translate(sinf(5.1f * f + fi) * 1.0f,
cosf(7.7f * f + fi) * 1.0f,
sinf(6.3f * f + fi) * cosf(1.5f * f + fi) * 2.0f) *
vmath::rotate(f * 45.0f + fi, 0.0f, 1.0f, 0.0f) *
vmath::rotate(f * 81.0f + fi, 1.0f, 0.0f, 0.0f);
}
glUnmapBuffer(GL_UNIFORM_BUFFER);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect_buffer);
for (j = 0; j < NUM_PASSES; j++)
{
glMultiDrawArraysIndirect(draw_triangles ? GL_TRIANGLES : GL_POINTS, NULL, NUM_CUBES, 0);
/*
for (i = 0; i < NUM_CUBES; i++)
{
glDrawArraysInstancedBaseInstance(draw_triangles ? GL_TRIANGLES : GL_POINTS, 0, 36, 1, i);
}
*/
}
}
void Asteroid::Render(GLfloat aspect)
{
float currentTime = glfwGetTime();
static double last_time = 0.0;
static double total_time = 0.0;
total_time += (currentTime - last_time);
last_time = currentTime;
float t = float(total_time);
int i = int(total_time * 3.0f);
glm::mat4 view_matrix = glm::lookAt(glm::vec3(100.0f * cosf(t * 0.023f), 100.0f * cosf(t * 0.023f), 300.0f * sinf(t * 0.037f) - 500.0f),
glm::vec3(0.0f, 0.0f, 260.0f),
glm::normalize(glm::vec3(0.1f - cosf(t * 0.1f) * 0.3f, 1.0f, 0.0f)));
glm::mat4 proj_matrix = glm::perspective(45.0f, aspect, 1.0f, 2000.0f);
glUseProgram(program);
glUniform1f(time_loc, t);
glUniformMatrix4fv(view_loc, 1, GL_FALSE, &view_matrix[0][0]);
glUniformMatrix4fv(proj_loc, 1, GL_FALSE, &proj_matrix[0][0]);
glUniformMatrix4fv(viewproj_loc, 1, GL_FALSE, &(proj_matrix * view_matrix)[0][0]);
glBindVertexArray(object.get_vao());
if (mode == MODE_MULTIDRAW)
{
glMultiDrawArraysIndirect(GL_TRIANGLES, NULL, NUM_DRAWS, 0);
}
else if (mode == MODE_SEPARATE_DRAWS)
{
for (int j = 0; j < NUM_DRAWS; j++)
{
GLuint first, count;
object.get_sub_object_info(j % object.get_sub_object_count(), first, count);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, first, count, 1, j);
}
}
glUseProgram(0);
}
void VertexArray::multiDrawArraysIndirect(const GLenum mode, const void* indirect, const GLsizei drawCount, const GLsizei stride) const
{
bind();
glMultiDrawArraysIndirect(mode, indirect, drawCount, stride);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawArraysIndirect(JNIEnv *__env, jclass clazz, jint mode, jlong indirectAddress, jint primcount, jint stride, jlong __functionAddress) {
const GLvoid *indirect = (const GLvoid *)(intptr_t)indirectAddress;
glMultiDrawArraysIndirectPROC glMultiDrawArraysIndirect = (glMultiDrawArraysIndirectPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glMultiDrawArraysIndirect(mode, indirect, primcount, stride);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawArraysIndirect__IJII(JNIEnv *__env, jclass clazz, jint mode, jlong indirectAddress, jint primcount, jint stride) {
glMultiDrawArraysIndirectPROC glMultiDrawArraysIndirect = (glMultiDrawArraysIndirectPROC)tlsGetFunction(894);
intptr_t indirect = (intptr_t)indirectAddress;
UNUSED_PARAM(clazz)
glMultiDrawArraysIndirect(mode, indirect, primcount, stride);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawArraysIndirectBO(JNIEnv *env, jclass clazz, jint mode, jlong indirect_buffer_offset, jint primcount, jint stride, jlong function_pointer) {
const GLvoid *indirect_address = (const GLvoid *)(intptr_t)offsetToPointer(indirect_buffer_offset);
glMultiDrawArraysIndirectPROC glMultiDrawArraysIndirect = (glMultiDrawArraysIndirectPROC)((intptr_t)function_pointer);
glMultiDrawArraysIndirect(mode, indirect_address, primcount, stride);
}
void VertexArrayObject::multiDrawArraysIndirect(GLenum mode, const void* indirect, GLsizei drawCount, GLsizei stride)
{
bind();
glMultiDrawArraysIndirect(mode, indirect, drawCount, stride);
CheckGLError();
}
void testDrawIndexing::render()
{
float Depth(1.0f);
glClearBufferfv(GL_DEPTH, 0, &Depth);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
{
glBindBuffer(GL_UNIFORM_BUFFER, this->BufferName[buffer::BUFFER_FRAME]);
glm::mat4* Pointer = reinterpret_cast<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, 4.0f / 3.0f, 0.1f, 2048.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -this->TranlationCurrent.y - 512));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, this->RotationCurrent.y, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, this->RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
*Pointer = Projection * View * Model;
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glViewportIndexedfv(0, &glm::vec4(0, 0, this->getWindowSize())[0]);
this->beginTimer();
switch(this->Indexing)
{
case DRAW:
case DIVISOR_MULTI_INDEXING:
case ID_INDEXING:
{
int const DrawChunk = 2;
for(int i = 0; i < DrawChunk; ++i)
glMultiDrawArraysIndirect(GL_TRIANGLES, 0, static_cast<GLsizei>(DrawCount / DrawChunk), 0);
}
case DIVISOR_INDEXING:
{
for(std::size_t DrawIndex(0); DrawIndex < DrawCount; ++DrawIndex)
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, static_cast<GLuint>(DrawIndex));
}
break;
case ATTRIB_INDEXING:
{
for(std::size_t DrawIndex(0); DrawIndex < DrawCount; ++DrawIndex)
{
glVertexAttribI1i(1, DrawIndex % 2 ? 0 : 1); // 1 is DRAW_ID attribute location
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
}
}
break;
case UNIFORM_INDEXING:
{
for(std::size_t DrawIndex(0); DrawIndex < DrawCount; ++DrawIndex)
{
glProgramUniform1i(this->ProgramName, UniformDrawIndex, DrawIndex % 2 ? 0 : 1);
glDrawArraysInstancedBaseInstance(GL_TRIANGLES, 0, VertexCount, 1, 0);
}
}
break;
default:
assert(0);
break;
}
this->endTimer();
}
Error operator()(GlState& state)
{
state.flushVertexState();
state.flushStencilState();
const BufferImpl& buff = *m_buff->m_impl;
ANKI_ASSERT(m_offset + sizeof(DrawArraysIndirectInfo) * m_drawCount <= buff.m_size);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buff.getGlName());
glMultiDrawArraysIndirect(
state.m_topology, numberToPtr<void*>(m_offset), m_drawCount, sizeof(DrawArraysIndirectInfo));
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
return ErrorCode::NONE;
}
