source: orxonox.OLD/branches/playability/src/world_entities/effects/wobblegrid.cc @ 10154

/*
   orxonox - the future of 3D-vertical-scrollers

   Copyright (C) 2006 orx

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2, or (at your option)
   any later version.

### File Specific:
   main-programmer: David Hasenfratz
*/

#include "wobblegrid.h"

#include "util/loading/load_param.h"
#include "util/loading/factory.h"

#include "graphics_engine.h"
#include "material.h"
#include "glincl.h"
#include "state.h"
#include "grid.h"

#include <assert.h>
#include "debug.h"


#include "class_id_DEPRECATED.h"
ObjectListDefinition(Wobblegrid);
CREATE_FACTORY(Wobblegrid);

/**
 * Wobble Grids are grids which "wobble"
 * Wobbling is realized through fixed center and sin wave outwards
 * For the beginning the grid will be a 5x5
 */

/**
 * standart constructor
 */
Wobblegrid::Wobblegrid (const TiXmlElement* root)
{
  this->size  = 5;

  this->init();

  if( root)
    this->loadParams(root);
}

Wobblegrid::Wobblegrid (int size, const TiXmlElement* root)
{
  this->size  = size;

  this->init();

  if( root)
    this->loadParams(root);
}


/**
 * destroys a Wobblegrid
 */
Wobblegrid::~Wobblegrid ()
{
  if (this->material)
    delete this->material;
}


/**
 * initializes the Wobblegrid
 */
void Wobblegrid::init()
{
  this->registerObject(this, Wobblegrid::_objectList);
  this->setName("Wobblegrid");

  this->toList(OM_COMMON);

  this->material = new Material();
  this->setAbsCoor(0, 0, 0);
  //this->setVisibiliy(true);
  
  this->subdivision = 5;

  this->grid  = new Grid( this->size, this->size, this->subdivision, this->subdivision);
  for (int i = 0; i < 25; i++)
    PRINTF(0)("Coordinate %i: %f,%f\n",i,this->grid->vertex(i).x,this->grid->vertex(i).z);
  this->angularSpeed = M_PI; //180;
}


/**
 *  load params
 * @param root TiXmlElement object
 */
void Wobblegrid::loadParams(const TiXmlElement* root)
{
  /*LoadParam(root, "texture", this->material, Material, setDiffuseMap)
      .describe("the texture-file to load onto the Wobblegrid");

  LoadParam(root, "size", this, Wobblegrid, setSize)
  .describe("the size of the Wobblegrid in Pixels");*/
}



/**
 * sets the material to load
 * @param textureFile The texture-file to load
 */
void Wobblegrid::setTexture(const std::string& textureFile)
{
  this->material->setDiffuseMap(textureFile);
}


/**
 * ticks the Wobblegrid
 * @param dt the time to ticks
 */
void Wobblegrid::tick(float dt)
{
  angle += dt * angularSpeed;
  if (angle > 2 * M_PI)
    angle -= 2 * M_PI;

  //Vector vec;
  float fac = 1.0 / (this->subdivision - 1);
  for( int z=1; z < 4; z++)
  {
    for( int x=1; x < 4; x++)
    {
      //if(x==2 && z == 2)
      //  continue;

      Vector2D& vec = this->grid->texCoord(z*this->subdivision + x);
      vec.y  = (x * fac + sgn(x-2)*sinf(angle)*fac/2.0);
      vec.x  = (z * fac + sgn(z-2)*sinf(angle)*fac/2.0);
    }
  }
  //this->grid->finalize();
}


/**
 * draws the billboard
 */
void Wobblegrid::draw() const
{
  if( !this->isVisible())
    return;

  glPushAttrib(GL_ENABLE_BIT);
  glDisable(GL_LIGHTING);
  glDisable(GL_FOG);

  glPushMatrix();

  //glTranslatef(this->getAbsCoor().x, this->getAbsCoor().y, this->getAbsCoor().z);
  //glTranslatef(0,0,0);
  this->material->select();

  const PNode* camera = State::getCameraNode();  //!< @todo MUST be different
  Vector cameraPos = camera->getAbsCoor();
  Vector cameraTargetPos = State::getCameraTargetNode()->getAbsCoor();
  Vector view = cameraTargetPos - cameraPos;


  Vector up = Vector(0, 1, 0);
  up = camera->getAbsDir().apply(up);
  Vector h = up.cross(view);
  Vector v = h.cross(view);
  h.normalize();
  v.normalize();

  float rangle  = acosf(v.dot(view)/view.len());

  v *= size;
  h *= size;

//v += this->getAbsCoor();
    //PRINTF(0)("sizeX: %f sizeZ: %f\n", sizeX, sizeZ);
  /*int xone = 0;
  int zone = 0;
  
  glBegin(GL_QUADS);

  for( int z=0; z<4; z++)
  {
    for( int x=0; x<4; x++)
    {
      xone = x + 1;
      zone = z + 1;
      glTexCoord2f(x*.25f,z*.25f);
      glVertex3f( this->getAbsCoor().x + this->grid[z][x].x*this->sizeX2 - h.x - v.x,
                  this->getAbsCoor().y - h.y - v.y,
                  this->getAbsCoor().z + this->grid[z][x].z*this->sizeZ2 - h.z - v.z);

      glTexCoord2f(x*.25f,zone*.25f);
      glVertex3f( this->getAbsCoor().x + this->grid[zone][x].x*this->sizeX2 - h.x - v.x,
                  this->getAbsCoor().y - h.y - v.y,
                  this->getAbsCoor().z + this->grid[zone][x].z*this->sizeZ2 - h.z - v.z);

      glTexCoord2f(xone*.25f,zone*.25f);
      glVertex3f( this->getAbsCoor().x + this->grid[zone][xone].x*this->sizeX2 - h.x - v.x,
                  this->getAbsCoor().y - h.y - v.y,
                  this->getAbsCoor().z + this->grid[zone][xone].z*this->sizeZ2 - h.z - v.z);

      glTexCoord2f(xone*.25f,z*.25f);
      glVertex3f( this->getAbsCoor().x + this->grid[z][xone].x*this->sizeX2 - h.x - v.x,
                  this->getAbsCoor().y - h.y - v.y,
                  this->getAbsCoor().z + this->grid[z][xone].z*this->sizeZ2 - h.z - v.z);
    }
  }
  glEnd();*/
  glTranslatef (this->getAbsCoor ().x,
                  this->getAbsCoor ().y,
                  this->getAbsCoor ().z);
  //Vector tmpRot = this->getAbsDir().getSpacialAxis();
  glRotatef (rangle, view.x, view.y, view.z );
  //glRotatef(this->angle, 0.0, 0.0, 1.0);

  this->grid->draw();

  glPopMatrix();

  glPopAttrib();
}