PlaneNode.cc

/*===========================================================================*\
 *                                                                           *
 *                              OpenFlipper                                  *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
 *                                                                           *
\*===========================================================================*/

/*===========================================================================*\
 *                                                                           *
 *   $Revision$                                                         *
 *   $Author$                                                      *
 *   $Date$                   *
 *                                                                           *
\*===========================================================================*/

#include <ACG/GL/acg_glew.hh>

#include "PlaneNode.hh"

#include <ACG/GL/ShaderGenerator.hh>
#include <ACG/GL/ShaderCache.hh>


//== IMPLEMENTATION ==========================================================

PlaneNode::PlaneNode(Plane& _plane, BaseNode* _parent, std::string _name)
    : BaseNode(_parent, _name),
      plane_(_plane),
      vbo_(0),
      vboNeedsUpdate_(true),  // not initialized, so we need an update
      sphere_(0)

{
  vertexDecl_.addElement(GL_FLOAT, 3, ACG::VERTEX_USAGE_POSITION);
  vertexDecl_.addElement(GL_FLOAT, 3, ACG::VERTEX_USAGE_NORMAL);
  vertexDecl_.addElement(GL_FLOAT, 2, ACG::VERTEX_USAGE_TEXCOORD);

  sphere_ = new ACG::GLSphere(10, 10);
  setPlane(_plane);
}

PlaneNode::~PlaneNode() {
  if (vbo_) glDeleteBuffers(1, &vbo_);
}

void PlaneNode::boundingBox(ACG::Vec3d& _bbMin, ACG::Vec3d& _bbMax) {
  ACG::Vec3d pos =
      plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;

  // add a little offset in normal direction
  ACG::Vec3d pos0 = ACG::Vec3d(pos + plane_.normal * 0.1);
  ACG::Vec3d pos1 = ACG::Vec3d(pos - plane_.normal * 0.1);

  ACG::Vec3d xDird = ACG::Vec3d(plane_.xDirection);
  ACG::Vec3d yDird = ACG::Vec3d(plane_.yDirection);

  _bbMin.minimize(pos0);
  _bbMin.minimize(pos0 + xDird);
  _bbMin.minimize(pos0 + yDird);
  _bbMin.minimize(pos0 + xDird + yDird);
  _bbMax.maximize(pos1);
  _bbMax.maximize(pos1 + xDird);
  _bbMax.maximize(pos1 + yDird);
  _bbMax.maximize(pos1 + xDird + yDird);

  _bbMin.minimize(pos1);
  _bbMin.minimize(pos1 + xDird);
  _bbMin.minimize(pos1 + yDird);
  _bbMin.minimize(pos1 + xDird + yDird);
  _bbMax.maximize(pos0);
  _bbMax.maximize(pos0 + xDird);
  _bbMax.maximize(pos0 + yDird);
  _bbMax.maximize(pos0 + xDird + yDird);
}

//----------------------------------------------------------------------------

ACG::SceneGraph::DrawModes::DrawMode PlaneNode::availableDrawModes() const {
  return (ACG::SceneGraph::DrawModes::POINTS |
          ACG::SceneGraph::DrawModes::SOLID_FLAT_SHADED |
          ACG::SceneGraph::DrawModes::SOLID_TEXTURED);
}

//----------------------------------------------------------------------------

//----------------------------------------------------------------------------

void PlaneNode::drawPlane(ACG::GLState& _state) {
  const ACG::Vec3d xy = plane_.xDirection + plane_.yDirection;

  // Array of coordinates for the plane
  float vboData_[9 * 3] = {0.0,
                           0.0,
                           0.0,
                           (float)plane_.xDirection[0],
                           (float)plane_.xDirection[1],
                           (float)plane_.xDirection[2],
                           (float)xy[0],
                           (float)xy[1],
                           (float)xy[2],
                           (float)plane_.yDirection[0],
                           (float)plane_.yDirection[1],
                           (float)plane_.yDirection[2],
                           0.0,
                           0.0,
                           0.0,
                           (float)plane_.yDirection[0],
                           (float)plane_.yDirection[1],
                           (float)plane_.yDirection[2],
                           (float)xy[0],
                           (float)xy[1],
                           (float)xy[2],
                           (float)plane_.xDirection[0],
                           (float)plane_.xDirection[1],
                           (float)plane_.xDirection[2],
                           0.0,
                           0.0,
                           0.0};

  // Enable the arrays
  _state.enableClientState(GL_VERTEX_ARRAY);
  _state.vertexPointer(3, GL_FLOAT, 0, &vboData_[0]);

  // first draw the lines
  _state.set_color(ACG::Vec4f(1.0, 1.0, 1.0, 1.0));
  glLineWidth(2.0);

  glDrawArrays(GL_LINE_STRIP, 0, 5);

  glLineWidth(1.0);

  // Remember blending state
  bool blending = _state.blending();
  bool culling = _state.isStateEnabled(GL_CULL_FACE);

  // then the red front side
  ACG::GLState::enable(GL_BLEND);
  ACG::GLState::blendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  ACG::GLState::enable(GL_CULL_FACE);

  _state.set_color(ACG::Vec4f(0.6f, 0.15f, 0.2f, 0.5f));
  glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

  // finally the green back side
  _state.set_color(ACG::Vec4f(0.1f, 0.8f, 0.2f, 0.5f));

  glDrawArrays(GL_TRIANGLE_FAN, 5, 4);

  if (!blending) ACG::GLState::disable(GL_BLEND);

  if (!culling) ACG::GLState::disable(GL_CULL_FACE);

  // deactivate vertex arrays after drawing
  _state.disableClientState(GL_VERTEX_ARRAY);
}

