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