DistortionRendering.cpp

#include <GLviewer/DistortionRendering.hh>
#include <GLviewer/GLProjectionParametersInterface.hh>

#include <Base/Image/Image.hh>
#include <Base/Image/ImageIO.hh>
#include <Utils/GlewInitWrapper.hh>


#ifdef BIAS_HAVE_CLASS_DISTORTIONRENDERING

using namespace BIAS;
using namespace BIAS;
using namespace std;

template<class imgType>
void Dump(glfTexture2D& textureA, const std::string& fileNameA) 
{
  Image<imgType> imgA;
  textureA.CopyToImage(imgA);
  if(ImageIO::Save(fileNameA, imgA)!=0) {
    BIASERR("could not dump to "<<fileNameA);
  }
}



DistortionRendering::DistortionRendering() : 
NotDistortedImageWidth_(0),
NotDistortedImageHeight_(0)
{
  loadDistortionShaders_ = true;
  ClearColor_.Set(0., 0., 0., 0.);
  UseStencilBuffer_ = true;
  DistortionShadersInitialized_=false;
  // AddDebugLevel(GLP_STATE_HIGH);
}


DistortionRendering::~DistortionRendering()
{
  Reset();
  glFinish();
}


void DistortionRendering::
SetQuadDataTexture_(float* data) 
{

 /* GL_QUADS
   *   3--2
   *   |  |
   *   0--1
   */

  unsigned int i=0;
  data[i++] = -1.0;
  data[i++] = -1.0; //vertex
  data[i++] = 0.0;
  data[i++] = 1.0; //tex0

 
  data[i++] = 1.0;
  data[i++] = -1.0; //vertex
  data[i++] = 1.0;
  data[i++] = 1.0; //tex0
  
  data[i++] = 1.0;
  data[i++] = 1.0; //vertex
  data[i++] = 1.0;
  data[i++] = 0.0; //tex0


  data[i++] = -1.0;
  data[i++] = 1.0;  //vertex
  data[i++] = 0.0;
  data[i] = 0.0; //tex0
  //  BIASERR("endpoint "<<i);
}



void DistortionRendering::
SetupPrimitiveRendering_()
{
  glfVertexFormat vertexFormat;
  vertexFormat.AddAttribute(glfVertexFormat::ATTRIB_POSITION, GL_FLOAT, 2);
  vertexFormat.AddAttribute(glfVertexFormat::ATTRIB_TEXCOORD, 0, GL_FLOAT, 2); 
 

  float vertexData[16]; //4 vertices a 4 data entries
  SetQuadDataTexture_(vertexData);
  /*disable arraybuffer  usage - 
    crashes in conjunction with open scene graph. (grauel 10/08) */
  vertices_.Create(4, vertexFormat, vertexData, false );
  distortionBatch_.SetVertexBuffer(&vertices_);

  distortionBatch_.SetPrimitiveType(GL_QUADS);
 
  
  //index buffering for 1 quad with 4 vertices? overhead?
  //anyway: i had to disable this due to incomapability with open scene graph!
  //reactivated ischiller 11/09
  /* GL_QUADS
   *   3--2
   *   |  |
   *   0--1
   */
  GLuint quadIndices[4] = {0,1,2,3};
  elements_.Create(4, 
                   GL_UNSIGNED_INT, 
                   GL_QUADS, 
                   quadIndices);
  distortionBatch_.SetElementBuffer(&elements_);
  distortionBatch_.SetRange(0, 4);
}

