SceneTexturedPlane.cpp

#include "SceneTexturedPlane.hh"

#include <bias_config.h>
#include <Gui/biasgl.h>
#include <Base/Image/ImageIO.hh>

using namespace BIAS;
using namespace std;

SceneTexturedPlane::
SceneTexturedPlane(const BIAS::Vector3<double> &topLeft,
                   const BIAS::Vector3<double> &width,
                   const BIAS::Vector3<double> &height,
                   const int widthSubsections,
                   const int heightSubsections,
                   const int minFilter, const int magFilter,
                   const int wrapping)
{
  isInitialized_ = false;
  drawNormal_ = false;
  drawNormalLength_ = 1.0f;
  texID_ = 0;
  texCoords_[0].Set(0.0f, 0.0f);
  texCoords_[1].Set(1.0f, 1.0f);
  texSize_.Set(1, 1);
  minFilter_ = minFilter;
  magFilter_ = magFilter;
  wrapping_ = wrapping;
  Resize(topLeft, width, height, widthSubsections, heightSubsections);
}

SceneTexturedPlane::~SceneTexturedPlane()
{
}

void SceneTexturedPlane::
Resize(const BIAS::Vector3<double> &topLeft,
       const BIAS::Vector3<double> &width,
       const BIAS::Vector3<double> &height,
       const int widthSubsections,
       const int heightSubsections)
{
  BIAS::Vector3<double> normal = width.CrossProduct(height);
  normal.Normalize();
  for (unsigned int i = 0; i < 3; i++) {
    corners_[0][i] = topLeft[i];                        // top left
    corners_[1][i] = topLeft[i] + width[i];             // top right
    corners_[2][i] = topLeft[i] + width[i] + height[i]; // bottom right
    corners_[3][i] = topLeft[i] + height[i];            // bottom left
    normal_[i] = -normal[i];
  }
  subsectionsX_ = subsectionsY_ = 1;
  if (widthSubsections > 1)
    subsectionsX_ = widthSubsections;
  if (heightSubsections > 1)
    subsectionsY_ = heightSubsections;
}

void SceneTexturedPlane::
GetBoundingBox(BIAS::Vector3<double> &minVal,
               BIAS::Vector3<double> &maxVal)
{
  // TODO Obtain min. and max. values from corners in Resize!
  minVal.Set(corners_[0][0], corners_[0][1], corners_[0][2]);
  maxVal.Set(corners_[2][0], corners_[2][1], corners_[2][2]);
}

