Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 8037 in orxonox.OLD for trunk/src/world_entities/environments


Ignore:
Timestamp:
May 31, 2006, 4:52:34 PM (18 years ago)
Author:
bensch
Message:

trunk: merged the water back
merged with command
svn merge -r7798:HEAD ​https://svn.orxonox.net/orxonox/branches/water .

conflicts are all resolved

Location:
trunk/src/world_entities/environments
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/world_entities/environments/mapped_water.cc

    r7796 r8037  
    1818#include "util/loading/factory.h"
    1919#include "util/loading/resource_manager.h"
     20#include "state.h"
    2021
    2122
    … …  
    2627
    2728MappedWater::MappedWater(const TiXmlElement* root)
    28     : texture(GL_TEXTURE_2D)
    2929{
    3030  this->setClassID(CL_MAPPED_WATER, "MappedWater");
    … …  
    3434    this->loadParams(root);
    3535
    36   //! HACK FIXME HACK FIXME HACK FIXME HACK FIXME
    37   //! todo: rename texture to reflection texture
     36  PRINTF(0)("MaxTextureUnits: %i\n", Material::getMaxTextureUnits());
     37
     38  // TODO rename texture to reflection texture
     39  /// loads the textures
    3840  // set up refleciton texture
    39   //mat.setDiffuseMap(&this->texture, 0);
     41  //mat.setDiffuseMap(this->texture, 0);
    4042  mat.setDiffuseMap("pictures/dudvmap.bmp", GL_TEXTURE_2D, 0);
    41 /*  mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 1);
    42   mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 2);
    43   mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 3);
    44   mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 4);*/
    4543  // load refraction texture
    46   //mat.setDiffuseMap(&this->refractionTexture, 1);
     44  mat.setDiffuseMap("pictures/error_texture.png", GL_TEXTURE_2D, 1);
    4745  // load normal map
    4846  //mat.setDiffuseMap("pictures/normalmap.bmp", GL_TEXTURE_2D, 2);
    … …  
    5048  //mat.setDiffuseMap("pictures/dudvmap.bmp", GL_TEXTURE_2D, 3);
    5149  // set up depth texture
    52   //mat.setDiffuseMap(&this->depthTexture, 4);
    53 
     50  //mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 4);
     51
     52
     53
     54  /// MAKE THE MAPPING TEXTURE.
     55  // THIS IS A HACK AND SHOULD BE IN TEXTURE SOMEWHERE
    5456  // set the size of the refraction and reflection textures
    55 
    56 
    57 
    58   /// MAKE THE MAPPING TEXTURE.
    59   // THIS IS A HACK AND SHOULD BE IN TEXTURE SOMEWHERE.
    6057  this->textureSize = 512;
    6158  unsigned int channels = 32;
    6259  GLenum type = GL_RGBA;
    63   unsigned int* pTexture = new unsigned int [this->textureSize * this->textureSize * channels];
    64   memset(pTexture, 0, this->textureSize * this->textureSize * channels * sizeof(unsigned int));
     60  unsigned int* pTextureReflection = new unsigned int [this->textureSize * this->textureSize * channels];
     61  memset(pTextureReflection, 0, this->textureSize * this->textureSize * channels * sizeof(unsigned int));
     62  unsigned int* pTextureRefraction = new unsigned int [this->textureSize * this->textureSize * channels];
     63  memset(pTextureRefraction, 0, this->textureSize * this->textureSize * channels * sizeof(unsigned int));
    6564  // Register the texture with OpenGL and bind it to the texture ID
    6665  mat.select();
    6766  glBindTexture(GL_TEXTURE_2D, this->mat.getDiffuseTexture(0));
    68   printf("========= CREATE %d\n", this->texture.getTexture());
    6967
    7068  // Create the texture and store it on the video card
    71   glTexImage2D(GL_TEXTURE_2D, 0, channels, this->textureSize, this->textureSize, 0, type, GL_UNSIGNED_INT, pTexture);
     69  glTexImage2D(GL_TEXTURE_2D, 0, channels, this->textureSize, this->textureSize, 0, type, GL_UNSIGNED_INT, pTextureReflection);
     70
     71  //gluBuild2DMipmaps(GL_TEXTURE_2D, channels, this->textureSize, this->textureSize, type,  GL_UNSIGNED_INT, pTexture);
     72
     73  //the same for the refraction
     74  glBindTexture(GL_TEXTURE_2D, this->mat.getDiffuseTexture(1));
     75  glTexImage2D(GL_TEXTURE_2D, 0, channels, this->textureSize, this->textureSize, 0, type, GL_UNSIGNED_INT, pTextureRefraction);
    7276
    7377  // Set the texture quality
    … …  
    7882
    7983  // Since we stored the texture space with OpenGL, we can delete the image data
    80   delete [] pTexture;
    81 
    82   //  shader = new Shader( ResourceManager::getInstance()->getDataDir() + "/shaders/water.vert", ResourceManager::getInstance()->getDataDir() +"/shaders/mapped_water.frag");
     84  delete [] pTextureReflection;
     85  delete [] pTextureRefraction;
     86
     87
     88  /// initialization of the texture coords, speeds etc...
     89  this->move = 0.0f;
     90  this->g_WaterUV = 35.0f;
     91  this->kNormalMapScale = 0.25f;
     92  this->g_WaterFlow = 0.0015f;
     93
     94  /// initialization of the shaders
     95  // load shader files
     96/*  shader = new Shader( ResourceManager::getInstance()->getDataDir() + "/shaders/mapped_water.vert", ResourceManager::getInstance()->getDataDir() +"/shaders/mapped_water.frag");
     97
     98  this->shader->activateShader();
     99  // Set the variable "reflection" to correspond to the first texture unit
     100  Shader::Uniform(shader, "reflection").set(0);
     101  // Set the variable "refraction" to correspond to the second texture unit
     102  Shader::Uniform(shader, "refraction").set(1);
     103  // Set the variable "normalMap" to correspond to the third texture unit
     104  Shader::Uniform(shader, "normalMap").set(2);
     105  // Set the variable "dudvMap" to correspond to the fourth texture unit
     106  Shader::Uniform(shader, "dudvMap").set(3);
     107  // Set the variable "depthMap" to correspond to the fifth texture unit
     108  Shader::Uniform(shader, "depthMap").set(4);
     109  // Give the variable "waterColor" a blue color
     110  Shader::Uniform(shader, "waterColor").set(0.1f, 0.2f, 0.4f, 1.0f);
     111  // Give the variable "lightPos" our hard coded light position
     112  Shader::Uniform(shader, "lightPos").set(lightPos.x, lightPos.y, lightPos.z, 1.0f);
     113  // uniform for the camera position
     114  cam_uni = new Shader::Uniform(shader, "cameraPos");
     115
     116  this->shader->deactivateShader();*/
    83117}
    84118
    … …  
    86120{
    87121  //delete shader;
     122  //delete cam_uni;
    88123}
    89124
    … …  
    93128
    94129  LoadParam(root, "waterHeight", this, MappedWater, setHeight);
     130  LoadParam(root, "lightPos", this, MappedWater, setLightPosition);
    95131}
    96132
    … …  
    101137  glTranslatef(0,this->waterHeight,0);
    102138
    103   //glEnable(GL_LIGHTING);
    104 
    105 
    106   //mat.setDiffuseMap("pictures/sky-replace.jpg", GL_TEXTURE_2D, 1);
    107   //mat.setTransparency(1.0);
    108   //mat.setDiffuse(1.0, 0, .1);
    109 
    110 
    111   // HACK
    112 
    113   //glDisable(GL_BLEND);
    114   //glActiveTexture(GL_TEXTURE0);
    115   //glBindTexture(GL_TEXTURE_2D, this->texture);
    116 
     139  mat.unselect();
    117140  mat.select();
    118   glBindTexture(GL_TEXTURE_2D, this->mat.getDiffuseTexture(0));
    119 
    120   // Shader init
    121   //this->shader->activateShader();
    122   GLint uniform;
    123 
    124   // Set the variable "reflection" to correspond to the first texture unit
    125   uniform = glGetUniformLocationARB(shader->getProgram(), "reflection");
    126   glUniform1iARB(uniform, 0); //second paramter is the texture unit
    127 
    128   // Set the variable "refraction" to correspond to the second texture unit
    129   //uniform = glGetUniformLocationARB(shader->getProgram(), "refraction");
    130   //glUniform1iARB(uniform, 0);
    131   // FIXME glUniform1iARB(uniform, 1);
    132 
    133   // Set the variable "normalMap" to correspond to the third texture unit
    134   //uniform = glGetUniformLocationARB(shader->getProgram(), "normalMap");
    135   //glUniform1iARB(uniform, 2);
    136 
    137   // Set the variable "dudvMap" to correspond to the fourth texture unit
    138   uniform = glGetUniformLocationARB(shader->getProgram(), "dudvMap");
    139   glUniform1iARB(uniform, 3);
    140 
    141   // Set the variable "depthMap" to correspond to the fifth texture unit
    142   //uniform = glGetUniformLocationARB(shader->getProgram(), "depthMap");
    143   //glUniform1iARB(uniform, 4);
    144   // FIXME we dont have a depthMap yet :-(
    145 
    146   // Give the variable "waterColor" a blue color
    147   uniform = glGetUniformLocationARB(shader->getProgram(), "waterColor");
    148   glUniform4fARB(uniform, 0.1f, 0.2f, 0.4f, 1.0f);
    149 
    150   // FIXME set camera and light information
    151   Vector lightPos(100.0f, 150.0f, 100.0f);
    152 
    153   // Store the camera position in a variable
    154   //CVector3 vPosition = g_Camera.Position();
    155   Vector vPosition(50.0f, 50.0f, 50.0f);
    156 
    157   // Give the variable "lightPos" our hard coded light position
    158   uniform = glGetUniformLocationARB(shader->getProgram(), "lightPos");
    159   glUniform4fARB(uniform, lightPos.x, lightPos.y, lightPos.z, 1.0f);
    160 
    161   // Give the variable "cameraPos" our camera position
    162   uniform = glGetUniformLocationARB(shader->getProgram(), "cameraPos");
    163   glUniform4fARB(uniform, vPosition.x, vPosition.y, vPosition.z, 1.0f);
     141
     142  ///this->shader->activateShader();
     143
     144  // reset the camera uniform to the current cam position
     145  Vector pos = State::getCameraNode()->getAbsCoor();
     146  ///cam_uni->set(pos.x, pos.y, pos.z, 1.0f);
    164147
    165148  glBegin(GL_QUADS);
    166   glNormal3f(0,1,0);
    167   glMultiTexCoord2f(GL_TEXTURE0, 0,0);
    168   glMultiTexCoord2f(GL_TEXTURE1, 0,0);
    169   glMultiTexCoord2f(GL_TEXTURE2, 0,0);
    170   glMultiTexCoord2f(GL_TEXTURE3, 0,0);
    171   glMultiTexCoord2f(GL_TEXTURE4, 0,0);
    172   glVertex3f(0,0,0);
    173 
    174   glMultiTexCoord2f(GL_TEXTURE0, 1,0);
    175   glMultiTexCoord2f(GL_TEXTURE1, 1,0);
    176   glMultiTexCoord2f(GL_TEXTURE2, 1,0);
    177   glMultiTexCoord2f(GL_TEXTURE3, 1,0);
    178   glMultiTexCoord2f(GL_TEXTURE4, 1,0);
    179   glVertex3f(100,0,0);
    180 
    181   glMultiTexCoord2f(GL_TEXTURE0, 1,1);
    182   glMultiTexCoord2f(GL_TEXTURE1, 1,1);
    183   glMultiTexCoord2f(GL_TEXTURE2, 1,1);
    184   glMultiTexCoord2f(GL_TEXTURE3, 1,1);
    185   glMultiTexCoord2f(GL_TEXTURE4, 1,1);
    186   glVertex3f(100,0,-100);
    187 
    188   glMultiTexCoord2f(GL_TEXTURE0, 0,1);
    189   glMultiTexCoord2f(GL_TEXTURE1, 0,1);
    190   glMultiTexCoord2f(GL_TEXTURE2, 0,1);
    191   glMultiTexCoord2f(GL_TEXTURE3, 0,1);
    192   glMultiTexCoord2f(GL_TEXTURE4, 0,1);
    193   glVertex3f(0,0,-100);
     149  // The back left vertice for the water
     150  glMultiTexCoord2f(GL_TEXTURE0, 0.0f, 0);//g_WaterUV);            // Reflection texture
     151  glMultiTexCoord2f(GL_TEXTURE1, 0.0f, 0);//refrUV - move);        // Refraction texture
     152  glMultiTexCoord2f(GL_TEXTURE2, 0.0f, normalUV + move2);     // Normal map texture
     153  glMultiTexCoord2f(GL_TEXTURE3, 0, 0);                       // DUDV map texture
     154  glMultiTexCoord2f(GL_TEXTURE4, 0, 0);                       // Depth texture
     155  glVertex3f(0.0f, waterHeight, 0.0f);
     156
     157  // The front left vertice for the water
     158  glMultiTexCoord2f(GL_TEXTURE0, 0.0f, 1);//0.0f);                  // Reflection texture
     159  glMultiTexCoord2f(GL_TEXTURE1, 0.0f, 1);//0.0f - move);           // Refraction texture
     160  glMultiTexCoord2f(GL_TEXTURE2, 0.0f, 0.0f + move2);          // Normal map texture
     161  glMultiTexCoord2f(GL_TEXTURE3, 0, 0);                        // DUDV map texture
     162  glMultiTexCoord2f(GL_TEXTURE4, 0, 0);                        // Depth texture
     163  glVertex3f(0.0f, waterHeight, 1000.0f);
     164
     165  // The front right vertice for the water
     166  glMultiTexCoord2f(GL_TEXTURE0, 1,1); //g_WaterUV, 0.0f);             // Reflection texture
     167  glMultiTexCoord2f(GL_TEXTURE1, 1,1);//refrUV, 0.0f - move);         // Refraction texture
     168  glMultiTexCoord2f(GL_TEXTURE2, normalUV, 0.0f + move2);      // Normal map texture
     169  glMultiTexCoord2f(GL_TEXTURE3, 0, 0);                        // DUDV map texture
     170  glMultiTexCoord2f(GL_TEXTURE4, 0, 0);                        // Depth texture
     171  glVertex3f(1000.0f, waterHeight, 1000.0f);
     172
     173  // The back right vertice for the water
     174  glMultiTexCoord2f(GL_TEXTURE0, 1,0);//g_WaterUV, g_WaterUV);        // Reflection texture
     175  glMultiTexCoord2f(GL_TEXTURE1, 1,0);//refrUV, refrUV - move);       // Refraction texture
     176  glMultiTexCoord2f(GL_TEXTURE2, normalUV, normalUV + move2);  // Normal map texture
     177  glMultiTexCoord2f(GL_TEXTURE3, 0, 0);                        // DUDV map texture
     178  glMultiTexCoord2f(GL_TEXTURE4, 0, 0);                        // Depth texture
     179  glVertex3f(1000.0f, waterHeight, 0.0f);
    194180  glEnd();
    195   //this->shader->deactivateShader();
     181
     182  ///this->shader->deactivateShader();
     183
     184  mat.unselect();
    196185
    197186  glPopMatrix();
    … …  
    200189void MappedWater::tick(float dt)
    201190{
     191  // makes the water flow
     192  this->move += this->g_WaterFlow;
     193  this->move2 = this->move * this->kNormalMapScale;
     194  this->refrUV = this->g_WaterUV;
     195  this->normalUV = this->g_WaterUV * this->kNormalMapScale;
    202196}
    203197
    … …  
    209203void MappedWater::activateReflection()
    210204{
     205  // save viewport matrix and change the viewport size
    211206  glPushAttrib(GL_VIEWPORT_BIT);
    212   //   glPushMatrix();
    213 
    214   //glLoadIdentity();
    215207  glViewport(0,0, textureSize, textureSize);
    216208
    217 
    218   // Clear the color and depth bits, reset the matrix and position our camera.
    219 
    220   //g_Camera.Look();
    221 
     209  glPushMatrix();
    222210
    223211  // If our camera is above the water we will render the scene flipped upside down.
    224212  // In order to line up the reflection nicely with the world we have to translate
    225213  // the world to the position of our reflected surface, multiplied by two.
    226   //if(g_Camera.Position().y > waterHeight)
    227   //{
    228   // Translate the world, then flip it upside down
    229   //   glTranslatef(0.0f, waterHeight*2.0f, 0.0f);
    230   //  glScalef(1.0, -1.0, 1.0);
    231 
    232   // Since the world is updside down we need to change the culling to FRONT
    233   //glCullFace(GL_FRONT);
    234 
    235   // Set our plane equation and turn clipping on
    236   // double plane[4] = {0.0, 1.0, 0.0, -waterHeight};
    237   //   glEnable(GL_CLIP_PLANE0);
    238   // glClipPlane(GL_CLIP_PLANE0, plane);
    239 
    240   // Render the world upside down and clipped (only render the top flipped).
    241   // If we don't turn OFF caustics for the reflection texture we get horrible
    242   // artifacts in the water.  That is why we set bRenderCaustics to FALSE.
    243   //RenderWorld(false);
    244 
    245   // Turn clipping off
    246   // glDisable(GL_CLIP_PLANE0);
    247 
    248   // Restore back-face culling
    249   //  glCullFace(GL_BACK);
    250   //}
    251   /*else
     214  glEnable(GL_CLIP_PLANE0);
     215  Vector pos = State::getCameraNode()->getAbsCoor();
     216  if(pos.y > waterHeight)
    252217  {
    253       // If the camera is below the water we don't want to flip the world,
    254       // but just render it clipped so only the top is drawn.
    255       double plane[4] = {0.0, 1.0, 0.0, waterHeight};
    256       glEnable(GL_CLIP_PLANE0);
    257       glClipPlane(GL_CLIP_PLANE0, plane);
    258       RenderWorld(true);
    259       glDisable(GL_CLIP_PLANE0);
    260   }*/
     218    // Translate the world, then flip it upside down
     219    glTranslatef(0.0f, waterHeight*2.0f, 0.0f);
     220    glScalef(1.0, -1.0, 1.0);
     221
     222    // Since the world is updside down we need to change the culling to FRONT
     223    glCullFace(GL_FRONT);
     224
     225    // Set our plane equation and turn clipping on
     226    double plane[4] = {0.0, 1.0, 0.0, -waterHeight};
     227    glClipPlane(GL_CLIP_PLANE0, plane);
     228  }
     229  else
     230  {
     231    // If the camera is below the water we don't want to flip the world,
     232    // but just render it clipped so only the top is drawn.
     233    double plane[4] = {0.0, 1.0, 0.0, waterHeight};
     234    glClipPlane(GL_CLIP_PLANE0, plane);
     235  }
    261236}
    262237
    … …  
    264239void MappedWater::deactivateReflection()
    265240{
    266 //  glBindTexture(GL_TEXTURE_2D, texture.getTexture()); //is done by mat.select();
    267   glBindTexture(GL_TEXTURE_2D, this->mat.getDiffuseTexture(0));
    268 
    269   //mat.setDiffuseMap(&texture, 0);
    270   // mat.select();
    271   glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, textureSize, textureSize);
    272 
    273 
     241  glDisable(GL_CLIP_PLANE0);
     242  glCullFace(GL_BACK);
     243
     244  mat.select();
     245  //glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, textureSize, textureSize);
     246  mat.renderToTexture(0, GL_TEXTURE_2D, 0, 0, 0, 0, 0, textureSize, textureSize);
     247
     248  glPopMatrix();
    274249  glPopAttrib();
    275   //   glPopMatrix();
    276250}
    277251
    278252void MappedWater::activateRefraction()
    279253{
     254  // To create the refraction and depth textures we do the same thing
     255  // we did for the reflection texture, except we don't need to turn
     256  // the world upside down.  We want to find the depth of the water,
     257  // not the depth of the sky and above water terrain.
     258
     259  // save viewport matrix and change the viewport size
     260  glPushAttrib(GL_VIEWPORT_BIT);
     261  glViewport(0,0, textureSize, textureSize);
     262
     263  glPushMatrix();
     264
     265  // If our camera is above the water we will render only the parts that
     266  // are under the water.  If the camera is below the water we render
     267  // only the stuff above the water.  Like the reflection texture, we
     268  // incorporate clipping planes to only render what we need.
     269
     270  // If the camera is above water, render the data below the water
     271  glEnable(GL_CLIP_PLANE0);
     272  Vector pos = State::getCameraNode()->getAbsCoor();
     273  if(pos.y > waterHeight)
     274  {
     275    double plane[4] = {0.0, -1.0, 0.0, waterHeight};
     276    glClipPlane(GL_CLIP_PLANE0, plane);
     277  }
     278  // If the camera is below the water, only render the data above the water
     279  else
     280  {
     281    glCullFace(GL_FRONT);
     282    double plane[4] = {0.0, 1.0, 0.0, -waterHeight};
     283    glClipPlane(GL_CLIP_PLANE0, plane);
     284  }
    280285}
    281286
    282287void MappedWater::deactivateRefraction()
    283288{
    284 }
     289  glDisable(GL_CLIP_PLANE0);
     290  glCullFace(GL_BACK);
     291
     292  mat.select();
     293  mat.renderToTexture(1, GL_TEXTURE_2D, 0, 0, 0, 0, 0, textureSize, textureSize);
     294  //glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, textureSize, textureSize, 0);
     295  //mat.renderToTexture(0, GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, textureSize, textureSize, 0);
     296
     297  // Bind the current scene to our refraction texture
     298//  glBindTexture(GL_TEXTURE_2D, g_Texture[REFRACTION_ID]);
     299//  glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, textureSize, textureSize);
     300
     301  // Bind the current scene to our depth texture
     302//  glBindTexture(GL_TEXTURE_2D, g_Texture[DEPTH_ID]);
     303//  glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, 0, 0, textureSize, textureSize, 0);
     304
     305  glPopMatrix();
     306  glPopAttrib();
     307}

  • trunk/src/world_entities/environments/mapped_water.h

    r7796 r8037  
    1010#include "world_entity.h"
    1111#include "material.h"
    12 #include "texture.h"
    1312#include "shader.h"
    1413
    … …  
    2019
    2120    void loadParams(const TiXmlElement* root);
     21
    2222
    2323    void activateReflection();
    … …  
    3131
    3232  private:
     33    void setLightPosition(float x, float y, float z) { this->lightPos = Vector(x,y,z); };
    3334    void setHeight(float height);
    3435
    3536  private:
    36     float           waterHeight;       //!< y-coord of the Water
    37     Material        mat;
     37    float               waterHeight;                //!< y-coord of the Water
    3838
    39     Texture         texture;
    40     int             textureSize;       //!< size of the texture
    41     Shader*         shader;
     39    float               move;                       //!< textures coords, speeds, positions for the shaded textures....
     40    float               move2;                      //!<
     41    float               g_WaterUV;                  //!<
     42    float               g_WaterFlow;                //!<
     43    float               refrUV;                     //!<
     44    float               normalUV;                   //!<
     45    float               kNormalMapScale;            //!<
     46
     47    int                 textureSize;                //!< size of the texture
     48    Vector              lightPos;
     49    Material            mat;
     50    Shader*             shader;
     51    Shader::Uniform*    cam_uni;                        //!< uniform that is used for the camera position
    4252
    4353};
Note: See TracChangeset for help on using the changeset viewer.