int DistortionRendering::
Init(ProjectionParametersPerspective* projParams)
{  
       
    //  GlewInitWrapper::GetInstance()->Init();
  if (!GLEW_EXT_framebuffer_object) {
    BIASWARN("Required rendering state not supported. Distortion rendering disabled!");
    return -1;
  }

  BIASDOUT(GLP_ACTIVITY_MEDIUM, "[DistortionRendering ]: INIT ");
   
  //the diameters of the distorted image
  unsigned int distortedImageWidth=0, distortedImageHeight=0;
  projParams->GetImageSize(distortedImageWidth, 
                           distortedImageHeight);

  BIASDOUT(GLP_ACTIVITY_MEDIUM, "Image Dim:"<<distortedImageWidth<<","<<distortedImageHeight);

  BIASASSERT(distortedImageWidth>0);
  BIASASSERT(distortedImageHeight>0);
 
  //get the size of a not distorted image 
  projParams->GetIdealImageSize(NotDistortedImageWidth_,
                                NotDistortedImageHeight_);
  BIASDOUT(GLP_ACTIVITY_MEDIUM, "Undistorted Image Dim:"
           <<NotDistortedImageWidth_<<","<<NotDistortedImageHeight_);
 
  BIASASSERT(NotDistortedImageWidth_>0);
  BIASASSERT(NotDistortedImageHeight_>0);  

  GLenum depthformat = GL_DEPTH_COMPONENT;
  if(UseStencilBuffer_) depthformat = GL_DEPTH24_STENCIL8_EXT;
  //setup not distorted DEPTH texture  
  NotDistortedDepthTexture_.Create();  
  NotDistortedDepthTexture_.SetMagFilter(GL_NEAREST);
  NotDistortedDepthTexture_.SetMinFilter(GL_NEAREST);
  NotDistortedDepthTexture_.SetWrapT(GL_CLAMP);
  NotDistortedDepthTexture_.SetWrapS(GL_CLAMP);
  NotDistortedDepthTexture_.Allocate(NotDistortedImageWidth_,
                                     NotDistortedImageHeight_,
                                     depthformat);//

  //GL_EXT_PACKED_DEPTH_STENCIL
  //DEPTH_STENCIL_EXT

  //setup not distorted COLOR texture
  int alphaBits;
  glGetIntegerv(GL_ALPHA_BITS, &alphaBits);
  GLenum format = (alphaBits>0) ? GL_RGBA8 : GL_RGB8;
  NotDistortedColorTexture_.Create();
  NotDistortedColorTexture_.SetMagFilter(GL_LINEAR);
  NotDistortedColorTexture_.SetMinFilter(GL_LINEAR_MIPMAP_LINEAR);

  NotDistortedColorTexture_.SetWrapT(GL_CLAMP);
  NotDistortedColorTexture_.SetWrapS(GL_CLAMP);
  NotDistortedColorTexture_.Allocate(NotDistortedImageWidth_,
                                     NotDistortedImageHeight_,
                                     format);  
  NotDistortedColorTexture_.GenerateMipMap();

    
  DistortionRenderingFBO_.Create();
  DistortionRenderingFBO_.AttachTexture(NotDistortedColorTexture_, 
                                        GL_COLOR_ATTACHMENT0_EXT);
  DistortionRenderingFBO_.AttachTexture(NotDistortedDepthTexture_, 
                                        GL_DEPTH_ATTACHMENT_EXT);
  if(UseStencilBuffer_)
    {
      //in this case depthtexture also contains an 8bit stencil channel
      DistortionRenderingFBO_.AttachTexture(NotDistortedDepthTexture_, 
                                            GL_STENCIL_ATTACHMENT_EXT);
    }

  DistortionRenderingFBO_.ClearColorBuffer(ClearColor_[0], ClearColor_[1],
                                           ClearColor_[2], ClearColor_[3]);
  DistortionRenderingFBO_.ClearDepthBuffer();

  try {
    DistortionRenderingFBO_.CheckComplete();
  } catch (glfException& e) {
    BIASERR("FBO init error: " << e.GetMessageString());
    return -1;
  } 
  BIASDOUT(GLP_STATE_HIGH, "[DistortionRendering ]: DISTORTION FBO OK");

  KMatrix K, Kinv, idealK;
  K = projParams->GetK();
  Kinv = K.Invert();
  projParams->GetIdealK(idealK);

  Image<float> lookupTexture(distortedImageWidth, distortedImageHeight, 3);
  float* tex = lookupTexture.GetImageData();
  unsigned int c=0;  
  HomgPoint2D source(0,0,1);

  
  BIASDOUT(GLP_STATE_HIGH, "[DistortionRendering ]: ideal size "<<
           NotDistortedImageWidth_<<"x"<<NotDistortedImageHeight_);
  
  for (unsigned int y=0; y<distortedImageHeight; y++) {
    for (unsigned int x=0; x<distortedImageWidth; x++) {
      source[0] = x;
      source[1] = y;
      //might have been changed by Undistort() in previous loop step
      source[2] = 1;
      projParams->Undistort(source); 
      source = idealK * Kinv * source;
      source.Homogenize();
      
      source[0] /= NotDistortedImageWidth_;
      source[1] /= NotDistortedImageHeight_;

      tex[c++] = source[0];
      tex[c++] = 1.0-source[1];
      tex[c++] = source[2];
    }
  }
 
  distortionMap_.Create();
  distortionMap_.SetMinFilter(GL_NEAREST);
  distortionMap_.SetMagFilter(GL_NEAREST);
  distortionMap_.SetWrapT(GL_CLAMP);
  distortionMap_.SetWrapS(GL_CLAMP);
  distortionMap_.UploadImage(lookupTexture, GL_RGB32F_ARB);
  // Dump<float>(distortionMap_, "lookup");

  if(loadDistortionShaders_) {
    BIASDOUT(GLP_ACTIVITY_MEDIUM, "[DistortionRendering ]: loading shaders");
    
    std::string fragmentProgramCode_ = 
      "uniform sampler2D lookup;"
      "uniform sampler2D color;"
      "uniform sampler2D depth;"
      ""
      " void main() {"
      ""
      "   vec2 indirect = texture2D(lookup, gl_TexCoord[0].st).st;"
      "   gl_FragColor = texture2D(color, indirect);"   
      //" gl_FragColor.rg = indirect; "
      " gl_FragDepth = texture2D(depth, indirect).r;" //distort depth buffer
      // "gl_FragColor.r = texture2D(depth, indirect).a;" //dbughack show depth in redchannel REMOVEME!
      " }";

    try {
      PerspectiveDistortionFragmentShader_.Create(GL_FRAGMENT_SHADER, 
                                                  fragmentProgramCode_);
    } catch (glfException& e) {
      BIASERR("Fragment Shader Compile ERROR: \n" << e.GetMessageString());
      return -1;
    }
    distortionProgram_.Create();
    distortionProgram_.AttachShader(PerspectiveDistortionFragmentShader_);
    try {
      distortionProgram_.Link();
    } catch (glfException& e) {
      BIASERR("Fragment Shader Linking ERROR: \n" << e.GetMessageString());
      return -1;
    }
    distortionProgram_.SetUniform("lookup", 0);
    distortionProgram_.SetUniform("color", 1);
    distortionProgram_.SetUniform("depth", 2);

    // why use the fixed pipeline??
    // glUseProgram(0);
    loadDistortionShaders_ = false;
  }
  
  //set in BeginRendering_ before call to Init(...)
  targetViewport_.SetOrigin(lastUsedGLViewport_[0], 
                              lastUsedGLViewport_[1]);
  targetViewport_.SetSize(lastUsedGLViewport_[2], 
                          lastUsedGLViewport_[3]);

  distortionBatch_.SetTexture(&distortionMap_, 0);
  distortionBatch_.SetTexture(&NotDistortedColorTexture_, 1);
  distortionBatch_.SetTexture(&NotDistortedDepthTexture_, 2);
  distortionBatch_.SetViewport(&targetViewport_);
  distortionBatch_.SetDepthBufferMode(&depthTest_);
  depthTest_.SetDepthFunc(GL_LEQUAL);
  depthTest_.SetDepthTest(true);
  distortionBatch_.SetRenderTarget(&globalRenderTarget_);
  distortionBatch_.SetShaderProgram(&distortionProgram_);
  //attaches quad
  SetupPrimitiveRendering_();

  //used later
  undistortedViewport_.SetOrigin(0,0);
  undistortedViewport_.SetSize(NotDistortedImageWidth_, 
                               NotDistortedImageHeight_);
   
  DistortionShadersInitialized_ = true;
  BIASDOUT(GLP_ACTIVITY_BASIC, "Distortion-shaders should be initialized now");

  GLF_THROW_ON_OPENGL_ERROR;
  return 0;
}