void SceneTexturedPlane::Draw()
{
  if (!isInitialized_) return;
  
  glPushAttrib(GL_TEXTURE_BIT);
  glPushAttrib(GL_LIGHTING);
  glEnable(GL_TEXTURE_2D);
  glEnable(GL_LIGHTING);

  glBindTexture(GL_TEXTURE_2D, texID_);

  glMatrixMode(GL_TEXTURE);
  glLoadIdentity();

  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping_);
  //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping_);

  float material[] = { 1.0f, 1.0f, 1.0f, 1.0f };
  glMaterialfv(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE, material);

  glBegin(GL_QUADS);

  if (subsectionsX_ < 2 && subsectionsY_ < 2) {
    // top left
    glTexCoord2f(texCoords_[0][0], texCoords_[0][1]);
    glNormal3f(normal_[0], normal_[1], normal_[2]);
    glVertex3f(corners_[0][0], corners_[0][1], corners_[0][2]);

    // top right
    glTexCoord2f(texCoords_[1][0], texCoords_[0][1]);
    glNormal3f(normal_[0], normal_[1], normal_[2]);
    glVertex3f(corners_[1][0], corners_[1][1], corners_[1][2]);

    // bottom right
    glTexCoord2f(texCoords_[1][0], texCoords_[1][1]);
    glNormal3f(normal_[0], normal_[1], normal_[2]);
    glVertex3f(corners_[2][0], corners_[2][1], corners_[2][2]);

    // bottom left
    glTexCoord2f(texCoords_[0][0], texCoords_[1][1]);
    glNormal3f(normal_[0], normal_[1], normal_[2]);
    glVertex3f(corners_[3][0], corners_[3][1], corners_[3][2]);

  } else {

    // Draw all subsections from top left to bottom right
    // TODO Precompute corners and texture coordinates!

    BIAS::Vector3<float> dx = corners_[1] - corners_[0];
    BIAS::Vector3<float> dy = corners_[3] - corners_[0];
    BIAS::Vector2<float> dtex = texCoords_[1] - texCoords_[0];
    dx /= (float)subsectionsX_; dy /= (float)subsectionsY_;
    dtex[0] /= subsectionsX_; dtex[1] /= subsectionsY_;

    for (int j = 0; j < subsectionsY_; j++) {
      BIAS::Vector3<float> pos = corners_[0] + (float) j * dy;
      BIAS::Vector2<float> tex(texCoords_[0][0], texCoords_[0][1] + j * dtex[1]);

      for (int i = 0; i < subsectionsX_; i++, pos += dx, tex[0] += dtex[0]) {
        // top left
        glTexCoord2f(tex[0], tex[1]);
        glNormal3f(normal_[0], normal_[1], normal_[2]);
        glVertex3f(pos[0], pos[1], pos[2]);

        // top right
        glTexCoord2f(tex[0] + dtex[0], tex[1]);
        glNormal3f(normal_[0], normal_[1], normal_[2]);
        glVertex3f(pos[0] + dx[0], pos[1] + dx[1], pos[2] + dx[2]);

        // bottom right
        glTexCoord2f(tex[0] + dtex[0], tex[1] + dtex[1]);
        glNormal3f(normal_[0], normal_[1], normal_[2]);
        glVertex3f(pos[0] + dx[0] + dy[0], pos[1] + dx[1] + dy[1], pos[2] + dx[2] + dy[2]);

        // bottom left
        glTexCoord2f(tex[0], tex[1] + dtex[1]);
        glNormal3f(normal_[0], normal_[1], normal_[2]);
        glVertex3f(pos[0] + dy[0], pos[1] + dy[1], pos[2] + dy[2]);
      }
    }
  }

  glEnd();

  // draw normal for debugging
  if (drawNormal_)
  {
    BIAS::Vector3<float> start =
      (corners_[0] + corners_[1] + corners_[2] + corners_[3]) * 0.25f;
    BIAS::Vector3<float> end = start + normal_ * drawNormalLength_;
    glDisable(GL_LIGHTING);
    glDisable(GL_TEXTURE_2D);

    glBegin(GL_LINES);
    glColor3f(1.0f, 1.0f, 0.0f);
    glVertex3f(start[0], start[1], start[2]);
    glVertex3f(end[0], end[1], end[2]);
    glEnd();

    GLfloat pointSize;
    glGetFloatv(GL_POINT_SIZE, &pointSize);
    glPointSize(8.0f);
    glBegin(GL_POINTS);
    glColor3f(1.0f, 1.0f, 0.0f);
    glVertex3f(end[0], end[1], end[2]);
    glEnd();
    glPointSize(pointSize);
  }

  glPopAttrib(); // GL_LIGHTING
  glPopAttrib(); // GL_TEXTURE_BIT
}

void SceneTexturedPlane::
SetTextureCoordinates(const BIAS::Vector2<int> topLeft,
                      const BIAS::Vector2<int> bottomRight)
{
  texCoords_[0][0] = topLeft[0] / (float)texSize_[0];
  texCoords_[0][1] = topLeft[1] / (float)texSize_[1];
  texCoords_[1][0] = bottomRight[0] / (float)texSize_[0];
  texCoords_[1][1] = bottomRight[1] / (float)texSize_[1];
}

void SceneTexturedPlane::
SetTextureCoordinates(const BIAS::Vector2<float> topLeft,
                      const BIAS::Vector2<float> bottomRight)
{
  texCoords_[0][0] = topLeft[0];
  texCoords_[0][1] = topLeft[1];
  texCoords_[1][0] = bottomRight[0];
  texCoords_[1][1] = bottomRight[1];
}

