source: orxonox.OLD/trunk/src/world_entities/environments/mapped_water.h @ 8902

/*!
 * @file mapped_water.h
 *  worldentity for flat, cool looking, mapped water
*/
/*! example input in .oxw file with the standard values
<MappedWater>
  <waterpos>0,0,0</waterpos>
  <watersize>100,100</watersize>
  <wateruv>9</wateruv><!-- size of the waves -->
  <waterflow>0.08</waterflow>
  <lightpos>0,10,0</lightpos>
  <waterangle>0</waterangle>
  <normalmapscale>0.25</normalmapscale><!-- you won't see a big differnce if you change that -->
  <shininess>128</shininess><!-- the bigger the value, the smaller the specular reflection point -->
  <watercolor>0.1, 0.2, 0.4</watercolor>
</MappedWater>
*/


#ifndef _MAPPED_WATER_H
#define _MAPPED_WATER_H

#include "world_entity.h"
#include "material.h"
#include "shader.h"


class MappedWater : public WorldEntity
{
public:
  MappedWater(const TiXmlElement* root = NULL);
  virtual ~MappedWater();

  void loadParams(const TiXmlElement* root);

  void draw() const;
  void tick(float dt);

  // function to prepare renderpaths for creation of refleaction and reflaction textures
  void activateReflection();
  void deactivateReflection();
  void activateRefraction();
  void deactivateRefraction();

  // functions to set parameters for the water, usually they're called through loadparam
  void setLightPos(float x, float y, float z) { this->lightPos = Vector(x,y,z); };
  void setWaterPos(float x, float y, float z) { this->waterPos = Vector(x,y,z); };
  void setWaterSize(float x, float z) { this->xWidth = x; this->zWidth = z; };
  void setWaterAngle(float angle) { this->waterAngle = angle; };
  void setWaterUV(float uv) { this->waterUV = uv; };
  void setWaterFlow(float flow) { this->waterFlow = flow; };
  void setNormalMapScale(float scale) { this->kNormalMapScale = scale; };
  void setShininess(float shine) { this->shininess = shine; };
  void setWaterColor(float r, float g, float b) { this->waterColor = Vector(r,g,b); };

  // functions to change water parameters during runtime
  // to reset waterUV and waterFlow just use the normal set functions
  void resetWaterColor(float r, float g, float b);
  void resetShininess(float shine);
  void resetLightPos(float x, float y, float z);

  // fade functions
  void fadeWaterColor(float r, float g, float b, float time);
  void fadeShininess(float shine, float time);
  void fadeLightPos(float x, float y, float z, float time);

private:
  void initParams();
  void initTextures();
  void initShaders();

private:
  Vector              waterPos;               //!< position of the water
  float               xWidth, zWidth;         //!< size of the water quad
  Vector              lightPos;               //!< position of the light that is used to render the reflection
  float               waterAngle;             //!< defines how much the water will be turned around the point waterPos
  Vector              waterColor;             //!< color of the water
  float               move;                   //!< textures coords, speeds, positions for the shaded textures....
  float               move2;
  float               waterUV;                //!< size of the waves
  float               waterFlow;              //!< speed of the water
  float               normalUV;
  float               kNormalMapScale;
  float               shininess;              //!< the bigger the value, the smaller the specular reflection point

  int                 textureSize;            //!< height and width of the texture
  Material            mat;
  Shader*             shader;
  Shader::Uniform*    cam_uni;                //!< uniform that is used for the camera position
  Shader::Uniform*    light_uni;              //!< uniform that is used for the light position
  Shader::Uniform*    color_uni;              //!< uniform that is used for the watercolor
  Shader::Uniform*    shine_uni;              //!< uniform that is used for the specular shininessd of the water
  
  
  int tempcounter;
};

#endif