void DistortionRendering::
Reset()
{  
  DistortionShadersInitialized_ = false;
}

int DistortionRendering::
BeginRendering(ProjectionParametersPerspective* projParams,
               bool useStencil)
{
  glGetIntegerv(GL_VIEWPORT, lastUsedGLViewport_.GetData());

  if((useStencil)&&(!GLEW_EXT_packed_depth_stencil))
    {
      BIASWARNONCE("Required stencil buffer capabilites not supported." "Distortion rendering disabled!");
      return -1;
    }
  
  if ((!GLEW_EXT_framebuffer_object)) {
    BIASWARNONCE("DistortionRendering is unsupported by your hardware");   
    return -1;
  }

  BIASDOUT(GLP_ACTIVITY_HIGH, "[DistortionRendering]:**** DrawScenes ****");
  UseStencilBuffer_ = useStencil;
  
  try {
    if(!DistortionShadersInitialized_) {

      BIASDOUT(GLP_STATE_HIGH, "[DistortionRendering]: Distortion not Initialized");
      try {
        if(Init(projParams)!=0) {         
          BIASERR("error during perspective distortion intialization");
          return -1;
        } else {
          BIASDOUT(GLP_STATE_HIGH, 
                   "[DistortionRendering]: Distortion already Initialized");
        }
      } catch (glfException& e) {
        BIASERR("ERROR in INIT of Distortion rendering: \n" 
                << e.GetMessageString());
        throw e;
      }    
    }
  

    //setting appropriate viewport, this is bigger then the final rendering
    //and the previouse one must be reinstalled afterwards
    //  glGetIntegerv(GL_VIEWPORT, lastUsedGLViewport_.GetData());
    
    //     cerr<<"last used viewport ";
    //     for(unsigned int i=0;i<4;i++) {
    //       cerr<<lastUsedGLViewport_[i]<<" ";
    //     }
    //     cerr<<endl;

    // activate fbo pipes output to renderbuffer for depth and 
    // and color buffer into NotDistortedColorTexure_ object.
    //DistortionRenderingFBO_.Install();//[0]->Bind();

    GLF_THROW_ON_OPENGL_ERROR;
    DistortionRenderingFBO_.CheckComplete();

    try {
      DistortionRenderingFBO_.Bind();
    } catch (glfException& e) {
      BIASERR("exception binding distortion FBO : \n" << e.GetMessageString());
      throw e;
    }

    undistortedViewport_.Bind();

    try {
      DistortionRenderingFBO_.ClearColorBuffer(ClearColor_[0], ClearColor_[1],
                                               ClearColor_[2], ClearColor_[3]);
    } catch (glfException& e) {
      BIASERR("clearing color of distortion FBO : \n" << e.GetMessageString());
      throw e;
    }

    try {
      DistortionRenderingFBO_.ClearDepthBuffer();
    } catch (glfException& e) {
      BIASERR("clearing depth of distortion FBO : \n" << e.GetMessageString());
      throw e;
    }

    if(UseStencilBuffer_)
      {
        try {
          DistortionRenderingFBO_.ClearStencilBuffer(); // here was a 0
        } catch (glfException& e) {
          BIASERR("clearing stencil of distortion FBO : \n"<<e.GetMessageString());
          throw e;
        }
      }
    
  } catch (glfException& e) {
    BIASERR("Preparing Distortion rendering: \n" << e.GetMessageString());
    throw e;
  }
  
  try {
    DistortionRenderingFBO_.CheckComplete();
    DistortionRenderingFBO_.Bind();
  } catch (glfException& e) {
    BIASERR("exception binding distortion FBO : \n" << e.GetMessageString());
    throw e;
  }

  undistortedViewport_.Bind();

  try {
    DistortionRenderingFBO_.ClearColorBuffer(ClearColor_[0], ClearColor_[1],
                                             ClearColor_[2], ClearColor_[3]);
  } catch (glfException& e) {
    BIASERR("clearing color of distortion FBO : \n" << e.GetMessageString());
    throw e;
  }

  try {
    DistortionRenderingFBO_.ClearDepthBuffer();
  } catch (glfException& e) {
    BIASERR("clearing depth of distortion FBO : \n" << e.GetMessageString());
    throw e;
  }

  if(UseStencilBuffer_)
    {
      try {
        DistortionRenderingFBO_.ClearStencilBuffer(); // here was a 0
      } catch (glfException& e) {
        BIASERR("clearing stencil of distortion FBO : \n"<<e.GetMessageString());
        throw e;
      }
    }   
  return 0;
}