//----------------------------------------------------------------

void PlaneNode::draw(
    ACG::GLState& _state,
    const ACG::SceneGraph::DrawModes::DrawMode& /*_drawMode*/) {
  _state.push_modelview_matrix();
  glPushAttrib(GL_COLOR_BUFFER_BIT);
  glPushAttrib(GL_LIGHTING_BIT);

  glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE);
  ACG::GLState::enable(GL_COLOR_MATERIAL);

  // plane_.position represents the center of the plane.
  // Compute the corner position
  ACG::Vec3d pos =
      plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;

  // translate to corner position
  _state.translate(pos[0], pos[1], pos[2]);

  // draw the plane
  drawPlane(_state);

  glPopAttrib();
  glPopAttrib();
  _state.pop_modelview_matrix();
}

//----------------------------------------------------------------

void PlaneNode::pick(ACG::GLState& _state,
  ACG::SceneGraph::PickTarget _target) {

  updateVBO();

  unsigned int vertexOffset = 0;

  if ( _target == ACG::SceneGraph::PICK_ANYTHING ) {
    // Anything is plane + 4 corners
    _state.pick_set_maximum(1+4);
    vertexOffset = 1;
  } else  if ( _target == ACG::SceneGraph::PICK_FACE ) {
    // Only the Face
    _state.pick_set_maximum(1);
  } else  if ( _target == ACG::SceneGraph::PICK_VERTEX ) {
    // 4 Vertices
    _state.pick_set_maximum(4);
  }

  // use fixed function or shaders to draw pick geometry
  const bool fixedFunctionGL = _state.compatibilityProfile();

  // load picking shader from cache
  GLSL::Program* pickShader = 0;
  if (!fixedFunctionGL)
  {
    static ACG::ShaderGenDesc desc;
    desc.fragmentTemplateFile = "Picking/single_color_fs.glsl";
    desc.vertexTemplateFile = "Picking/vertex.glsl";
    pickShader = ACG::ShaderCache::getInstance()->getProgram(&desc, nullptr);
    if (!pickShader)
      return;

    pickShader->use();
  }

  if (_target == ACG::SceneGraph::PICK_ANYTHING || _target == ACG::SceneGraph::PICK_FACE) {

    ACG::Vec3d pos = plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;

    _state.push_modelview_matrix();
    _state.translate(pos[0], pos[1], pos[2]);

    // We only draw one plane. So we start at element 0 and have a maximum of one elements
    _state.pick_set_name(0);

    if (pickShader)
    {

      pickShader->setUniform("color", _state.pick_get_name_color_norm(0));

      ACG::GLMatrixf mWVP = _state.projection() * _state.modelview();
      pickShader->setUniform("mWVP", mWVP);

      glBindBuffer(GL_ARRAY_BUFFER, vbo_);
      vertexDecl_.activateShaderPipeline(pickShader);


      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);


      vertexDecl_.deactivateShaderPipeline(pickShader);
      glBindBuffer(GL_ARRAY_BUFFER, 0);

    }
    else
    {

      glBindBuffer(GL_ARRAY_BUFFER, vbo_);

      _state.enableClientState(GL_VERTEX_ARRAY);

      _state.vertexPointer(3, GL_FLOAT, 8 * sizeof(float), 0);

      glDrawArrays(GL_TRIANGLE_FAN, 0, 4);

      // deactivate vertex arrays after drawing
      _state.disableClientState(GL_VERTEX_ARRAY);

      glBindBuffer(GL_ARRAY_BUFFER, 0);
    }

    _state.pop_modelview_matrix();

  }

  if (_target == ACG::SceneGraph::PICK_ANYTHING  || _target == ACG::SceneGraph::PICK_VERTEX) {

    float sphereRadius = 0.05f;

    if (pickShader)
    {
      // Compute zero corner of plane ( Shifted by half such that center of plane is 0,0
      ACG::Vec3d pos = plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;

      //==========================================
      // Draw 0 Corner:
      //==========================================
      _state.push_modelview_matrix();
      _state.translate(pos[0], pos[1], pos[2]);

      ACG::GLMatrixf mWVP = _state.projection() * _state.modelview();
      mWVP.scale(sphereRadius, sphereRadius, sphereRadius);
      pickShader->setUniform("mWVP", mWVP);
      pickShader->setUniform("color", _state.pick_get_name_color_norm(vertexOffset));
      sphere_->draw_primitive(pickShader);

      //==========================================
      // Draw x Corner:
      //==========================================
      vertexOffset++;
      _state.translate(plane_.xDirection[0] , plane_.xDirection[1], plane_.xDirection[2]);

      mWVP = _state.projection() * _state.modelview();
      mWVP.scale(sphereRadius, sphereRadius, sphereRadius);
      pickShader->setUniform("mWVP", mWVP);
      pickShader->setUniform("color", _state.pick_get_name_color_norm(vertexOffset));
      sphere_->draw_primitive(pickShader);

      //==========================================
      // Draw xy Corner:
      //==========================================
      vertexOffset++;
      _state.translate(plane_.yDirection[0] , plane_.yDirection[1], plane_.yDirection[2]);

      mWVP = _state.projection() * _state.modelview();
      mWVP.scale(sphereRadius, sphereRadius, sphereRadius);
      pickShader->setUniform("mWVP", mWVP);
      pickShader->setUniform("color", _state.pick_get_name_color_norm(vertexOffset));
      sphere_->draw_primitive(pickShader);

      //==========================================
      // Draw y Corner:
      //==========================================
      vertexOffset++;
      _state.translate(-plane_.xDirection[0] , -plane_.xDirection[1], -plane_.xDirection[2]);

      mWVP = _state.projection() * _state.modelview();
      mWVP.scale(sphereRadius, sphereRadius, sphereRadius);
      pickShader->setUniform("mWVP", mWVP);
      pickShader->setUniform("color", _state.pick_get_name_color_norm(vertexOffset));
      sphere_->draw_primitive(pickShader);

      _state.pop_modelview_matrix();

    } else {

      // Compute zero corner of plane ( Shifted by half such that center of plane is 0,0
      ACG::Vec3d pos = plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;

      //==========================================
      // Draw 0 Corner:
      //==========================================
      _state.push_modelview_matrix();
      _state.translate(pos[0], pos[1], pos[2]);
      _state.pick_set_name (vertexOffset);
      sphere_->draw(_state,sphereRadius);

      //==========================================
      // Draw x Corner:
      //==========================================
      vertexOffset++;
      _state.translate(plane_.xDirection[0] , plane_.xDirection[1], plane_.xDirection[2]);
      _state.pick_set_name(vertexOffset);
            sphere_->draw(_state,sphereRadius);

      //==========================================
      // Draw xy Corner:
      //==========================================
      vertexOffset++;
      _state.translate(plane_.yDirection[0] , plane_.yDirection[1], plane_.yDirection[2]);
      _state.pick_set_name(vertexOffset);
      sphere_->draw(_state,sphereRadius);

      //==========================================
      // Draw y Corner:
      //==========================================
      vertexOffset++;
      _state.translate(-plane_.xDirection[0] , -plane_.xDirection[1], -plane_.xDirection[2]);
      _state.pick_set_name(vertexOffset);
      sphere_->draw(_state,sphereRadius);

      _state.pop_modelview_matrix();
    }

  }

}




