/** * @brief Render the mesh given a camera and light, using a Phong shader
* @param mesh Given mesh
* @param camera Given camera
* @param lightTrackball Given light camera
*/
void render (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
tftest_shader.bind();
// sets all uniform variables for the phong shader
tftest_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
tftest_shader.setUniform("modelMatrix", mesh.getModelMatrix());
tftest_shader.setUniform("viewMatrix", camera.getViewMatrix());
tftest_shader.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
tftest_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));
tftest_shader.setUniform("default_color", default_color);
tftest_shader.setUniform("tf", 1.0);
cout << "set attrib TF\n";
mesh.setAttributeLocation(tftest_shader);
glEnable(GL_RASTERIZER_DISCARD);
mesh.bindBuffers();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, mesh.getAttribute("nPos")->getBufferID());
glBeginTransformFeedback(GL_POINTS);
glEnable(GL_DEPTH_TEST);
mesh.renderPoints();
glEndTransformFeedback();
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, 0);
mesh.unbindBuffers();
glDisable(GL_RASTERIZER_DISCARD);
tftest_shader.unbind();
printActiveAttribs(tftest_shader.getShaderProgram(), "TF");
printActiveAttribs(tfrender.getShaderProgram(), "RENDER");
// RENDERING
tfrender.bind();
// sets all uniform variables for the phong shader
tfrender.setUniform("projectionMatrix", camera.getProjectionMatrix());
tfrender.setUniform("modelMatrix", mesh.getModelMatrix());
tfrender.setUniform("viewMatrix", camera.getViewMatrix());
tfrender.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
tfrender.setUniform("has_color", mesh.hasAttribute("in_Color"));
tfrender.setUniform("default_color", default_color);
// tfrender.setUniform("tf", 1.0);
cout << "set attrib RENDER\n";
mesh.setAttributeLocation(tfrender);
mesh.bindBuffers();
mesh.renderElements();
mesh.unbindBuffers();
tfrender.unbind();
}
/**
* @brief Render sphere
*/
void render (const Tucano::Camera& camera, const Tucano::Camera& light)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
sphere_shader.bind();
sphere_shader.setUniform("modelMatrix", model_matrix);
sphere_shader.setUniform("viewMatrix", camera.getViewMatrix());
sphere_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
sphere_shader.setUniform("lightViewMatrix", light.getViewMatrix());
sphere_shader.setUniform("in_Color", color);
vector <string> attribs;
sphere_shader.getActiveAttributes(attribs);
this->setAttributeLocation(&sphere_shader);
glEnable(GL_DEPTH_TEST);
this->bindBuffers();
this->renderElements();
this->unbindBuffers();
glDisable(GL_DEPTH_TEST);
sphere_shader.unbind();
#ifdef TUCANODEBUG
errorCheckFunc(__FILE__, __LINE__);
#endif
}
/** * @brief Render the mesh given a camera and light, using a Phong shader
* @param mesh Given mesh
* @param camera Given camera
* @param lightTrackball Given light camera
*/
void render (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
depthmap_shader.bind();
// sets all uniform variables for the phong shader
depthmap_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
depthmap_shader.setUniform("modelMatrix", mesh.getModelMatrix());
depthmap_shader.setUniform("viewMatrix", camera.getViewMatrix());
depthmap_shader.setUniform("near", 0.1);
depthmap_shader.setUniform("far", 10000.0);
// std::cout << "Model" << std::endl;
// std::cout << mesh.getModelMatrix().matrix() << std::endl;
// std::cout << "View" << std::endl;
// std::cout << camera.getViewMatrix().matrix() << std::endl;
mesh.setAttributeLocation(depthmap_shader);
glEnable(GL_DEPTH_TEST);
mesh.render();
depthmap_shader.unbind();
}
/** * @brief Render the mesh given a camera and light, using a Phong shader
* @param mesh Given mesh
* @param camera Given camera
* @param lightTrackball Given light camera
*/
void render (PointCloud& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
particletf_shader.bind();
glUniformSubroutinesuiv(GL_VERTEX_SHADER, 1, 0);
// Transform feedback 0
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[0]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,mesh.getAttribute("in_Position")->getBufferID());
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,mesh.getAttribute("in_Velocity")->getBufferID());
// posBuf[0] -> mesh.getAttribute("in_Position")->getBufferID()
// Transform feedback 1
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[1]);
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,0,mesh.getAttribute("in_Position")->getBufferID());
glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,mesh.getAttribute("in_Velocity")->getBufferID());
// glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,1,velBuf[1]);
// glBindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER,2,startTime[1]);
// sets all uniform variables for the phong shader
particletf_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
particletf_shader.setUniform("modelMatrix", mesh.getModelMatrix());
particletf_shader.setUniform("viewMatrix", camera.getViewMatrix());
particletf_shader.setUniform("lightViewMatrix", lightTrackball.getViewMatrix());
particletf_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));
particletf_shader.setUniform("default_color", default_color);
// Disable rendering
glEnable(GL_RASTERIZER_DISCARD);
int drawBuf = 0;
// Bind the feedback object for the buffers to be drawn next
glBindTransformFeedback(GL_TRANSFORM_FEEDBACK, feedback[drawBuf]);
mesh.setAttributeLocation(particletf_shader);
glEnable(GL_DEPTH_TEST);
mesh.render();
particletf_shader.unbind();
// glEndTransformFeedback();
}
/** * @brief Render the mesh given a camera and light, using a Phong shader
* @param mesh Given mesh
* @param camera Given camera
* @param lightTrackball Given light camera
*/
void render (Tucano::Mesh& mesh, const Tucano::Camera& camera, const Tucano::Camera& lightTrackball)
{
if (read_va == NULL)
{
read_va = mesh.getAttribute("positions1");
write_va = mesh.getAttribute("positions2");
}
if (read_va == NULL || write_va == NULL)
qDebug() << "AHHH morri";
updateTF(mesh, camera, lightTrackball);
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
simple.bind();
// sets all uniform variables for the phong shader
simple.setUniform("projectionMatrix", camera.getProjectionMatrix());
simple.setUniform("modelMatrix", mesh.getModelMatrix());
simple.setUniform("viewMatrix", camera.getViewMatrix());
glEnable(GL_DEPTH_TEST);
//mesh.setAttributeLocation(simple);
mesh.bindBuffers();
// mesh.resetLocations();
//qDebug() << mesh.getAttribute("nPos")->getLocation();
read_va->disable();
write_va->enable(simple.getAttributeLocation("inPos"));
mesh.setAttributeLocation("nColor", simple.getAttributeLocation("inColor"));
mesh.renderPoints();
mesh.unbindBuffers();
simple.unbind();
VertexAttribute *tmp_va;
tmp_va = read_va;
read_va = write_va;
write_va = tmp_va;
}
/**
* @brief Render the mesh given a camera trackball
* @param mesh Given mesh
* @param cameraTrackball Given camera trackball
*/
virtual void render(Tucano::Mesh& mesh, const Tucano::Camera& camera)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
normalvec_shader.bind();
// sets all uniform variables for the phong shader
normalvec_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
normalvec_shader.setUniform("modelMatrix", mesh.getModelMatrix());
normalvec_shader.setUniform("viewMatrix", camera.getViewMatrix());
mesh.setAttributeLocation(normalvec_shader);
glEnable(GL_DEPTH_TEST);
mesh.render();
glDisable(GL_DEPTH_TEST);
normalvec_shader.unbind();
}
/** * @brief Render the mesh given a camera
* @param mesh Given mesh
* @param camera Given camera
*/
void render (Tucano::Mesh& mesh, const Tucano::Camera& camera)
{
Eigen::Vector4f viewport = camera.getViewport();
glViewport(viewport[0], viewport[1], viewport[2], viewport[3]);
directcolor_shader.bind();
// sets all uniform variables for the phong shader
directcolor_shader.setUniform("projectionMatrix", camera.getProjectionMatrix());
directcolor_shader.setUniform("modelMatrix", mesh.getModelMatrix());
directcolor_shader.setUniform("viewMatrix", camera.getViewMatrix());
directcolor_shader.setUniform("has_color", mesh.hasAttribute("in_Color"));
directcolor_shader.setUniform("default_color", default_color);
mesh.setAttributeLocation(directcolor_shader);
glEnable(GL_DEPTH_TEST);
mesh.render();
directcolor_shader.unbind();
}