void DistortionRendering::Bind()
{
  undistortedViewport_.Bind();
  DistortionRenderingFBO_.Bind();
}

int DistortionRendering::
EndRendering(glfRenderTarget* renderTarget)
{
  if (!GLEW_EXT_framebuffer_object) {
    BIASERR("Distortion rendering was not possible!");
    return -1;
  }

  NotDistortedColorTexture_.GenerateMipMap();

  // activate render target
  renderTarget->Bind();
  
  targetViewport_.SetOrigin(lastUsedGLViewport_[0], 
                            lastUsedGLViewport_[1]);
  targetViewport_.SetSize(lastUsedGLViewport_[2], 
                          lastUsedGLViewport_[3]);

  //producing the final result in buffers:
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glPushAttrib(GL_ALL_ATTRIB_BITS);

  glMatrixMode(GL_MODELVIEW);
  glPushMatrix();
  glMatrixMode(GL_PROJECTION);
  glPushMatrix();

  //will also set the viewport !
  distortionBatch_.Draw();
  // disable active textures
  for (int i=2; i>=0; i--) {
    glActiveTexture(GL_TEXTURE0+i);
    glDisable(GL_TEXTURE_2D);
  }

  //Batch::SetDefaultRenderStates();
  glMatrixMode(GL_PROJECTION);
  glPopMatrix();
  glMatrixMode(GL_MODELVIEW);
  glPopMatrix();   

  glPopAttrib();

  glUseProgram(0);
  glEnable(GL_DEPTH_TEST);


  // for some strange reason, this viewport is not set by distortionBatch_ (??)
  //   glViewport(lastUsedGLViewport_[0],
  //              lastUsedGLViewport_[1],
  //              lastUsedGLViewport_[2],
  //              lastUsedGLViewport_[3]);

  GLF_THROW_ON_OPENGL_ERROR;

  return 0;
}

