simgear/scene/tgdb/SGOceanTile.cxx

   1 /* -*-c++-*-
   2  *
   3  * Copyright (C) 2006-2007 Mathias Froehlich, Tim Moore
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License as
   7  * published by the Free Software Foundation; either version 2 of the
   8  * License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  18  * MA 02110-1301, USA.
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #  include <simgear_config.h>
  24 #endif
  25
  26 #include "SGOceanTile.hxx"
  27
  28 #include <math.h>
  29 #include <simgear/compiler.h>
  30
  31 #include <osg/Geode>
  32 #include <osg/Geometry>
  33 #include <osg/MatrixTransform>
  34 #include <osg/StateSet>
  35
  36 #include <simgear/bucket/newbucket.hxx>
  37 #include <simgear/math/sg_geodesy.hxx>
  38 #include <simgear/math/sg_types.hxx>
  39 #include <simgear/misc/texcoord.hxx>
  40 #include <simgear/scene/material/Effect.hxx>
  41 #include <simgear/scene/material/EffectGeode.hxx>
  42 #include <simgear/scene/material/mat.hxx>
  43 #include <simgear/scene/material/matlib.hxx>
  44 #include <simgear/scene/util/OsgMath.hxx>
  45 #include <simgear/scene/util/VectorArrayAdapter.hxx>
  46 #include <simgear/scene/util/SGNodeMasks.hxx>
  47
  48 using namespace simgear;
  49 // Ocean tile with curvature and apron to hide cracks. The cracks are
  50 // mostly with adjoining coastal tiles that assume a flat ocean
  51 // between corners of a tile; they also hide the micro cracks between
  52 // adjoining ocean tiles. This is probably over-engineered, but it
  53 // serves as a testbed for some things that will come later.
  54
  55 // Helper class for building and accessing the mesh. The layout of the
  56 // points in the mesh is a little wacky. First is the bottom row of
  57 // the points for the apron. Next is the left apron point, the points
  58 // in the mesh, and the right apron point, for each of the rows of the
  59 // mesh; the points for the top apron come last. This order should
  60 // help with things like vertex caching in the OpenGL driver, though
  61 // it may be superfluous for such a small mesh.
  62 namespace
  63 {
  64 class OceanMesh {
  65 public:
  66     OceanMesh(int latP, int lonP):
  67         latPoints(latP),
  68         lonPoints(lonP),
  69         geoPoints(latPoints * lonPoints + 2 * (lonPoints + latPoints)),
  70         geod_nodes(latPoints * lonPoints),
  71         vl(new osg::Vec3Array(geoPoints)),
  72         nl(new osg::Vec3Array(geoPoints)),
  73         tl(new osg::Vec2Array(geoPoints)),
  74         vlArray(*vl, lonPoints + 2, lonPoints, 1),
  75         nlArray(*nl, lonPoints + 2, lonPoints, 1),
  76         tlArray(*tl, lonPoints + 2, lonPoints, 1)
  77     {
  78         int numPoints = latPoints * lonPoints;
  79         geod = new SGGeod[numPoints];
  80         normals = new SGVec3f[numPoints];
  81         rel = new SGVec3d[numPoints];
  82     }
  83
  84     ~OceanMesh()
  85     {
  86         delete[] geod;
  87         delete[] normals;
  88         delete[] rel;
  89     }
  90
  91     const int latPoints, lonPoints;
  92     const int geoPoints;
  93     SGGeod* geod;
  94     SGVec3f* normals;
  95     SGVec3d* rel;
  96
  97     std::vector<SGGeod> geod_nodes;
  98
  99     osg::Vec3Array* vl;
 100     osg::Vec3Array* nl;
 101     osg::Vec2Array* tl;
 102     VectorArrayAdapter<osg::Vec3Array> vlArray;
 103     VectorArrayAdapter<osg::Vec3Array> nlArray;
 104     VectorArrayAdapter<osg::Vec2Array> tlArray;
 105
 106     void calcMesh(const SGVec3d& cartCenter, const SGQuatd& orient,
 107                   double clon, double clat,
 108                   double height, double width, double tex_width);
 109     void calcApronPt(int latIdx, int lonIdx, int latInner, int lonInner,
 110                      int destIdx, double tex_width);
 111     void calcApronPts(double tex_width);
 112
 113 };
 114 }
 115
 116 void OceanMesh::calcMesh(const SGVec3d& cartCenter, const SGQuatd& orient,
 117                          double clon, double clat,
 118                          double height, double width, double tex_width)
 119 {
 120     // Calculate vertices. By splitting the tile up into 4 quads on a
 121     // side we avoid curvature-of-the-earth problems; the error should
 122     // be less than .5 meters.
 123     double longInc = width * .25;
 124     double latInc = height * .25;
 125     double startLat = clat - height * .5;
 126     double startLon = clon - width * .5;
 127     for (int j = 0; j < latPoints; j++) {
 128         double lat = startLat + j * latInc;
 129         for (int i = 0; i < lonPoints; i++) {
 130             int index = (j * lonPoints) + i;
 131             geod[index] = SGGeod::fromDeg(startLon + i * longInc, lat);
 132             SGVec3d cart = SGVec3d::fromGeod(geod[index]);
 133             rel[index] = orient.transform(cart - cartCenter);
 134             normals[index] = toVec3f(orient.transform(normalize(cart)));
 135         }
 136     }
 137
 138     // Calculate texture coordinates
 139     typedef std::vector<SGGeod> GeodVector;
 140
 141     GeodVector geod_nodes(latPoints * lonPoints);
 142     VectorArrayAdapter<GeodVector> geodNodesArray(geod_nodes, lonPoints);
 143     int_list rectangle(latPoints * lonPoints);
 144     VectorArrayAdapter<int_list> rectArray(rectangle, lonPoints);
 145     for (int j = 0; j < latPoints; j++) {
 146         for (int i = 0; i < lonPoints; i++) {
 147             int index = (j * lonPoints) + i;
 148             geodNodesArray(j, i) = geod[index];
 149             rectArray(j, i) = index;
 150         }
 151     }
 152
 153     typedef std::vector<SGVec2f> Vec2Array;
 154     Vec2Array texs = sgCalcTexCoords( clat, geod_nodes, rectangle,
 155                                        1000.0 / tex_width );
 156
 157
 158     VectorArrayAdapter<Vec2Array> texsArray(texs, lonPoints);
 159
 160     for (int j = 0; j < latPoints; j++) {
 161         for (int i = 0; i < lonPoints; ++i) {
 162             int index = (j * lonPoints) + i;
 163             vlArray(j, i) = toOsg(rel[index]);
 164             nlArray(j, i) = toOsg(normals[index]);
 165             tlArray(j, i) = toOsg(texsArray(j, i));
 166         }
 167     }
 168
 169 }
 170
 171 // Apron points. For each point on the edge we'll go 150
 172 // metres "down" and 40 metres "out" to create a nice overlap. The
 173 // texture should be applied according to this dimension. The
 174 // normals of the apron polygons will be the same as the those of
 175 // the points on the edge to better disguise the apron.
 176 void OceanMesh::calcApronPt(int latIdx, int lonIdx, int latInner, int lonInner,
 177                             int destIdx, double tex_width)
 178 {
 179     static const float downDist = 150.0f;
 180     static const float outDist = 40.0f;
 181     // Get vector along edge, in the right direction to make a cross
 182     // product with the normal vector that will point out from the
 183     // mesh.
 184     osg::Vec3f edgePt = vlArray(latIdx, lonIdx);
 185     osg::Vec3f edgeVec;
 186     if (lonIdx == lonInner) {   // bottom or top edge
 187         if (lonIdx > 0)
 188             edgeVec = vlArray(latIdx, lonIdx - 1) - edgePt;
 189         else
 190             edgeVec = edgePt - vlArray(latIdx, lonIdx + 1);
 191         if (latIdx > latInner)
 192             edgeVec = -edgeVec;  // Top edge
 193     } else {                     // right or left edge
 194         if (latIdx > 0)
 195             edgeVec = edgePt - vlArray(latIdx - 1, lonIdx);
 196         else
 197             edgeVec = vlArray(latIdx + 1, lonIdx) - edgePt;
 198         if (lonIdx > lonInner)  // right edge
 199             edgeVec = -edgeVec;
 200     }
 201     edgeVec.normalize();
 202     osg::Vec3f outVec = nlArray(latIdx, lonIdx) ^ edgeVec;
 203     (*vl)[destIdx]
 204         = edgePt - nlArray(latIdx, lonIdx) * downDist + outVec * outDist;
 205     (*nl)[destIdx] = nlArray(latIdx, lonIdx);
 206     static const float apronDist
 207         = sqrtf(downDist * downDist  + outDist * outDist);
 208     float texDelta = apronDist / tex_width;
 209     if (lonIdx == lonInner) {
 210         if (latIdx > latInner)
 211             (*tl)[destIdx]
 212                 = tlArray(latIdx, lonIdx) + osg::Vec2f(0.0f, texDelta);
 213         else
 214             (*tl)[destIdx]
 215                 = tlArray(latIdx, lonIdx) - osg::Vec2f(0.0f, texDelta);
 216     } else {
 217         if (lonIdx > lonInner)
 218             (*tl)[destIdx]
 219                 = tlArray(latIdx, lonIdx) + osg::Vec2f(texDelta, 0.0f);
 220         else
 221             (*tl)[destIdx]
 222                 = tlArray(latIdx, lonIdx) - osg::Vec2f(texDelta, 0.0f);
 223     }
 224 }
 225
 226 void OceanMesh::calcApronPts(double tex_width)
 227 {
 228     for (int i = 0; i < lonPoints; i++)
 229         calcApronPt(0, i, 1, i, i, tex_width);
 230     int topApronOffset = latPoints + (2 + lonPoints) * latPoints;
 231     for (int i = 0; i < lonPoints; i++)
 232         calcApronPt(latPoints - 1, i, latPoints - 2, i,
 233                     i + topApronOffset, tex_width);
 234     for (int i = 0; i < latPoints; i++) {
 235         calcApronPt(i, 0, i, 1, lonPoints + i * (lonPoints + 2), tex_width);
 236         calcApronPt(i, lonPoints - 1, i, lonPoints - 2,
 237                     lonPoints + i * (lonPoints + 2) + 1 + lonPoints, tex_width);
 238     }
 239 }
 240
 241 namespace
 242 {
 243 // Enter the vertices of triangles that fill one row of the
 244 // mesh. The vertices are entered in counter-clockwise order.
 245 void fillDrawElementsRow(int width, short row0Start, short row1Start,
 246                          osg::DrawElementsUShort::vector_type::iterator&
 247                          elements)
 248 {
 249     short row0Idx = row0Start;
 250     short row1Idx = row1Start;
 251     for (int i = 0; i < width - 1; i++, row0Idx++, row1Idx++) {
 252         *elements++ = row0Idx;
 253         *elements++ = row0Idx + 1;
 254         *elements++ = row1Idx;
 255         *elements++ = row1Idx;
 256         *elements++ = row0Idx + 1;
 257         *elements++ = row1Idx + 1;
 258     }
 259 }
 260
 261 void fillDrawElementsWithApron(short height, short width,
 262                                osg::DrawElementsUShort::vector_type::iterator
 263                                elements)
 264 {
 265     // First apron row
 266     fillDrawElementsRow(width, 0, width + 1, elements);
 267     for (short i = 0; i < height - 1; i++)
 268         fillDrawElementsRow(width + 2, width + i * (width + 2),
 269                             width + (i + 1) * (width + 2),
 270                             elements);
 271     // Last apron row
 272     short topApronBottom = width + (height - 1) * (width + 2) + 1;
 273     fillDrawElementsRow(width, topApronBottom, topApronBottom + width + 1,
 274                         elements);
 275 }
 276 }
 277
 278 osg::Node* SGOceanTile(const SGBucket& b, SGMaterialLib *matlib, int latPoints, int lonPoints)
 279 {
 280     Effect *effect = 0;
 281
 282     double tex_width = 1000.0;
 283
 284     // find Ocean material in the properties list
 285     SGMaterial *mat = matlib->findCached( "Ocean" );
 286     if ( mat != NULL ) {
 287         // set the texture width and height values for this
 288         // material
 289         tex_width = mat->get_xsize();
 290
 291         // set OSG State
 292         effect = mat->get_effect();
 293     } else {
 294         SG_LOG( SG_TERRAIN, SG_ALERT, "Ack! unknown use material name = Ocean");
 295     }
 296     OceanMesh grid(latPoints, lonPoints);
 297     // Calculate center point
 298     SGVec3d cartCenter = SGVec3d::fromGeod(b.get_center());
 299     SGGeod geodPos = SGGeod::fromCart(cartCenter);
 300     SGQuatd hlOr = SGQuatd::fromLonLat(geodPos)*SGQuatd::fromEulerDeg(0, 0, 180);
 301
 302     double clon = b.get_center_lon();
 303     double clat = b.get_center_lat();
 304     double height = b.get_height();
 305     double width = b.get_width();
 306
 307     grid.calcMesh(cartCenter, hlOr, clon, clat, height, width, tex_width);
 308     grid.calcApronPts(tex_width);
 309
 310     osg::Vec4Array* cl = new osg::Vec4Array;
 311     cl->push_back(osg::Vec4(1, 1, 1, 1));
 312
 313     osg::Geometry* geometry = new osg::Geometry;
 314     geometry->setDataVariance(osg::Object::STATIC);
 315     geometry->setVertexArray(grid.vl);
 316     geometry->setNormalArray(grid.nl);
 317     geometry->setNormalBinding(osg::Geometry::BIND_PER_VERTEX);
 318     geometry->setColorArray(cl);
 319     geometry->setColorBinding(osg::Geometry::BIND_OVERALL);
 320     geometry->setTexCoordArray(0, grid.tl);
 321
 322     // Allocate the indices for triangles in the mesh and the apron
 323     osg::DrawElementsUShort* drawElements
 324         = new osg::DrawElementsUShort(GL_TRIANGLES,
 325                                       6 * ((latPoints - 1) * (lonPoints + 1)
 326                                            + 2 * (latPoints - 1)));
 327     fillDrawElementsWithApron(latPoints, lonPoints, drawElements->begin());
 328     geometry->addPrimitiveSet(drawElements);
 329
 330     EffectGeode* geode = new EffectGeode;
 331     geode->setName("Ocean tile");
 332     geode->setEffect(effect);
 333     geode->addDrawable(geometry);
 334     geode->runGenerators(geometry);
 335
 336     osg::MatrixTransform* transform = new osg::MatrixTransform;
 337     transform->setName("Ocean");
 338     transform->setMatrix(osg::Matrix::rotate(toOsg(hlOr))*
 339                          osg::Matrix::translate(toOsg(cartCenter)));
 340     transform->addChild(geode);
 341     transform->setNodeMask( ~simgear::MODELLIGHT_BIT );
 342
 343     return transform;
 344 }