int SceneTexturedPlane::
SetImage(const int texID, const int width, const int height)
{
  // Delete previous texture
  glDeleteTextures(1, &texID_);

  // Pad texture size to power of two
  texSize_.Set(1, 1);
  while (texSize_[0] < width) texSize_[0] *= 2;
  while (texSize_[1] < height) texSize_[1] *= 2;

  // Reset texture coordinates
  texCoords_[0].Set(0.0f, 0.0f);
  texCoords_[1].Set(width / (float)texSize_[0], height / (float)texSize_[1]);

  // Set and return texture ID
  texID_ = texID;
  isInitialized_ = true;
  return texID;
}

int SceneTexturedPlane::
SetImage(const std::string &imageFilename)
{
  BIAS::Image<unsigned char> image;
  BIAS::ImageIO::Load(imageFilename, image);
  return SetImage(image);
}

int SceneTexturedPlane::
SetImage(const BIAS::Image<unsigned char> &image)
{
  // Check color model of texture image
  if (image.GetColorModel() != BIAS::ImageBase::CM_Grey &&
      image.GetColorModel() != BIAS::ImageBase::CM_RGB) {
    BIASERR("Unsupported texture color model (use Gray or RGB)!");
    return -1;
  }

  // Check size of texture image and pad to power of two if needed
  BIAS::Image<unsigned char> texture = image;
  texture.PadToPowerOfTwo();
  int maxTexSize = 0;
  glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
  if ((int)texture.GetWidth()  > maxTexSize ||
      (int)texture.GetHeight() > maxTexSize) {
    BIASERR("Texture size is too large (use max. " << maxTexSize << ")!");
    return -1;
  }

  // Reset texture coordinates
  texCoords_[0].Set(0.0f, 0.0f);
  texCoords_[1].Set(image.GetWidth() / (float)texture.GetWidth(),
                    image.GetHeight() / (float)texture.GetHeight());

  // Initialize or resize and bind texture
  if (!isInitialized_ || (int)texture.GetWidth() != texSize_[0] ||
      (int)texture.GetHeight() != texSize_[1]) {
    return InitializeTexture_(texture);
  }

  // Bind texture if it is already initialized and has right size
  glBindTexture(GL_TEXTURE_2D, texID_);
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  if (texture.GetChannelCount() == 3) {
    BIASASSERT(texture.GetColorModel() == BIAS::ImageBase::CM_RGB);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texSize_[0], texSize_[1],
                    GL_RGB, GL_UNSIGNED_BYTE, texture.GetImageData());
  } else {
    BIASASSERT(texture.GetChannelCount() == 1 &&
               texture.GetColorModel() == BIAS::ImageBase::CM_Grey);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, texSize_[0], texSize_[1],
                    GL_LUMINANCE, GL_UNSIGNED_BYTE, texture.GetImageData());
  }

  // Return texture ID
  return texID_;
}

int SceneTexturedPlane::
InitializeTexture_(BIAS::Image<unsigned char> &texture)
{
  // Delete old texture, generate new texture
  glDeleteTextures(1, &texID_);
  glGenTextures(1, &texID_);

  // Bind texture
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glPixelStorei(GL_PACK_ALIGNMENT, 1);
  glBindTexture(GL_TEXTURE_2D, texID_);

  texSize_.Set(texture.GetWidth(), texture.GetHeight());
  if (texture.GetChannelCount() == 3) {
    BIASASSERT(texture.GetColorModel() == BIAS::ImageBase::CM_RGB);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, texSize_[0], texSize_[1], 0,
                 GL_RGB, GL_UNSIGNED_BYTE, texture.GetImageData());
  } else {
    BIASASSERT(texture.GetChannelCount() == 1 &&
               texture.GetColorModel() == BIAS::ImageBase::CM_Grey);
    glTexImage2D(GL_TEXTURE_2D, 0,GL_RGB, texSize_[0], texSize_[1], 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, texture.GetImageData());
  }
  glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, minFilter_);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, magFilter_);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, wrapping_);
  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, wrapping_);

  // Return new texture ID
  isInitialized_ = true;
  return texID_;
}