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); }