Error operator()(GlState& state)
{
state.flushVertexState();
state.flushStencilState();
const BufferImpl& buff = *m_buff->m_impl;
ANKI_ASSERT(m_offset + sizeof(DrawElementsIndirectInfo) * m_drawCount <= buff.m_size);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, buff.getGlName());
GLenum indicesType = 0;
switch(state.m_indexSize)
{
case 2:
indicesType = GL_UNSIGNED_SHORT;
break;
case 4:
indicesType = GL_UNSIGNED_INT;
break;
default:
ANKI_ASSERT(0);
break;
};
glMultiDrawElementsIndirect(state.m_topology,
indicesType,
numberToPtr<void*>(m_offset),
m_drawCount,
sizeof(DrawElementsIndirectInfo));
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
return ErrorCode::NONE;
}
inline void multi_draw_elements_indirect(Primitive primitive, IndexType index_type, uint32 byte_offset,
uint32 draw_count, uint32 byte_stride)
{
ARC_GL_CLEAR_ERRORS();
glMultiDrawElementsIndirect((GLenum)primitive, (GLenum)index_type, (void*)byte_offset,
draw_count, byte_stride);
ARC_GL_CHECK_FOR_ERRORS();
}
void Display()
{
glClear( GL_COLOR_BUFFER_BIT );
glMultiDrawElementsIndirect( GL_TRIANGLES,
GL_UNSIGNED_INT,
(GLvoid*)0,
100,
0 );
glutSwapBuffers();
}
void MultiDrawIndirect::DrawMulti()
{
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, m_IndirectDrawBuffer);
glBindVertexArray(m_VertexArrayObject);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, NULL, m_GridSize * m_GridSize, 0);
glBindVertexArray(0);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, 0);
CHECK_GL_ERROR();
}
/** Draw glowing meshes.
* Faster than drawIndirect.
* Require OpenGL AZDO extensions
*/
void multidraw() const
{
InstancedColorizeShader::getInstance()->use();
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(irr::video::EVT_STANDARD,
InstanceTypeGlow));
if (m_size[0])
{
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[0] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[0],
sizeof(DrawElementsIndirectCommand));
}
} // multidraw
// --------------------------------------------------------------------------------------------------------------------
void TexturedQuadsGLTextureArrayMultiDrawBuffer::Render(const std::vector<Matrix>& _transforms)
{
// Program
Vec3 dir = { 0, 0, 1 };
Vec3 at = { 0, 0, 0 };
Vec3 up = { 0, 1, 0 };
dir = normalize(dir);
Vec3 eye = at - 250 * dir;
Matrix view = matrix_look_at(eye, at, up);
Matrix view_proj = mProj * view;
glUseProgram(mProgram);
glUniformMatrix4fv(mUniformLocation.ViewProjection, 1, GL_TRUE, &view_proj.x.x);
glUniform1iv(mUniformLocation.TexContainer, mTexUnits.size(), mTexUnits.data());
// Rasterizer State
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glFrontFace(GL_CCW);
glDisable(GL_SCISSOR_TEST);
// Blend State
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Depth Stencil State
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mTransformBuffer);
BufferData(GL_SHADER_STORAGE_BUFFER, _transforms, GL_DYNAMIC_DRAW);
size_t xformCount = _transforms.size();
assert(xformCount <= mObjectCount);
for (size_t u = 0; u < xformCount; ++u) {
DrawElementsIndirectCommand *cmd = &m_commands[u];
cmd->count = mIndexCount;
cmd->instanceCount = 1;
cmd->firstIndex = 0;
cmd->baseVertex = 0;
cmd->baseInstance = u;
}
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, mCommandBuffer);
glBufferData(GL_DRAW_INDIRECT_BUFFER, xformCount * sizeof(DrawElementsIndirectCommand), m_commands.data(), GL_DYNAMIC_DRAW);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, nullptr, xformCount, 0);
}
void multidraw(Uniforms...uniforms) const
{
if (m_size[T::MaterialType])
{
T::InstancedRSMShader::getInstance()->use();
T::InstancedRSMShader::getInstance()->setUniforms(uniforms...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeRSM));
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidraw
// --------------------------------------------------------------------------------------------------------------------
void UntexturedObjectsGLBufferStorage::Render(const std::vector<Matrix>& _transforms)
{
const auto objCount = m_commands.size();
const auto xformCount = _transforms.size();
assert(objCount == xformCount);
// Program
Vec3 dir = { -0.5f, -1, 1 };
Vec3 at = { 0, 0, 0 };
Vec3 up = { 0, 0, 1 };
dir = normalize(dir);
Vec3 eye = at - 250 * dir;
Matrix view = matrix_look_at(eye, at, up);
Matrix view_proj = mProj * view;
glUseProgram(m_prog);
glUniformMatrix4fv(mUniformLocation.ViewProjection, 1, GL_TRUE, &view_proj.x.x);
// Rasterizer State
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glDisable(GL_SCISSOR_TEST);
// Blend State
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Depth Stencil State
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
for (size_t u = 0; u < objCount; ++u)
{
DrawElementsIndirectCommand *cmd = &m_commands[u];
cmd->count = mIndexCount;
cmd->instanceCount = 1;
cmd->firstIndex = 0;
cmd->baseVertex = 0;
cmd->baseInstance = mUseShaderDrawParameters ? 0 : u;
}
memcpy(m_transform_ptr, &*_transforms.begin(), sizeof(Matrix) * xformCount);
memcpy(m_cmd_ptr, &*m_commands.begin(), sizeof(DrawElementsIndirectCommand) * objCount);
glMemoryBarrier(GL_CLIENT_MAPPED_BUFFER_BARRIER_BIT);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, nullptr, objCount, 0);
}
// --------------------------------------------------------------------------------------------------------------------
void UntexturedObjectsGLMultiDraw::Render(const std::vector<Matrix>& _transforms)
{
size_t count = _transforms.size();
assert(count <= m_commands.size());
// Program
Vec3 dir = { -0.5f, -1, 1 };
Vec3 at = { 0, 0, 0 };
Vec3 up = { 0, 0, 1 };
dir = normalize(dir);
Vec3 eye = at - 250 * dir;
Matrix view = matrix_look_at(eye, at, up);
Matrix view_proj = mProj * view;
glUseProgram(m_prog);
glUniformMatrix4fv(mUniformLocation.ViewProjection, 1, GL_TRUE, &view_proj.x.x);
// Rasterizer State
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glDisable(GL_SCISSOR_TEST);
// Blend State
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Depth Stencil State
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
for (size_t u = 0; u < count; ++u)
{
DrawElementsIndirectCommand *cmd = &m_commands[u];
cmd->count = mIndexCount;
cmd->instanceCount = 1;
cmd->firstIndex = 0;
cmd->baseVertex = 0;
cmd->baseInstance = mUseShaderDrawParameters ? 0 : u;
}
glBindBuffer(GL_SHADER_STORAGE_BUFFER, m_transform_buffer);
glBufferData(GL_SHADER_STORAGE_BUFFER, _transforms.size() * sizeof(Matrix), &*_transforms.begin(), GL_DYNAMIC_DRAW);
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, &*m_commands.begin(), count, 0);
}
void display()
{
// Selection of the indirect buffer to use
if(Window.KeyPressed[32] >= IndirectBufferCount)
Window.KeyPressed[32] = 0;
std::size_t const IndirectBufferIndex = Window.KeyPressed[32];
// Clear framebuffer
float Depth(1.0f);
glClearBufferfv(GL_DEPTH, 0, &Depth);
glClearBufferfv(GL_COLOR, 0, &glm::vec4(1.0f)[0]);
{
// Update the transformation matrix
glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]);
glm::mat4* Pointer = (glm::mat4*)glMapBufferRange(GL_UNIFORM_BUFFER, 0, sizeof(glm::mat4) * 3,
GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT);
glm::mat4 Projection = glm::perspective(45.0f, 4.0f / 3.0f, 0.1f, 100.0f);
glm::mat4 ViewTranslate = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -Window.TranlationCurrent.y));
glm::mat4 ViewRotateX = glm::rotate(ViewTranslate, Window.RotationCurrent.y + 45.0f, glm::vec3(1.f, 0.f, 0.f));
glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x + 45.0f, glm::vec3(0.f, 1.f, 0.f));
glm::mat4 Model = glm::mat4(1.0f);
*(Pointer + 0) = Projection * View * glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.5f));
*(Pointer + 1) = Projection * View * glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
*(Pointer + 2) = Projection * View * glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f,-0.5f));
glUnmapBuffer(GL_UNIFORM_BUFFER);
}
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::TEXTURE_A]);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::TEXTURE_B]);
glActiveTexture(GL_TEXTURE2);
glBindTexture(GL_TEXTURE_2D, TextureName[texture::TEXTURE_C]);
// Draw
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, BufferName[buffer::INDIRECT_A] + GLuint(IndirectBufferIndex));
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, 0, DrawCount[IndirectBufferIndex], sizeof(DrawElementsIndirectCommand));
// Swap framebuffers
glf::swapBuffers();
}
void multidrawShadow(unsigned cascade, Uniforms ...uniforms) const
{
int material_id = T::MaterialType + cascade * Material::SHADERTYPE_COUNT;
if (m_size[material_id])
{
T::InstancedShadowPassShader::getInstance()->use();
T::InstancedShadowPassShader::getInstance()->setUniforms(cascade, uniforms...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
InstanceTypeShadow));
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[material_id] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[material_id],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawShadow
void multidrawNormals() const
{
if (m_size[T::MaterialType])
{
NormalVisualizer::getInstance()->use();
NormalVisualizer::getInstance()->setUniforms(video::SColor(255, 0, 255, 0));
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidrawNormals
void multidraw2ndPass(const std::vector<uint64_t> &handles,
Uniforms... uniforms) const
{
if (m_size[T::MaterialType])
{
T::InstancedSecondPassShader::getInstance()->use();
T::InstancedSecondPassShader::getInstance()->setUniforms(uniforms...);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(T::VertexType,
T::Instance));
expandHandlesSecondPass<T>(handles);
glMultiDrawElementsIndirect(GL_TRIANGLES,
GL_UNSIGNED_SHORT,
(const void*)(m_offset[T::MaterialType] * sizeof(DrawElementsIndirectCommand)),
(int) m_size[T::MaterialType],
sizeof(DrawElementsIndirectCommand));
}
} // multidraw2ndPass
void Curvature::run(GLuint nbcells_reg, GLuint nbcells_tr, GLuint* nb_triangles_regular, GLuint* nb_triangles_transition, GLuint64* sync_time)
{
configureProgram();
if((int)Parameters::getInstance()->g_ground_truth == 2)
// glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_GTCURV]);
//else if((int)Parameters::getInstance()->g_ground_truth == 2)
glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_HIERARCHCURV]);
else if((int)Parameters::getInstance()->g_ground_truth == 1)
glUseProgram(Parameters::getInstance()->g_programs[PROGRAM_APPROXCURV]);
glBeginQuery(GL_PRIMITIVES_GENERATED, Parameters::getInstance()->g_query[QUERY_TRIANGLES]);
int res = (int)Parameters::getInstance()->g_tessel;
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, Parameters::getInstance()->g_buffers[BUFFER_INDIRECT_DRAWS]);
glBindVertexArray (Parameters::getInstance()->g_vertex_arrays[VERTEX_ARRAY_CURVATURE]);
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, Parameters::getInstance()->g_feedbacks[FEEDBACK_TRIANGULATION]);
if (!Parameters::getInstance()->g_lightmode)
{
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
0u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_TGL]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
1u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_DIRMIN]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
2u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_DIRMAX]
);
glBindBufferBase (
GL_TRANSFORM_FEEDBACK_BUFFER,
3u,
Parameters::getInstance()->g_buffers[BUFFER_EXPORT_NORMALES]
);
}
glBeginTransformFeedback(GL_TRIANGLES);
glMultiDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_INT,
NULL,
nbcells_reg*res*res*res,
0);
glEndQuery(GL_PRIMITIVES_GENERATED);
GLint64 start, stop;
glGetInteger64v(GL_TIMESTAMP, &start);
glGetQueryObjectuiv(Parameters::getInstance()->g_query[QUERY_TRIANGLES], GL_QUERY_RESULT, nb_triangles_regular);
glGetInteger64v(GL_TIMESTAMP, &stop);
//printf("After Curv %d\n", *nb_triangles_regular);
*sync_time = stop - start;
glBeginQuery(GL_PRIMITIVES_GENERATED, Parameters::getInstance()->g_query[QUERY_TRIANGLES]);
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, Parameters::getInstance()->g_buffers[BUFFER_INDIRECT_DRAWS_TR]);
glBindVertexArray (Parameters::getInstance()->g_vertex_arrays[VERTEX_ARRAY_CURVATURE_TR]);
glMultiDrawElementsIndirect(
GL_TRIANGLES,
GL_UNSIGNED_INT,
NULL,
nbcells_tr*res*res,
0);
glEndQuery(GL_PRIMITIVES_GENERATED);
glGetInteger64v(GL_TIMESTAMP, &start);
glGetQueryObjectuiv(Parameters::getInstance()->g_query[QUERY_TRIANGLES], GL_QUERY_RESULT, nb_triangles_transition);
glGetInteger64v(GL_TIMESTAMP, &stop);
glEndTransformFeedback();
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0);
glUseProgram(0);
*sync_time += (stop - start);
}
void VertexArray::multiDrawElementsIndirect(const GLenum mode, const GLenum type, const void* indirect, const GLsizei drawCount, const GLsizei stride) const
{
bind();
glMultiDrawElementsIndirect(mode, type, indirect, drawCount, stride);
}
void gfx::BasicRenderProgram::Draw(DrawData* data)
{
//draw
int flag = data->ShaderFlags;
g_ModelBank.ApplyBuffers( POS_NORMAL_TEX_TANGENT );
ShaderProgram* prog = g_ShaderBank.GetProgramFromHandle(m_ProgramHandle);
prog->Apply();
m_RenderJobManager->BindBuffers(prog);
GLint loc = -1;
if(flag & FRAGMENT_DIFFUSEMAP)
{
Texture* diffuse = g_MaterialBank.GetTextureAtlasTex(Texture_Atlas_Type::Diffuse);
loc = prog->FetchUniform("g_DiffuseTex");
diffuse->Apply(loc, 0);
prog->SetUniformBool("useDiffuse",true);
}
else
{
prog->SetUniformBool("useDiffuse",false);
}
if(flag & FRAGMENT_NORMALMAP)
{
Texture* normal = g_MaterialBank.GetTextureAtlasTex(Texture_Atlas_Type::Normal);
loc = prog->FetchUniform("g_NormalTex");
normal->Apply(loc, 1);
prog->SetUniformBool("useNormal",true);
}
else
{
prog->SetUniformBool("useNormal",false);
}
if(flag & FRAGMENT_ROUGHNESSMAP)
{
Texture* roughness = g_MaterialBank.GetTextureAtlasTex(Texture_Atlas_Type::Roughness);
loc = prog->FetchUniform("g_RoughnessTex");
roughness->Apply(loc, 2);
prog->SetUniformBool("useRoughness",true);
}
else
{
prog->SetUniformBool("useRoughness",false);
}
if(flag & FRAGMENT_METALMAP)
{
Texture* metal = g_MaterialBank.GetTextureAtlasTex(Texture_Atlas_Type::Metal);
loc = prog->FetchUniform("g_MetalTex");
metal->Apply(loc, 3);
prog->SetUniformBool("useMetal",true);
}
else
{
prog->SetUniformBool("useMetal",false);
}
BasicData* frameData = (BasicData*)(data->ExtraData);
prog->SetUniformInt("numPLights", frameData->PointLightCount);
prog->SetUniformInt("numDLights", frameData->DirLightCount);
prog->SetUniformUInt("BatchCounts",frameData->BatchOffset);
prog->SetUniformVec2("g_WorldSize", frameData->WorldSize);
prog->SetUniformMat4("ShadowMat",frameData->ShadowMat);
loc = prog->FetchUniform("g_LightCubeTex");
frameData->SkyTex->Apply(loc, 4);
loc = prog->FetchUniform("g_IrradianceCube");
frameData->IrradianceTex->Apply(loc, 5);
//fog tex
loc = prog->FetchUniform("g_FogOfWarTex");
glUniform1i(loc,6);
glActiveTexture(GL_TEXTURE6);
glBindTexture(GL_TEXTURE_2D, frameData->FogTex);
//fog tex
loc = prog->FetchUniform("g_ShadowMap");
glUniform1i(loc,7);
glActiveTexture(GL_TEXTURE7);
glBindTexture(GL_TEXTURE_2D, frameData->ShadowTex);
if (m_HasDrawID)
{
GPU_PROFILE( AutoGPUProfiler gpMultiDraw( "BasicRenderProgramMultiDrawElementsIndirect" ); );
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_INT, (GLvoid*)(sizeof(IndirectDrawCall) * (frameData->BatchOffset)), frameData->BatchCount, 0);
GPU_PROFILE( gpMultiDraw.Stop(); );
void IrrDriver::renderGlow(std::vector<GlowData>& glows)
{
m_scene_manager->setCurrentRendertime(scene::ESNRP_SOLID);
m_rtts->getFBO(FBO_TMP1_WITH_DS).Bind();
glClearStencil(0);
glClearColor(0, 0, 0, 0);
glClear(GL_STENCIL_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
const u32 glowcount = (int)glows.size();
glStencilOp(GL_KEEP, GL_KEEP, GL_REPLACE);
glStencilFunc(GL_ALWAYS, 1, ~0);
glEnable(GL_STENCIL_TEST);
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_BLEND);
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(EVT_STANDARD));
for (u32 i = 0; i < glowcount; i++)
{
const GlowData &dat = glows[i];
scene::ISceneNode * cur = dat.node;
STKMeshSceneNode *node = static_cast<STKMeshSceneNode *>(cur);
node->setGlowColors(SColor(0, (unsigned) (dat.b * 255.f), (unsigned)(dat.g * 255.f), (unsigned)(dat.r * 255.f)));
if (!CVS->supportsIndirectInstancingRendering())
node->render();
}
if (CVS->supportsIndirectInstancingRendering())
{
glBindBuffer(GL_DRAW_INDIRECT_BUFFER, GlowPassCmd::getInstance()->drawindirectcmd);
glUseProgram(MeshShader::InstancedColorizeShader::getInstance()->Program);
glBindVertexArray(VAOManager::getInstance()->getInstanceVAO(video::EVT_STANDARD, InstanceTypeGlow));
if (CVS->isAZDOEnabled())
{
if (GlowPassCmd::getInstance()->Size)
{
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT,
(const void*)(GlowPassCmd::getInstance()->Offset * sizeof(DrawElementsIndirectCommand)),
(int)GlowPassCmd::getInstance()->Size,
sizeof(DrawElementsIndirectCommand));
}
}
else
{
for (unsigned i = 0; i < ListInstancedGlow::getInstance()->size(); i++)
glDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, (const void*)((GlowPassCmd::getInstance()->Offset + i) * sizeof(DrawElementsIndirectCommand)));
}
}
glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
glDisable(GL_STENCIL_TEST);
glDisable(GL_BLEND);
// To half
FrameBuffer::Blit(irr_driver->getFBO(FBO_TMP1_WITH_DS), irr_driver->getFBO(FBO_HALF1), GL_COLOR_BUFFER_BIT, GL_LINEAR);
// To quarter
FrameBuffer::Blit(irr_driver->getFBO(FBO_HALF1), irr_driver->getFBO(FBO_QUARTER1), GL_COLOR_BUFFER_BIT, GL_LINEAR);
glEnable(GL_BLEND);
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glStencilFunc(GL_EQUAL, 0, ~0);
glEnable(GL_STENCIL_TEST);
m_rtts->getFBO(FBO_COLORS).Bind();
m_post_processing->renderGlow(m_rtts->getRenderTarget(RTT_QUARTER1));
glDisable(GL_STENCIL_TEST);
}
// --------------------------------------------------------------------------------------------------------------------
void TexturedQuadsGLBindlessMultiDraw::Render(const std::vector<Matrix>& _transforms)
{
// Program
Vec3 dir = { 0, 0, 1 };
Vec3 at = { 0, 0, 0 };
Vec3 up = { 0, 1, 0 };
dir = normalize(dir);
Vec3 eye = at - 250 * dir;
Matrix view = matrix_look_at(eye, at, up);
Matrix view_proj = mProj * view;
glUseProgram(mProgram);
glUniformMatrix4fv(0, 1, GL_TRUE, &view_proj.x.x);
// Input Layout. First the IB
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIndexBuffer);
// Then the VBs.
glBindBuffer(GL_ARRAY_BUFFER, mVertexBuffer);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, pos));
glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(TexturedQuadsProblem::Vertex), (void*)offsetof(TexturedQuadsProblem::Vertex, tex));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
// Rasterizer State
glEnable(GL_CULL_FACE);
glCullFace(GL_FRONT);
glFrontFace(GL_CCW);
glDisable(GL_SCISSOR_TEST);
// Blend State
glDisable(GL_BLEND);
glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);
// Depth Stencil State
glEnable(GL_DEPTH_TEST);
glDepthMask(GL_TRUE);
for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) {
glMakeTextureHandleResidentARB(*it);
}
glBindBuffer(GL_SHADER_STORAGE_BUFFER, mTransformBuffer);
BufferData(GL_SHADER_STORAGE_BUFFER, _transforms, GL_DYNAMIC_DRAW);
size_t xformCount = _transforms.size();
assert(xformCount <= mObjectCount);
for (size_t u = 0; u < xformCount; ++u) {
DrawElementsIndirectCommand *cmd = &mCommands[u];
cmd->count = mIndexCount;
cmd->instanceCount = 1;
cmd->firstIndex = 0;
cmd->baseVertex = 0;
cmd->baseInstance = 0;
}
glMultiDrawElementsIndirect(GL_TRIANGLES, GL_UNSIGNED_SHORT, &*mCommands.begin(), xformCount, 0);
for (auto it = mTexHandles.begin(); it != mTexHandles.end(); ++it) {
glMakeTextureHandleNonResidentARB(*it);
}
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawElementsIndirect(JNIEnv *__env, jclass clazz, jint mode, jint type, jlong indirectAddress, jint primcount, jint stride, jlong __functionAddress) {
const GLvoid *indirect = (const GLvoid *)(intptr_t)indirectAddress;
glMultiDrawElementsIndirectPROC glMultiDrawElementsIndirect = (glMultiDrawElementsIndirectPROC)(intptr_t)__functionAddress;
UNUSED_PARAMS(__env, clazz)
glMultiDrawElementsIndirect(mode, type, indirect, primcount, stride);
}
void VertexArrayObject::multiDrawElementsIndirect(GLenum mode, GLenum type, const void* indirect, GLsizei drawCount, GLsizei stride)
{
bind();
glMultiDrawElementsIndirect(mode, type, indirect, drawCount, stride);
CheckGLError();
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawElementsIndirect__IIJII(JNIEnv *__env, jclass clazz, jint mode, jint type, jlong indirectAddress, jint primcount, jint stride) {
glMultiDrawElementsIndirectPROC glMultiDrawElementsIndirect = (glMultiDrawElementsIndirectPROC)tlsGetFunction(895);
intptr_t indirect = (intptr_t)indirectAddress;
UNUSED_PARAM(clazz)
glMultiDrawElementsIndirect(mode, type, indirect, primcount, stride);
}
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL43_nglMultiDrawElementsIndirectBO(JNIEnv *env, jclass clazz, jint mode, jint type, jlong indirect_buffer_offset, jint primcount, jint stride, jlong function_pointer) {
const GLvoid *indirect_address = (const GLvoid *)(intptr_t)offsetToPointer(indirect_buffer_offset);
glMultiDrawElementsIndirectPROC glMultiDrawElementsIndirect = (glMultiDrawElementsIndirectPROC)((intptr_t)function_pointer);
glMultiDrawElementsIndirect(mode, type, indirect_address, primcount, stride);
}