//----------------------------------------------------------------

ACG::Vec3d PlaneNode::position() { return plane_.position; }

//----------------------------------------------------------------

ACG::Vec3d PlaneNode::normal() { return plane_.normal; }

//----------------------------------------------------------------

ACG::Vec3d PlaneNode::xDirection() { return plane_.xDirection; }

//----------------------------------------------------------------

ACG::Vec3d PlaneNode::yDirection() { return plane_.yDirection; }

//----------------------------------------------------------------

PlaneNode::Plane& PlaneNode::getPlane() { return plane_; }

//----------------------------------------------------------------

void PlaneNode::setPlane(Plane plane) {
  plane_ = plane;
  update();
}

//----------------------------------------------------------------------------

void PlaneNode::addSphereAt(ACG::Vec3d _pos, ACG::IRenderer* _renderer,
                            ACG::GLState& _state, ACG::RenderObject* _ro) {
  // 1. Project point to screen
  ACG::Vec3d projected = _state.project(_pos);

  // 2. Shift it by the requested point size
  //    glPointSize defines the diameter but we want the radius, so we divide it
  //    by two
  ACG::Vec3d shifted = projected;
  shifted[0] = shifted[0] + (double)_state.point_size() / 2.0;

  // 3. un-project into 3D
  ACG::Vec3d unProjectedShifted = _state.unproject(shifted);

  // 4. The difference vector defines the radius in 3D for the sphere
  ACG::Vec3d difference = unProjectedShifted - _pos;

  const double sphereSize = difference.norm();

  sphere_->addToRenderer(_renderer, _ro, sphereSize, ACG::Vec3f(_pos));
}