int DistortionRendering::
DrawScenes(std::vector<SceneBase*>& scenes,
           bool& FirstRenderingPassFinished,
           bool& informScenesOfChange,
           ProjectionParametersPerspective* projParams,
           glfRenderTarget* renderTarget,
           bool useStencil
)
{
  if (BeginRendering(projParams,useStencil) != 0) {
    
    return -1;
  }

  for (unsigned int i=0; i<scenes.size(); i++) {
    if(informScenesOfChange)
      scenes[i]->UpdateCameraRelatedState();    
    scenes[i]->Render();      
  }
  FirstRenderingPassFinished = false;  
  informScenesOfChange = false;
 
  if(useStencil)
  { //set all pixels in the offscreen undistorted zbuffer for which the
    //stencil test passes to zfar
    //enable stencil test    
    glPushAttrib(GL_DEPTH_BUFFER_BIT | GL_TEXTURE_BIT |GL_STENCIL_BUFFER_BIT);
    glEnable(GL_STENCIL_TEST); 
    glEnable(GL_DEPTH_TEST);
    glDepthMask(GL_TRUE);
    glStencilFunc(GL_EQUAL, 1, (GLuint)(~0));
    glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
    glMatrixMode(GL_MODELVIEW);
    glPushMatrix();
    glLoadIdentity();
    glMatrixMode(GL_PROJECTION);
    glPushMatrix();
    glLoadIdentity();
    glDepthFunc(GL_ALWAYS); //<-------- overwrite everything not stenciled!
    glOrtho(-1.0, 1.0, -1.0, 1.0, -1.0, 1.0);
    glColorMask(0,0,0,1); //clear alpha channel or background image blending will use alpha channel
    float s=1;
    glDisable(GL_TEXTURE_2D);
    glBegin(GL_QUADS);
    glColor4f(0,1,1,0); //clear alpha channel with 0 rgb can be anything
    glVertex3f(-s, s, -s);
    glVertex3f(-s, -s, -s);
    glVertex3f(s, -s, -s);
    glVertex3f(s, s, -s);
    glEnd();
    glColorMask(1,1,1,1);
    glDepthFunc(GL_LESS);
    glMatrixMode(GL_PROJECTION);
    glPopMatrix();
    glMatrixMode(GL_MODELVIEW);
    glPopMatrix();
    glPopAttrib();   
    //------------------------
    glDisable(GL_STENCIL_TEST);
  }

  //now render a quad with the distoted fbo.textures on it.
  //the main depth buffer is filled with the depth values from the fbo
  if (EndRendering(renderTarget) != 0) {
    return -1;
  }
  return 0;
}


#endif // BIAS_HAVE_CLASS_DISTORTIONRENDERING