TriangleMeshSplatRendering.cpp

#include <GLviewer/TriangleMeshSplatRendering.hh>
#include <Image/Camera.hh>
#include <Base/Image/ImageIO.hh>
#include <GLviewer/GLProjectionParametersBase.hh>
#include <algorithm>

using namespace BIAS;

const char* DEPTH_PASS_VS =
  "uniform float depthTolerance;"
  "uniform vec3 cameraCenter;"
  "void main()"
  "{"
  "  vec3 point = gl_Vertex.xyz;"
  "  vec3 diff = normalize(point - cameraCenter);"
  "  point += diff * depthTolerance;"
  "  gl_Position = gl_ModelViewProjectionMatrix * vec4(point, 1.0);"
  "}";

const char* DEPTH_PASS_FS =
  "void main()"
  "{"
  "  gl_FragColor = vec4(0, 0, 0, 0);"
  "}";

const char* NORMALIZATION_PASS_VS =
  "void main()"
  "{"
  "  gl_TexCoord[0] = gl_MultiTexCoord0;"
  "  gl_Position = gl_Vertex;" // no transformation
  "}";

const char* NORMALIZATION_PASS_FS =
  "uniform sampler2D colorTexture;"
  "uniform sampler2D depthTexture;"
  "void main()"
  "{"
  "  vec4 color = texture2D(colorTexture, gl_TexCoord[0].st);"
  "  float invAlpha = 1.0 / color.a;"
  "  color.r *= invAlpha;"
  "  color.g *= invAlpha;"
  "  color.b *= invAlpha;"
  "  gl_FragColor = color;"
  "  gl_FragDepth = texture2D(depthTexture, gl_TexCoord[0].st).r;"
  "}";


TriangleMeshSplatRendering::TriangleMeshSplatRendering()
  : internalWidth_(1280)
  , internalHeight_(960)
  , depthTolerance_(0.1f)
  , enableBlending_(true)
  , mustCreateShaders_(true)
  , mustCreateFrameBuffer_(true)
{
  camera_ = NULL;
}

TriangleMeshSplatRendering::
~TriangleMeshSplatRendering()
{
  // for (unsigned int i = 0; i < tdos_.size(); i++)
//   {
//     delete tdos_[i];
//   }
  tdos_.clear();
}

void TriangleMeshSplatRendering::
SetInternalResolution(int width, int height)
{
  internalWidth_ = width;
  internalHeight_ = height;
  mustCreateFrameBuffer_ = true;
}

void TriangleMeshSplatRendering::
SetDepthTolerance(float depthTolerance)
{
  depthTolerance_ = depthTolerance;
}

void TriangleMeshSplatRendering::
SetCamera(BIAS::GLProjectionParametersInterface* camera){
  camera_ = camera;
}

void TriangleMeshSplatRendering::
ComputeDepthTolerance(float fraction)
{
  Vector3<double> min, max;
  GetBoundingBox(min, max);

  double width  = max[0] - min[0];
  double height = max[1] - min[1];
  double depth  = max[2] - min[2];

  double size = std::max(width, std::max(height, depth));
  SetDepthTolerance((float)size * fraction);
  //  std::cout<<"Tolerance:"<<(float)size * fraction<<std::endl;
}

void TriangleMeshSplatRendering::
AddThreeDOut(ThreeDOut* tdo)
{
  tdos_.push_back(tdo);
}

void TriangleMeshSplatRendering::
ClearThreeDOuts(){
  tdos_.clear();
}