void PlaneNode::update() {
  // update the plane in the next renderstep
  // if the old renderer is used, nothing to do here
  // if the new, shader based renderer is used, we have to update the vbo
  //  this is done at the next render call

  // this method prevents, that the vbo is created, if we don't use a shader
  // based renderer
  vboNeedsUpdate_ = true;
}

//----------------------------------------------------------------------------

void PlaneNode::updateVBO() {
  if (!vboNeedsUpdate_) return;

  if (!vbo_) {
    glGenBuffers(1, &vbo_);
  }

  const ACG::Vec3d xy = plane_.xDirection + plane_.yDirection;
  const ACG::Vec3d normal =
      (plane_.xDirection % plane_.yDirection).normalized();

  // Array of coordinates for the plane ( duplicated due to front and back
  // rendering ) Interleaved with normals 8 vertices with (3 float for position
  // + 3 float for normal + 2 for uv)
  const size_t vboSize = 8 * (3 + 3 + 2);
  float vboData[vboSize] = {
      // vertex A
      0.0, 0.0, 0.0, (float)normal[0], (float)normal[1], (float)normal[2], 0.f,
      0.f,
      // vertex B
      (float)plane_.xDirection[0], (float)plane_.xDirection[1],
      (float)plane_.xDirection[2], (float)normal[0], (float)normal[1],
      (float)normal[2], 1.f, 0.f,
      // vertex C
      (float)xy[0], (float)xy[1], (float)xy[2], (float)normal[0],
      (float)normal[1], (float)normal[2], 1.f, 1.f,
      // vertex D
      (float)plane_.yDirection[0], (float)plane_.yDirection[1],
      (float)plane_.yDirection[2], (float)normal[0], (float)normal[1],
      (float)normal[2], 0.f, 1.f,
      // backside vertex D
      (float)plane_.yDirection[0], (float)plane_.yDirection[1],
      (float)plane_.yDirection[2], (float)-normal[0], (float)-normal[1],
      (float)-normal[2], 0.f, 1.f,
      // backside vertex C
      (float)xy[0], (float)xy[1], (float)xy[2], (float)-normal[0],
      (float)-normal[1], (float)-normal[2], 1.f, 1.f,
      // backside vertex B
      (float)plane_.xDirection[0], (float)plane_.xDirection[1],
      (float)plane_.xDirection[2], (float)-normal[0], (float)-normal[1],
      (float)-normal[2], 1.f, 0.f,
      // backside vertex A
      0.0, 0.0, 0.0, (float)-normal[0], (float)-normal[1], (float)-normal[2],
      0.f, 0.f};

  // Bind buffer
  glBindBuffer(GL_ARRAY_BUFFER_ARB, vbo_);

  // Upload to buffer
  glBufferData(GL_ARRAY_BUFFER_ARB, vboSize * sizeof(float), &vboData[0],
               GL_STATIC_DRAW_ARB);

  // Unbind
  ACG::GLState::bindBufferARB(GL_ARRAY_BUFFER_ARB, 0);

  // VBO is updated for the new renderer
  vboNeedsUpdate_ = false;
}

