src/client/land/LandVisibilityPatch.cpp

   1 ////////////////////////////////////////////////////////////////////////////////
   2 //    Scorched3D (c) 2000-2004
   3 //
   4 //    This file is part of Scorched3D.
   5 //
   6 //    Scorched3D is free software; you can redistribute it and/or modify
   7 //    it under the terms of the GNU General Public License as published by
   8 //    the Free Software Foundation; either version 2 of the License, or
   9 //    (at your option) any later version.
  10 //
  11 //    Scorched3D is distributed in the hope that it will be useful,
  12 //    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 //    GNU General Public License for more details.
  15 //
  16 //    You should have received a copy of the GNU General Public License
  17 //    along with Scorched3D; if not, write to the Free Software
  18 //    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19 ////////////////////////////////////////////////////////////////////////////////
  20
  21 #include <land/LandVisibilityPatch.h>
  22 #include <land/VisibilityPatchGrid.h>
  23 #include <landscapemap/LandscapeMaps.h>
  24 #include <landscapemap/GraphicalHeightMap.h>
  25 #include <landscape/GraphicalLandscapeMap.h>
  26 #include <graph/OptionsDisplay.h>
  27 #include <graph/MainCamera.h>
  28 #include <client/ScorchedClient.h>
  29 #include <common/Logger.h>
  30 #include <GLEXT/GLStateExtension.h>
  31 #include <GLEXT/GLInfo.h>
  32 #include <GLW/GLWFont.h>
  33
  34 LandVisibilityPatch::LandVisibilityPatch() :
  35         visible_(false), recalculateErrors_(false),
  36         leftPatch_(0), rightPatch_(0),
  37         topPatch_(0), bottomPatch_(0),
  38         visibilityIndex_(-1),
  39         dataSize_(0)
  40 {
  41 }
  42
  43 LandVisibilityPatch::~LandVisibilityPatch()
  44 {
  45 }
  46
  47 static float getHeight(int x, int y)
  48 {
  49         int mapWidth = ScorchedClient::instance()->getLandscapeMaps().
  50                 getGroundMaps().getLandscapeWidth();
  51
  52         GraphicalLandscapeMap *landscapeMap = (GraphicalLandscapeMap *)
  53                 ScorchedClient::instance()->getLandscapeMaps().
  54                         getGroundMaps().getHeightMap().getGraphicalMap();
  55         return landscapeMap->getHeightData()[x + (y * (mapWidth + 1))].floatPosition[2];
  56 }
  57
  58 static float calculateError(int x1, int x2, int y1, int y2,
  59         float x1y1, float x2y2, float x1y2, float x2y1)
  60 {
  61         if (x2 - x1 <= 1) return 0.0f;
  62
  63         int midx = (x1 + x2) / 2;
  64         int midy = (y1 + y2) / 2;
  65         float actualheight = getHeight(midx, midy);
  66
  67         float approxheight1 = (x1y1 + x2y2) / 2.0f;
  68         float approxheight2 = (x1y2 + x2y1) / 2.0f;
  69         float approxheight3 = (x1y1 + x1y2) / 2.0f;
  70         float approxheight4 = (x1y1 + x2y1) / 2.0f;
  71         float approxheight5 = (x1y2 + x2y2) / 2.0f;
  72         float approxheight6 = (x2y1 + x2y2) / 2.0f;
  73
  74         float heightdiff1 = fabs(approxheight1 - actualheight);
  75         float heightdiff2 = fabs(approxheight2 - actualheight);
  76
  77         float errorChild1 = calculateError(x1, midx, y1, midy,
  78                 x1y1, approxheight1, approxheight3, approxheight4);
  79         float errorChild2 = calculateError(midx, x2, y1, midy,
  80                 approxheight4, approxheight6, approxheight1, x2y1);
  81         float errorChild3 = calculateError(x1, midx, midy, y2,
  82                 approxheight3, approxheight5, x1y2, approxheight2);
  83         float errorChild4 = calculateError(midx, x2, midy, y2,
  84                 approxheight2, x2y2, approxheight5, approxheight6);
  85
  86         float errorChildren = MAX(errorChild1, MAX(errorChild2, MAX(errorChild3, errorChild4)));
  87         float totalError = MAX(errorChildren, MAX(heightdiff1, heightdiff2));
  88         return totalError;
  89 }
  90
  91 void LandVisibilityPatch::setLocation(int x, int y,
  92         LandVisibilityPatch *leftPatch,
  93         LandVisibilityPatch *rightPatch,
  94         LandVisibilityPatch *topPatch,
  95         LandVisibilityPatch *bottomPatch)
  96 {
  97         int mapWidth = ScorchedClient::instance()->getLandscapeMaps().
  98                 getGroundMaps().getLandscapeWidth();
  99         int mapHeight = ScorchedClient::instance()->getLandscapeMaps().
 100                 getGroundMaps().getLandscapeHeight();
 101
 102         DIALOG_ASSERT(x >= 0 && y >= 0 &&
 103                 x < mapWidth && y < mapHeight);
 104
 105         // Set location and neighbors
 106         x_ = x; y_ = y;
 107         leftPatch_ = leftPatch;
 108         rightPatch_ = rightPatch;
 109         topPatch_ = topPatch;
 110         bottomPatch_ = bottomPatch;
 111
 112         // Set pointers to heightmap
 113         dataSize_ = (mapWidth + 1) * (mapHeight + 1);
 114
 115         GraphicalLandscapeMap *landscapeMap = (GraphicalLandscapeMap *)
 116                 ScorchedClient::instance()->getLandscapeMaps().
 117                         getGroundMaps().getHeightMap().getGraphicalMap();
 118         dataOffSet_ = (x + (y * (mapWidth + 1))) *
 119                 sizeof(GraphicalLandscapeMap::HeightData) / sizeof(float);
 120
 121         calculateErrors();
 122 }
 123
 124 void LandVisibilityPatch::calculateErrors()
 125 {
 126         maxHeight_ = 0.0f;
 127         minHeight_ = 100000.0f;
 128         for (int i=0; i<=5; i++)
 129         {
 130                 float error = 0.0f;
 131                 if (i>0)
 132                 {
 133                         int skip = 1 << i;
 134                         for (int y1=y_; y1<y_+32; y1+=skip)
 135                         {
 136                                 for (int x1=x_; x1<x_+32; x1+=skip)
 137                                 {
 138                                         int x2 = x1 + skip;
 139                                         int y2 = y1 + skip;
 140
 141                                         float x1y1 = getHeight(x1, y1);
 142                                         float x2y2 = getHeight(x2, y2);
 143                                         float x1y2 = getHeight(x1, y2);
 144                                         float x2y1 = getHeight(x2, y1);
 145
 146                                         float thisError = calculateError(x1, x2, y1, y2,
 147                                                 x1y1, x2y2, x1y2, x2y1);
 148                                         error = MAX(error, thisError);
 149
 150                                         if (x1y1 > maxHeight_) maxHeight_ = x1y1;
 151                                         if (x1y1 < minHeight_) minHeight_ = x1y1;
 152                                 }
 153                         }
 154                 }
 155
 156                 indexErrors_[i] = error;
 157         }
 158
 159         float heightRange = maxHeight_ - minHeight_;
 160         boundingSize_ = MAX(32.0f, heightRange) * 1.25f;
 161         position_ = Vector(float(x_ + 16), float(y_ + 16),
 162                 heightRange / 2.0f + minHeight_);
 163 }
 164
 165 bool LandVisibilityPatch::setVisible(float distance)
 166 {
 167         visible_ = true;
 168
 169         if (recalculateErrors_)
 170         {
 171                 calculateErrors();
 172                 recalculateErrors_ = false;
 173         }
 174
 175         float maxError = 5.0f;
 176         if (distance < 32.0f) maxError = 1.0f;
 177         else if (distance < 64.0f) maxError = 1.5f;
 178         else if (distance < 256.0f) maxError = 3.0f;
 179
 180         visibilityIndex_ = 0;
 181         if (!OptionsDisplay::instance()->getNoLandLOD())
 182         {
 183                 for (int i=0; i<=5; i++)
 184                 {
 185                         if (indexErrors_[i] > maxError) break;
 186                         visibilityIndex_ = i;
 187                 }
 188         }
 189
 190         return true;
 191 }
 192
 193 void LandVisibilityPatch::setNotVisible()
 194 {
 195         visible_ = false;
 196 }
 197
 198 void LandVisibilityPatch::draw(MipMapPatchIndex &index, bool simple)
 199 {
 200         GraphicalLandscapeMap *landscapeMap = (GraphicalLandscapeMap *)
 201                 ScorchedClient::instance()->getLandscapeMaps().
 202                         getGroundMaps().getHeightMap().getGraphicalMap();
 203         float *heightMapData = &landscapeMap->getHeightData()->floatPosition[0];
 204
 205         // Number triangles
 206         GLInfo::addNoTriangles(index.getSize() - 2);
 207
 208         if (!OptionsDisplay::instance()->getNoGLDrawElements() &&
 209                 GLStateExtension::hasDrawRangeElements())
 210         {
 211                 // Map data to draw
 212                 float *data = 0;
 213                 if (landscapeMap->getBufferObject())
 214                 {
 215                         data = (float*) NULL + dataOffSet_;
 216                 }
 217                 else
 218                 {
 219                         data = &heightMapData[dataOffSet_];
 220                 }
 221
 222                 // Vertices On
 223                 glVertexPointer(3, GL_FLOAT, sizeof(GraphicalLandscapeMap::HeightData), data);
 224
 225                 if (!simple)
 226                 {
 227                         // Normals On
 228                         glNormalPointer(GL_FLOAT, sizeof(GraphicalLandscapeMap::HeightData), data + 3);
 229
 230                         // Tex Coords
 231                         if (GLStateExtension::hasMultiTex())
 232                         {
 233                                 glClientActiveTextureARB(GL_TEXTURE1_ARB);
 234                                 glTexCoordPointer(2, GL_FLOAT, sizeof(GraphicalLandscapeMap::HeightData), data + 6);
 235                                 if (GLStateExtension::getTextureUnits() > 2)
 236                                 {
 237                                         glClientActiveTextureARB(GL_TEXTURE2_ARB);
 238                                         glTexCoordPointer(2, GL_FLOAT, sizeof(GraphicalLandscapeMap::HeightData), data + 8);
 239                                 }
 240                         }
 241                         glClientActiveTextureARB(GL_TEXTURE0_ARB);
 242                         glTexCoordPointer(2, GL_FLOAT, sizeof(GraphicalLandscapeMap::HeightData), data + 6);
 243                 }
 244
 245                 // Map indices to draw
 246                 unsigned short *indices = 0;
 247                 if (index.getBufferOffSet() != -1)
 248                 {
 249                         indices = (unsigned short *) NULL + (index.getBufferOffSet() / sizeof(unsigned short));
 250                 }
 251                 else
 252                 {
 253                         indices = index.getIndices();
 254                 }
 255
 256                 // Draw elements
 257                 glDrawRangeElements(GL_TRIANGLE_STRIP,
 258                         index.getMinIndex(),
 259                         index.getMaxIndex(),
 260                         index.getSize(),
 261                         GL_UNSIGNED_SHORT,
 262                         indices);
 263                 DIALOG_ASSERT((index.getMaxIndex()-index.getMinIndex()+1) <
 264                         GLStateExtension::getMaxElementVertices());
 265                 DIALOG_ASSERT(index.getSize() <
 266                         GLStateExtension::getMaxElementIndices());
 267         }
 268         else
 269         {
 270                 glBegin(GL_TRIANGLE_STRIP);
 271                         for (int i=0; i<index.getSize(); i++)
 272                         {
 273                                 float *data = &heightMapData[dataOffSet_] +
 274                                         (sizeof(GraphicalLandscapeMap::HeightData) / 4 * index.getIndices()[i]);
 275                                 if (!simple)
 276                                 {
 277                                         glNormal3fv(data + 3);
 278                                         glTexCoord2fv(data + 6);
 279                                         if (GLStateExtension::hasMultiTex())
 280                                         {
 281                                                 glMultiTexCoord2fvARB(GL_TEXTURE1_ARB, data + 6);
 282                                                 if (GLStateExtension::getTextureUnits() > 2)
 283                                                 {
 284                                                         glMultiTexCoord2fvARB(GL_TEXTURE2_ARB, data + 8);
 285                                                 }
 286                                         }
 287                                 }
 288
 289                                 glVertex3fv(data);
 290                         }
 291                 glEnd();
 292         }
 293 }
 294
 295 void LandVisibilityPatch::drawLODLevel(MipMapPatchIndex &index)
 296 {
 297         if (OptionsDisplay::instance()->getDrawLines()) glPolygonMode(GL_FRONT, GL_FILL);
 298
 299         GraphicalLandscapeMap *landscapeMap = (GraphicalLandscapeMap *)
 300                 ScorchedClient::instance()->getLandscapeMaps().
 301                         getGroundMaps().getHeightMap().getGraphicalMap();
 302         float *heightMapData = &landscapeMap->getHeightData()->floatPosition[0];
 303
 304         Vector red(1.0f, 0.0f, 0.0f);
 305         Vector yellow(1.0f, 1.0f, 0.0f);
 306         GLWFont::instance()->getGameFont()->drawBilboard(red, 1.0f, 3.0f,
 307                 position_[0], position_[1], position_[2],
 308                 S3D::formatStringBuffer("%i", visibilityIndex_));
 309
 310         if ((MainCamera::instance()->getCamera().getLookAt() - position_).Magnitude() < 20.0f)
 311         {
 312                 for (int i=0; i<index.getSize(); i++)
 313                 {
 314                         float *data = &heightMapData[dataOffSet_] +
 315                                 (sizeof(GraphicalLandscapeMap::HeightData) / 4 * index.getIndices()[i]);
 316
 317                         GLWFont::instance()->getGameFont()->drawBilboard(yellow, 1.0f, 1.0f,
 318                                 data[0], data[1], data[2] + i * 1.5f,
 319                                 S3D::formatStringBuffer("%i", i));
 320                 }
 321         }
 322
 323         if (OptionsDisplay::instance()->getDrawLines()) glPolygonMode(GL_FRONT, GL_LINE);
 324 }