void TriangleMeshSplatRendering::
Splat()
{
  if (!enableBlending_)
  {
    for (unsigned int i = 0; i < tdos_.size(); i++)
    {
      tdos_[i]->OpenGLOutIndexedFaceSets();
    }
    return;
  }

  if (mustCreateShaders_)
  {
    CreateShaders();
    mustCreateShaders_ = false;
  }

  if (mustCreateFrameBuffer_)
  {
    CreateFrameBuffer(internalWidth_, internalHeight_);
    mustCreateFrameBuffer_ = false;
  }

  // TODO: Sometimes it's not right to directly render to the
  // screen, for example when distortion rendering is enabled.
  // But where to get the current render target from?
  glfRenderTarget& renderTarget = glfScreen::GetInstance();
  
  // store old viewport
  GLint oldViewport[4];
  glGetIntegerv(GL_VIEWPORT, oldViewport);

  // get camera center
  Vector3<double> cameraCenter = camera_->GetMyselfAsProjectionParameterBase()->GetC();
  
  // ---------------------------------------------
  // DEPTH PASS
  // ---------------------------------------------

  // write to fbo
  fbo_.Bind();
  fbo_.ClearColorBuffer(0.0, 0.0, 0.0, 0.0);
  fbo_.ClearDepthBuffer();
  glViewport(0, 0, colorBuffer_.GetWidth(), colorBuffer_.GetHeight());

  // use depth buffer for reading and writing
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LESS);

  // don't write to color buffer
  glColorMask(GL_FALSE, GL_FALSE, GL_FALSE, GL_FALSE);

  // use depth pass program
  depthPassProgram_.SetUniform("cameraCenter", cameraCenter);
  depthPassProgram_.SetUniform("depthTolerance", depthTolerance_);
  depthPassProgram_.Bind();

  // render geometry
  for (unsigned int i = 0; i < tdos_.size(); i++) {
    tdos_[i]->OpenGLOutIndexedFaceSets();
  }

  // ---------------------------------------------
  // SPLATTING PASS
  // ---------------------------------------------

  // use depth buffer read-only
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_FALSE);
  glDepthFunc(GL_LEQUAL);

  // write to color buffer
  glColorMask(GL_TRUE, GL_TRUE, GL_TRUE, GL_TRUE);

  // use additive blending
  glEnable(GL_BLEND);
  glBlendEquation(GL_FUNC_ADD);
  glBlendFunc(GL_ONE, GL_ONE);

  // use fixed function 
  glUseProgram(0);

  // render geometry
  for (unsigned int i = 0; i < tdos_.size(); i++) {
    tdos_[i]->OpenGLOutIndexedFaceSets();
  }

  // ---------------------------------------------
  // NORMALIZATION PASS
  // ---------------------------------------------

  // disable fbo and write to destination render target
  renderTarget.Bind();
  glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);

  // use depth buffer
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LEQUAL);

  // disable blending
  glDisable(GL_BLEND);

  // use normalization pass program
  normalizationPassProgram_.Bind();

  // use texture from fbo
  glActiveTexture(GL_TEXTURE0);
  colorBuffer_.Bind();
  glActiveTexture(GL_TEXTURE1);
  depthBuffer_.Bind();

  // render quad to screen
  glBegin(GL_QUADS);
  glTexCoord2f(0.0f, 0.0f);
  glVertex2f(-1.0f, -1.0f);
  glTexCoord2f(1.0f, 0.0f);
  glVertex2f(1.0f, -1.0f);
  glTexCoord2f(1.0f, 1.0f);
  glVertex2f(1.0f, 1.0f);
  glTexCoord2f(0.0f, 1.0f);
  glVertex2f(-1.0f, 1.0f);
  glEnd();
  
  // restore render states
  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LESS);
  glUseProgram(0);
  glActiveTexture(GL_TEXTURE0);
}

void TriangleMeshSplatRendering::
CreateShaders()
{
  // create shader program for depth pass
  depthPassProgram_.Create();
  depthPassProgram_.AttachShaderFromSource(GL_VERTEX_SHADER, DEPTH_PASS_VS);
  depthPassProgram_.AttachShaderFromSource(GL_FRAGMENT_SHADER, DEPTH_PASS_FS);
  depthPassProgram_.Link();

  // create shader program for normalization pass
  normalizationPassProgram_.Create();
  normalizationPassProgram_.AttachShaderFromSource(GL_VERTEX_SHADER, NORMALIZATION_PASS_VS);
  normalizationPassProgram_.AttachShaderFromSource(GL_FRAGMENT_SHADER, NORMALIZATION_PASS_FS);
  normalizationPassProgram_.Link();
  normalizationPassProgram_.SetUniform("colorTexture", 0);
  normalizationPassProgram_.SetUniform("depthTexture", 1);
}

void TriangleMeshSplatRendering::
CreateFrameBuffer(int width, int height)
{
  // create color buffer
  colorBuffer_.Create();
  colorBuffer_.SetMagFilter(GL_LINEAR);
  colorBuffer_.SetMinFilter(GL_LINEAR);
  colorBuffer_.SetWrapT(GL_CLAMP);
  colorBuffer_.SetWrapS(GL_CLAMP);
  colorBuffer_.Allocate(width, height, GL_RGBA16F_ARB);
  colorBuffer_.GenerateMipMap();

  // create depth buffer
  depthBuffer_.Create();
  depthBuffer_.SetMagFilter(GL_NEAREST);
  depthBuffer_.SetMinFilter(GL_NEAREST);
  depthBuffer_.SetWrapT(GL_CLAMP);
  depthBuffer_.SetWrapS(GL_CLAMP);
  depthBuffer_.Allocate(width, height, GL_DEPTH_COMPONENT);

  // create framebuffer object
  fbo_.Create();
  fbo_.AttachTexture(colorBuffer_, GL_COLOR_ATTACHMENT0_EXT);
  fbo_.AttachTexture(depthBuffer_, GL_DEPTH_ATTACHMENT_EXT);
  fbo_.CheckComplete();
}

void TriangleMeshSplatRendering::
GetBoundingBox(Vector3<double>& min,
               Vector3<double>& max)
{
  min[0] = DBL_MAX;
  min[1] = DBL_MAX;
  min[2] = DBL_MAX;
  max[0] = -DBL_MAX;
  max[1] = -DBL_MAX;
  max[2] = -DBL_MAX;

  for (unsigned int i = 0; i < tdos_.size(); i++)
    {
      Vector3<double> localMin, localMax;
      tdos_[i]->GetBoundingBox(localMin, localMax);

      min[0] = std::min(min[0], localMin[0]);
      min[1] = std::min(min[1], localMin[1]);
      min[2] = std::min(min[2], localMin[2]);

      max[0] = std::max(max[0], localMax[0]);
      max[1] = std::max(max[1], localMax[1]);
      max[2] = std::max(max[2], localMax[2]);
    }
}