void ParticleSystem::UpdateParticles(int deltaTimeMillis){ glBindTexture(GL_TEXTURE_2D, mTexture); glEnable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, mParticleBuffer[mCurrVB]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTransformFeedback[mCurrTFB]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), 0); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4); glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)16); glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)28); glBeginTransformFeedback(GL_POINTS); if (mIsFirst){ glDrawArrays(GL_POINTS, 0, 1); mIsFirst = false; } else{ glDrawTransformFeedback(GL_POINTS, mTransformFeedback[mCurrVB]); } glEndTransformFeedback(); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); }
void FireWorkEffect::render(Pipeline& p, Renderer* r) { p.pushMatrix(); p.translate(m_position); p.addMatrix(m_rotation); p.scale(m_scale); r->setUniLocs(p); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currTFB]); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)4); // position glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currTFB]); glDisableVertexAttribArray(0); p.popMatrix(); m_currVB = m_currTFB; m_currTFB = (m_currTFB + 1) & 0x1; }
protected: void update(int dt) { mUpdateProgram->enable(); mUpdateProgram->setUniform("u_fTime", (float)mTime); mUpdateProgram->setUniform("u_fDeltaTime", (float)dt); mRandomTexture->bind(OGL_TEXTURE_GENERIC); glEnable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, mVBOs[mActiveVBO]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, mTBOs[mActiveTBO]); glBindVertexArray(mVAOs[0]); glBeginTransformFeedback(GL_POINTS); /////////////////////////////////////////////////////////////////////////// if(mFirst) { glDrawArrays(GL_POINTS, 0, 1); mFirst = false; } else { glDrawTransformFeedback(GL_POINTS, mTBOs[mActiveVBO]); } glEndTransformFeedback(); ////////////////////////////////////////////////////////////////////////////////////// // glExitIfError(); glBindVertexArray(0); glDisable(GL_RASTERIZER_DISCARD);
void Particles::update() { glEnable(GL_RASTERIZER_DISCARD); glBindVertexArray(m_vao[m_currVB]); GL_CHECK_ERRORS_MSG("Particles update 1"); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]); GL_CHECK_ERRORS_MSG("Particles update 2"); glBeginTransformFeedback(GL_POINTS); if (m_isFirst) { m_isFirst = false; glDrawArrays(GL_POINTS, 0, NUM_RAIN); GL_CHECK_ERRORS_MSG("Particles update 6"); } else { glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]); GL_CHECK_ERRORS_MSG("Particles update 7"); } glEndTransformFeedback(); GL_CHECK_ERRORS_MSG("Particles update 8"); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); glBindVertexArray(0); glDisable(GL_RASTERIZER_DISCARD); }
void IndexMap::predictIndices(const Eigen::Matrix4f & pose, const int & time, const std::pair<GLuint, GLuint> & model, const float depthCutoff, const int timeDelta) { indexFrameBuffer.Bind(); glPushAttrib(GL_VIEWPORT_BIT); glViewport(0, 0, indexRenderBuffer.width, indexRenderBuffer.height); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); indexProgram->Bind(); Eigen::Matrix4f t_inv = pose.inverse(); Eigen::Vector4f cam(Intrinsics::getInstance().cx() * IndexMap::FACTOR, Intrinsics::getInstance().cy() * IndexMap::FACTOR, Intrinsics::getInstance().fx() * IndexMap::FACTOR, Intrinsics::getInstance().fy() * IndexMap::FACTOR); indexProgram->setUniform(Uniform("t_inv", t_inv)); indexProgram->setUniform(Uniform("cam", cam)); indexProgram->setUniform(Uniform("maxDepth", depthCutoff)); indexProgram->setUniform(Uniform("cols", (float)Resolution::getInstance().cols() * IndexMap::FACTOR)); indexProgram->setUniform(Uniform("rows", (float)Resolution::getInstance().rows() * IndexMap::FACTOR)); indexProgram->setUniform(Uniform("time", time)); indexProgram->setUniform(Uniform("timeDelta", timeDelta)); glBindBuffer(GL_ARRAY_BUFFER, model.first); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glDrawTransformFeedback(GL_POINTS, model.second); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); indexFrameBuffer.Unbind(); indexProgram->Unbind(); glPopAttrib(); glFinish(); }
void Particles::renderParticles() { glBindVertexArray(m_vao[m_currTFB]); GL_CHECK_ERRORS_MSG("Billboard render#3"); glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currTFB]); GL_CHECK_ERRORS_MSG("Billboard render#4"); glBindVertexArray(0); GL_CHECK_ERRORS_MSG("After Billboard render"); }
void GlobalModel::renderPointCloud(pangolin::OpenGlMatrix mvp, const float threshold, const bool drawUnstable, const bool drawNormals, const bool drawColors, const bool drawPoints, const bool drawWindow, const bool drawTimes, const int time, const int timeDelta) { std::shared_ptr<Shader> program = drawPoints ? drawProgram : drawSurfelProgram; program->Bind(); program->setUniform(Uniform("MVP", mvp)); program->setUniform(Uniform("threshold", threshold)); program->setUniform(Uniform("colorType", (drawNormals ? 1 : drawColors ? 2 : drawTimes ? 3 : 0))); program->setUniform(Uniform("unstable", drawUnstable)); program->setUniform(Uniform("drawWindow", drawWindow)); program->setUniform(Uniform("time", time)); program->setUniform(Uniform("timeDelta", timeDelta)); Eigen::Matrix4f pose = Eigen::Matrix4f::Identity(); //This is for the point shader program->setUniform(Uniform("pose", pose)); glBindBuffer(GL_ARRAY_BUFFER, vbos[target].first); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 1)); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glDrawTransformFeedback(GL_POINTS, vbos[target].second); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); program->Unbind(); }
void ParticleSystem::RenderParticles(const glm::mat4x4& mvp, const glm::vec3& camPos){ glUseProgram(mSpriteShader.GetHandle()); mSpriteShader.UpdateUniforms(camPos, mvp); //glBindTexture(GL_TEXTURE_1D,m) glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, mParticleBuffer[mCurrTFB]); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4); glDrawTransformFeedback(GL_POINTS, mTransformFeedback[mCurrTFB]); glDisableVertexAttribArray(0); }
void FireWorkEffect::update(Pipeline& p, Renderer* r) { // m_randomTexture.Bind(RANDOM_TEXTURE_UNIT); p.pushMatrix(); r->setUniLocs(p); // We have another draw call later on that does that. // Calling glEnable() with the GL_RASTERIZER_DISCARD flag // tells the pipeline to discard all primitives before // they reach the rasterizer (but after the optional transform feedback stage). glEnable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currVB]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), 0); // type glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)4); // position glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)16); // velocity glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)28); // lifetime glBeginTransformFeedback(GL_POINTS); // first drawing function, since we know we're drawing one point if (m_isFirst) { glDrawArrays(GL_POINTS, 0, 1); m_isFirst = false; } else { glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]); } glEndTransformFeedback(); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); glDisable(GL_RASTERIZER_DISCARD); p.popMatrix(); }
void GlobalModel::initialise(const FeedbackBuffer & rawFeedback, const FeedbackBuffer & filteredFeedback) { initProgram->Bind(); glBindBuffer(GL_ARRAY_BUFFER, rawFeedback.vbo); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f))); glBindBuffer(GL_ARRAY_BUFFER, filteredFeedback.vbo); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glEnable(GL_RASTERIZER_DISCARD); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[target].second); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[target].first); glBeginTransformFeedback(GL_POINTS); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, countQuery); //It's ok to use either fid because both raw and filtered have the same amount of vertices glDrawTransformFeedback(GL_POINTS, rawFeedback.fid); glEndTransformFeedback(); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glGetQueryObjectuiv(countQuery, GL_QUERY_RESULT, &count); glDisable(GL_RASTERIZER_DISCARD); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); initProgram->Unbind(); glFinish(); }
void FireWorkEffect::renderParticles() { glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, m_textureId); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currTFB]); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(FireWorkParticle), (const GLvoid*)4); // position glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currTFB]); glDisableVertexAttribArray(0); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); // Compute the MVP (Model View Projection matrix) { glBindBuffer(GL_UNIFORM_BUFFER, BufferName[buffer::TRANSFORM]); 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, 100.0f); glm::mat4 Model = glm::mat4(1.0f); *Pointer = Projection * this->view() * Model; glUnmapBuffer(GL_UNIFORM_BUFFER); } // Set the display viewport glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); // Clear color buffer glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // First draw, capture the attributes // Disable rasterisation, vertices processing only! glEnable(GL_RASTERIZER_DISCARD); glUseProgram(TransformProgramName); glBindVertexArray(TransformVertexArrayName); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); glBeginTransformFeedback(GL_TRIANGLES); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndTransformFeedback(); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); glDisable(GL_RASTERIZER_DISCARD); // Second draw, reuse the captured attributes glUseProgram(FeedbackProgramName); glBindVertexArray(FeedbackVertexArrayName); glDrawTransformFeedback(GL_TRIANGLES, FeedbackName); return true; }
void render() { mRenderProgram->enable(); mRenderProgram->setUniform("u_vCameraPosition", mCameraPosition); mRenderProgram->setUniform("u_mVP", mProjectionMatrix * mViewMatrix); mDiffuseTexture->bind(OGL_TEXTURE_DIFFUSE); glBindBuffer(GL_ARRAY_BUFFER, mVBOs[mActiveTBO]); glBindVertexArray(mVAOs[1]); glDrawTransformFeedback(GL_POINTS, mTBOs[mActiveTBO]); // glExitIfError(); glBindVertexArray(0);
void ParticleSystem::UpdateParticles(int DeltaTimeMillis) { m_updateTechnique.Enable(); m_updateTechnique.SetTime(m_time); m_updateTechnique.SetDeltaTimeMillis(DeltaTimeMillis); m_updateTechnique.SetRandomColor(); m_randomTexture.Bind(GL_TEXTURE3); glEnable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currVB]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_transformFeedback[m_currTFB]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glEnableVertexAttribArray(4); glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), 0); // type glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4); // position glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)16); // velocity glVertexAttribPointer(3, 1, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)28); // lifetime glVertexAttribPointer(4, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)40); // color glBeginTransformFeedback(GL_POINTS); if (m_isFirst) { glDrawArrays(GL_POINTS, 0, 1); m_isFirst = false; } else { glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currVB]); } glEndTransformFeedback(); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); glDisableVertexAttribArray(4); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); { glm::mat4 Model = glm::mat4(1.0f); glm::mat4 Projection = glm::perspective(glm::pi<float>() * 0.25f, WindowSize.x / WindowSize.y, 0.1f, 100.0f); glm::mat4 MVP = Projection * this->view() * Model; *UniformPointer = MVP; } // Set the display viewport glViewportIndexedf(0, 0.0f, 0.0f, WindowSize.x, WindowSize.y); // Clear color buffer glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // First draw, capture the attributes // Disable rasterisation, vertices processing only! glEnable(GL_RASTERIZER_DISCARD); glBindProgramPipeline(PipelineName[program::TRANSFORM]); glBindBufferBase(GL_UNIFORM_BUFFER, semantic::uniform::TRANSFORM0, BufferName[buffer::TRANSFORM]); glBindVertexArray(VertexArrayName[program::TRANSFORM]); glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::VERTEX], 0, sizeof(glm::vec4)); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); glBeginTransformFeedback(GL_TRIANGLES); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndTransformFeedback(); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); glDisable(GL_RASTERIZER_DISCARD); // Second draw, reuse the captured attributes glBindProgramPipeline(PipelineName[program::FEEDBACK]); glBindVertexArray(VertexArrayName[program::FEEDBACK]); glBindVertexBuffer(semantic::buffer::STATIC, BufferName[buffer::FEEDBACK], 0, sizeof(glf::vertex_v4fc4f)); glDrawTransformFeedback(GL_TRIANGLES, FeedbackName); return true; }
void ParticleSystem::renderParticles() { glBindVertexArray(vao); auto vp = Engine::getEngine()->graphics->projection * Engine::getEngine()->graphics->view; render_prog->bind(); render_prog->set("camera_pos", Engine::getEngine()->graphics->camera->getPos()); render_prog->set("vp", vp); if(texture) texture->bind(COLOR_TEXTURE_UNIT); glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, particleBuffer[currTFB]); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (void*)4); // position glDrawTransformFeedback(GL_POINTS, transformFeedback[currTFB]); glDisableVertexAttribArray(0); glBindVertexArray(0); }
void ParticleSystem::RenderParticles(const Matrix4f& VP, const Vector3f& CameraPos) { m_billboardTechnique.Enable(); m_billboardTechnique.SetCameraPosition(CameraPos); m_billboardTechnique.SetVP(VP); m_pTexture->Bind(COLOR_TEXTURE_UNIT); glDisable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, m_particleBuffer[m_currTFB]); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(Particle), (const GLvoid*)4); // position glDrawTransformFeedback(GL_POINTS, m_transformFeedback[m_currTFB]); glDisableVertexAttribArray(0); }
void display() { // Compute the MVP (Model View Projection matrix) 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, glm::vec3(1.f, 0.f, 0.f)); glm::mat4 View = glm::rotate(ViewRotateX, Window.RotationCurrent.x, glm::vec3(0.f, 1.f, 0.f)); glm::mat4 Model = glm::mat4(1.0f); glm::mat4 MVP = Projection * View * Model; // Set the display viewport glViewport(0, 0, Window.Size.x, Window.Size.y); // Clear color buffer glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // First draw, capture the attributes // Disable rasterisation, vertices processing only! glEnable(GL_RASTERIZER_DISCARD); glUseProgram(TransformProgramName); glUniformMatrix4fv(TransformUniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindVertexArray(TransformVertexArrayName); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); glBeginTransformFeedback(GL_TRIANGLES); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndTransformFeedback(); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); glDisable(GL_RASTERIZER_DISCARD); // Second draw, reuse the captured attributes glUseProgram(FeedbackProgramName); glBindVertexArray(FeedbackVertexArrayName); glDrawTransformFeedback(GL_TRIANGLES, FeedbackName); glf::swapBuffers(); }
bool render() { glm::vec2 WindowSize(this->getWindowSize()); // Compute the MVP (Model View Projection matrix) 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); glm::mat4 MVP = Projection * this->view() * Model; // Set the display viewport glViewport(0, 0, static_cast<GLsizei>(WindowSize.x), static_cast<GLsizei>(WindowSize.y)); // Clear color buffer glClearBufferfv(GL_COLOR, 0, &glm::vec4(0.0f, 0.0f, 0.0f, 1.0f)[0]); // First draw, capture the attributes // Disable rasterisation, vertices processing only! glEnable(GL_RASTERIZER_DISCARD); glUseProgram(TransformProgramName); glUniformMatrix4fv(TransformUniformMVP, 1, GL_FALSE, &MVP[0][0]); glBindVertexArray(TransformVertexArrayName); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, FeedbackName); glBeginTransformFeedback(GL_TRIANGLES); glDrawArraysInstanced(GL_TRIANGLES, 0, VertexCount, 1); glEndTransformFeedback(); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); glDisable(GL_RASTERIZER_DISCARD); // Second draw, reuse the captured attributes glUseProgram(FeedbackProgramName); glBindVertexArray(FeedbackVertexArrayName); glDrawTransformFeedback(GL_TRIANGLES, FeedbackName); return true; }
void ParticleSystem::updateParticles(float dt) { glBindVertexArray(vao); update_prog->bind(); update_prog->set("time", time); update_prog->set("dt", dt * 1000.0f); random_texture->bind(RANDOM_TEXTURE_UNIT); glEnable(GL_RASTERIZER_DISCARD); glBindBuffer(GL_ARRAY_BUFFER, particleBuffer[currVB]); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, transformFeedback[currTFB]); glEnableVertexAttribArray(0); glEnableVertexAttribArray(1); glEnableVertexAttribArray(2); glEnableVertexAttribArray(3); glVertexAttribPointer(0,1,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 0); // type glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 4); // position glVertexAttribPointer(2,3,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 16); // velocity glVertexAttribPointer(3,1,GL_FLOAT,GL_FALSE,sizeof(Particle),(void*) 28); // lifetime glBeginTransformFeedback(GL_POINTS); if (isFirst) { glDrawArrays(GL_POINTS, 0, 1); isFirst = false; } else { glDrawTransformFeedback(GL_POINTS, transformFeedback[currVB]); } glEndTransformFeedback(); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glDisableVertexAttribArray(3); }
JNIEXPORT void JNICALL Java_org_lwjgl_opengl_GL40_nglDrawTransformFeedback(JNIEnv *__env, jclass clazz, jint mode, jint id, jlong __functionAddress) { glDrawTransformFeedbackPROC glDrawTransformFeedback = (glDrawTransformFeedbackPROC)(intptr_t)__functionAddress; UNUSED_PARAMS(__env, clazz) glDrawTransformFeedback(mode, id); }
void GlobalModel::fuse(const Eigen::Matrix4f & pose, const int & time, GPUTexture * rgb, GPUTexture * depthRaw, GPUTexture * depthFiltered, GPUTexture * indexMap, GPUTexture * vertConfMap, GPUTexture * colorTimeMap, GPUTexture * normRadMap, const float depthCutoff, const float confThreshold, const float weighting) { TICK("Fuse::Data"); //This first part does data association and computes the vertex to merge with, storing //in an array that sets which vertices to update by index frameBuffer.Bind(); glPushAttrib(GL_VIEWPORT_BIT); glViewport(0, 0, renderBuffer.width, renderBuffer.height); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); dataProgram->Bind(); dataProgram->setUniform(Uniform("cSampler", 0)); dataProgram->setUniform(Uniform("drSampler", 1)); dataProgram->setUniform(Uniform("drfSampler", 2)); dataProgram->setUniform(Uniform("indexSampler", 3)); dataProgram->setUniform(Uniform("vertConfSampler", 4)); dataProgram->setUniform(Uniform("colorTimeSampler", 5)); dataProgram->setUniform(Uniform("normRadSampler", 6)); dataProgram->setUniform(Uniform("time", (float)time)); dataProgram->setUniform(Uniform("weighting", weighting)); dataProgram->setUniform(Uniform("cam", Eigen::Vector4f(Intrinsics::getInstance().cx(), Intrinsics::getInstance().cy(), 1.0 / Intrinsics::getInstance().fx(), 1.0 / Intrinsics::getInstance().fy()))); dataProgram->setUniform(Uniform("cols", (float)Resolution::getInstance().cols())); dataProgram->setUniform(Uniform("rows", (float)Resolution::getInstance().rows())); dataProgram->setUniform(Uniform("scale", (float)IndexMap::FACTOR)); dataProgram->setUniform(Uniform("texDim", (float)TEXTURE_DIMENSION)); dataProgram->setUniform(Uniform("pose", pose)); dataProgram->setUniform(Uniform("maxDepth", depthCutoff)); glEnableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, uvo); glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, 0); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, newUnstableFid); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, newUnstableVbo); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, rgb->texture->tid); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, depthRaw->texture->tid); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, depthFiltered->texture->tid); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, indexMap->texture->tid); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, vertConfMap->texture->tid); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, colorTimeMap->texture->tid); glActiveTexture(GL_TEXTURE6); glBindTexture(GL_TEXTURE_2D, normRadMap->texture->tid); glBeginTransformFeedback(GL_POINTS); glDrawArrays(GL_POINTS, 0, uvSize); glEndTransformFeedback(); frameBuffer.Unbind(); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); glDisableVertexAttribArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); dataProgram->Unbind(); glPopAttrib(); glFinish(); TOCK("Fuse::Data"); TICK("Fuse::Update"); //Next we update the vertices at the indexes stored in the update textures //Using a transform feedback conditional on a texture sample updateProgram->Bind(); updateProgram->setUniform(Uniform("vertSamp", 0)); updateProgram->setUniform(Uniform("colorSamp", 1)); updateProgram->setUniform(Uniform("normSamp", 2)); updateProgram->setUniform(Uniform("texDim", (float)TEXTURE_DIMENSION)); updateProgram->setUniform(Uniform("time", time)); glBindBuffer(GL_ARRAY_BUFFER, vbos[target].first); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glEnable(GL_RASTERIZER_DISCARD); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[renderSource].second); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[renderSource].first); glBeginTransformFeedback(GL_POINTS); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, updateMapVertsConfs.texture->tid); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, updateMapColorsTime.texture->tid); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, updateMapNormsRadii.texture->tid); glDrawTransformFeedback(GL_POINTS, vbos[target].second); glEndTransformFeedback(); glDisable(GL_RASTERIZER_DISCARD); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); updateProgram->Unbind(); std::swap(target, renderSource); glFinish(); TOCK("Fuse::Update"); }
void GlobalModel::clean(const Eigen::Matrix4f & pose, const int & time, GPUTexture * indexMap, GPUTexture * vertConfMap, GPUTexture * colorTimeMap, GPUTexture * normRadMap, GPUTexture * depthMap, const float confThreshold, std::vector<float> & graph, const int timeDelta, const float maxDepth, const bool isFern) { assert(graph.size() / 16 < MAX_NODES); if(graph.size() > 0) { //Can be optimised by only uploading new nodes with offset glBindTexture(GL_TEXTURE_2D, deformationNodes.texture->tid); glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, graph.size(), 1, GL_LUMINANCE, GL_FLOAT, graph.data()); } TICK("Fuse::Copy"); //Next we copy the new unstable vertices from the newUnstableFid transform feedback into the global map unstableProgram->Bind(); unstableProgram->setUniform(Uniform("time", time)); unstableProgram->setUniform(Uniform("confThreshold", confThreshold)); unstableProgram->setUniform(Uniform("scale", (float)IndexMap::FACTOR)); unstableProgram->setUniform(Uniform("indexSampler", 0)); unstableProgram->setUniform(Uniform("vertConfSampler", 1)); unstableProgram->setUniform(Uniform("colorTimeSampler", 2)); unstableProgram->setUniform(Uniform("normRadSampler", 3)); unstableProgram->setUniform(Uniform("nodeSampler", 4)); unstableProgram->setUniform(Uniform("depthSampler", 5)); unstableProgram->setUniform(Uniform("nodes", (float)(graph.size() / 16))); unstableProgram->setUniform(Uniform("nodeCols", (float)NODE_TEXTURE_DIMENSION)); unstableProgram->setUniform(Uniform("timeDelta", timeDelta)); unstableProgram->setUniform(Uniform("maxDepth", maxDepth)); unstableProgram->setUniform(Uniform("isFern", (int)isFern)); Eigen::Matrix4f t_inv = pose.inverse(); unstableProgram->setUniform(Uniform("t_inv", t_inv)); unstableProgram->setUniform(Uniform("cam", Eigen::Vector4f(Intrinsics::getInstance().cx(), Intrinsics::getInstance().cy(), Intrinsics::getInstance().fx(), Intrinsics::getInstance().fy()))); unstableProgram->setUniform(Uniform("cols", (float)Resolution::getInstance().cols())); unstableProgram->setUniform(Uniform("rows", (float)Resolution::getInstance().rows())); glBindBuffer(GL_ARRAY_BUFFER, vbos[target].first); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glEnable(GL_RASTERIZER_DISCARD); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, vbos[renderSource].second); glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, vbos[renderSource].first); glBeginTransformFeedback(GL_POINTS); glActiveTexture(GL_TEXTURE0); glBindTexture(GL_TEXTURE_2D, indexMap->texture->tid); glActiveTexture(GL_TEXTURE1); glBindTexture(GL_TEXTURE_2D, vertConfMap->texture->tid); glActiveTexture(GL_TEXTURE2); glBindTexture(GL_TEXTURE_2D, colorTimeMap->texture->tid); glActiveTexture(GL_TEXTURE3); glBindTexture(GL_TEXTURE_2D, normRadMap->texture->tid); glActiveTexture(GL_TEXTURE4); glBindTexture(GL_TEXTURE_2D, deformationNodes.texture->tid); glActiveTexture(GL_TEXTURE5); glBindTexture(GL_TEXTURE_2D, depthMap->texture->tid); glBeginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, countQuery); glDrawTransformFeedback(GL_POINTS, vbos[target].second); glBindBuffer(GL_ARRAY_BUFFER, newUnstableVbo); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f))); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glDrawTransformFeedback(GL_POINTS, newUnstableFid); glEndQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN); glGetQueryObjectuiv(countQuery, GL_QUERY_RESULT, &count); glEndTransformFeedback(); glDisable(GL_RASTERIZER_DISCARD); glBindTexture(GL_TEXTURE_2D, 0); glActiveTexture(GL_TEXTURE0); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, 0); unstableProgram->Unbind(); std::swap(target, renderSource); glFinish(); TOCK("Fuse::Copy"); }
void IndexMap::synthesizeInfo(const Eigen::Matrix4f & pose, const std::pair<GLuint, GLuint> & model, const float depthCutoff, const float confThreshold) { glEnable(GL_PROGRAM_POINT_SIZE); glEnable(GL_POINT_SPRITE); infoFrameBuffer.Bind(); glPushAttrib(GL_VIEWPORT_BIT); glViewport(0, 0, infoRenderBuffer.width, infoRenderBuffer.height); glClearColor(0, 0, 0, 0); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); combinedProgram->Bind(); Eigen::Matrix4f t_inv = pose.inverse(); Eigen::Vector4f cam(Intrinsics::getInstance().cx(), Intrinsics::getInstance().cy(), Intrinsics::getInstance().fx(), Intrinsics::getInstance().fy()); combinedProgram->setUniform(Uniform("t_inv", t_inv)); combinedProgram->setUniform(Uniform("cam", cam)); combinedProgram->setUniform(Uniform("maxDepth", depthCutoff)); combinedProgram->setUniform(Uniform("confThreshold", confThreshold)); combinedProgram->setUniform(Uniform("cols", (float)Resolution::getInstance().cols())); combinedProgram->setUniform(Uniform("rows", (float)Resolution::getInstance().rows())); combinedProgram->setUniform(Uniform("time", 0)); combinedProgram->setUniform(Uniform("maxTime", std::numeric_limits<int>::max())); combinedProgram->setUniform(Uniform("timeDelta", std::numeric_limits<int>::max())); glBindBuffer(GL_ARRAY_BUFFER, model.first); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, 0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 1)); glEnableVertexAttribArray(2); glVertexAttribPointer(2, 4, GL_FLOAT, GL_FALSE, Vertex::SIZE, reinterpret_cast<GLvoid*>(sizeof(Eigen::Vector4f) * 2)); glDrawTransformFeedback(GL_POINTS, model.second); glDisableVertexAttribArray(0); glDisableVertexAttribArray(1); glDisableVertexAttribArray(2); glBindBuffer(GL_ARRAY_BUFFER, 0); infoFrameBuffer.Unbind(); combinedProgram->Unbind(); glDisable(GL_PROGRAM_POINT_SIZE); glDisable(GL_POINT_SPRITE); glPopAttrib(); glFinish(); }