void PlaneNode::getRenderObjects(
    ACG::IRenderer* _renderer, ACG::GLState& _state,
    const ACG::SceneGraph::DrawModes::DrawMode& _drawMode,
    const ACG::SceneGraph::Material* _mat) {

  // init base render object
  ACG::RenderObject ro;

  //  _state.enable(GL_COLOR_MATERIAL);
  //  _state.disable(GL_LIGHTING);
  ro.initFromState(&_state);

  // plane_.position represents the center of the plane.
  // Compute the corner position
  const ACG::Vec3d pos =
      plane_.position - plane_.xDirection * 0.5 - plane_.yDirection * 0.5;
  const ACG::Vec3d xy = plane_.xDirection + plane_.yDirection;

  // translate to corner position and store that in renderer
  _state.push_modelview_matrix();
  _state.translate(pos[0], pos[1], pos[2]);
  ro.modelview = _state.modelview();
  _state.pop_modelview_matrix();

  // Render with depth test enabled
  ro.depthTest = true;

  updateVBO();

  // Set the buffers for rendering
  ro.vertexBuffer = vbo_;
  ro.vertexDecl = &vertexDecl_;

  for (unsigned int i = 0; i < _drawMode.getNumLayers(); ++i) {
    ACG::SceneGraph::Material localMaterial = *_mat;

    const ACG::SceneGraph::DrawModes::DrawModeProperties* props =
        _drawMode.getLayer(i);

    ro.setupShaderGenFromDrawmode(props);

    switch (props->primitive()) {
      case ACG::SceneGraph::DrawModes::PRIMITIVE_POINT:

        ro.blending = false;

        //---------------------------------------------------
        // No lighting!
        // Therefore we need some emissive color
        //---------------------------------------------------
        localMaterial.baseColor(localMaterial.ambientColor());
        ro.setMaterial(&localMaterial);

        //---------------------------------------------------
        // Simulate glPointSize(12) with a sphere
        //---------------------------------------------------

        ro.debugName = "Plane Sphere x";
        addSphereAt(plane_.xDirection, _renderer, _state, &ro);

        ro.debugName = "Plane Sphere y";
        addSphereAt(plane_.yDirection, _renderer, _state, &ro);

        ro.debugName = "Plane Sphere xy";
        addSphereAt(xy, _renderer, _state, &ro);

        ro.debugName = "Plane Sphere 0";
        addSphereAt(ACG::Vec3d(0.0, 0.0, 0.0), _renderer, _state, &ro);

        break;
      default:

        ro.priority = 10;

        // Blending enabled, since we want some transparency
        ro.blending = true;
        ro.blendSrc = GL_SRC_ALPHA;
        ro.blendDest = GL_ONE_MINUS_SRC_ALPHA;

        // Enable culling in order to avoid z-fighting artifacts
        ro.culling = true;

        //---------------------------------------------------
        // Just draw the quads here ( front )
        //---------------------------------------------------
        ro.debugName = "PlaneNode.plane_front ";
        applyRenderObjectSettings(ACG::SceneGraph::DrawModes::PRIMITIVE_POLYGON, &ro);
        if (ro.textures().size() != 0) {
            localMaterial.ambientColor(ACG::Vec4f(0.6f, 0.15f, 0.2f, 0.5f));
            localMaterial.diffuseColor(ACG::Vec4f(0.6f, 0.15f, 0.2f, 0.5f));
            localMaterial.specularColor(ACG::Vec4f(0.6f, 0.15f, 0.2f, 0.5f));
        } else {
            localMaterial.ambientColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
            localMaterial.diffuseColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
            localMaterial.specularColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
        }
        ro.setMaterial(&localMaterial);
        ro.glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
        _renderer->addRenderObject(&ro);

        //---------------------------------------------------
        // Just draw the quads here ( back )
        //---------------------------------------------------
        ro.debugName = "PlaneNode.plane_back";
        applyRenderObjectSettings(ACG::SceneGraph::DrawModes::PRIMITIVE_POLYGON, &ro);
        if (ro.textures().size() != 0) {
            localMaterial.ambientColor(ACG::Vec4f(0.1f, 0.8f, 0.2f, 0.5f));
            localMaterial.diffuseColor(ACG::Vec4f(0.1f, 0.8f, 0.2f, 0.5f));
            localMaterial.specularColor(ACG::Vec4f(0.1f, 0.8f, 0.2f, 0.5f));
        } else {
            localMaterial.ambientColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
            localMaterial.diffuseColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
            localMaterial.specularColor(ACG::Vec4f(1.0f, 1.0f, 1.0f, 1.0f));
        }

        ro.setMaterial(&localMaterial);
        ro.glDrawArrays(GL_TRIANGLE_FAN, 4, 4);
        _renderer->addRenderObject(&ro);

        break;
    }
  }
}

//=============================================================================