src/eal/horde3d/extensions/island.cc

   1 /*
   2  * Island scene node for Horde3D
   3  *
   4  * Copyright (C) 2009 Mathias Gottschlag, Nicolas Schulz, Volker Wiendl
   5  *
   6  * This file is part of OpenStranded
   7  *
   8  * OpenStranded is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * OpenStranded is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with OpenStranded. If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "eal/horde3d/extensions/island.hh"
  23 #include "egModules.h"
  24 #include "egMaterial.h"
  25 #include "utOpenGL.h"
  26
  27 namespace eal
  28 {
  29         namespace horde3d
  30         {
  31                 const char *vsIslandDebugView =
  32                         "uniform mat4 worldMat;\n"
  33                         "varying vec4 color;\n"
  34                         "void main() {\n"
  35                         "       color = gl_Color;\n"
  36                         "       gl_Position = gl_ModelViewProjectionMatrix * worldMat * gl_Vertex;\n"
  37                         "}";
  38
  39                 const char *fsIslandDebugView =
  40                         "varying vec4 color;\n"
  41                         "void main() {\n"
  42                         "       gl_FragColor = color;\n"
  43                         "}\n";
  44
  45                 ShaderCombination IslandNode::debugViewShader;
  46
  47                 IslandNode::~IslandNode()
  48                 {
  49                 }
  50
  51                 SceneNodeTpl *IslandNode::parsingFunc(std::map< std::string, std::string > &attribs)
  52                 {
  53                         // TODO
  54                 }
  55                 SceneNode *IslandNode::factoryFunc(const SceneNodeTpl &nodeTpl)
  56                 {
  57                         if( nodeTpl.type != SNT_IslandNode ) return 0x0;
  58
  59                         return new IslandNode( *(IslandNodeTpl *)&nodeTpl );
  60                 }
  61                 void IslandNode::renderFunc(const std::string &shaderContext, const std::string &theClass, bool debugView,
  62                         const Frustum *frust1, const Frustum *frust2, RenderingOrder::List order, int occSet)
  63                 {
  64                         CameraNode *curCam = Modules::renderer().getCurCamera();
  65                         if( curCam == 0x0 ) return;
  66
  67                         Modules::renderer().setMaterial( 0x0, "" );
  68
  69                         // Loop through island queue
  70                         for( uint32 i = 0, s = (uint32)Modules::sceneMan().getRenderableQueue().size(); i < s; ++i )
  71                         {
  72                                 if( Modules::sceneMan().getRenderableQueue()[i].type != SNT_IslandNode )
  73                                 {
  74                                         continue;
  75                                 }
  76
  77                                 IslandNode *island = (IslandNode*)Modules::sceneMan().getRenderableQueue()[i].node;
  78
  79                                 if (!debugView)
  80                                 {
  81                                         if (!island->materialRes->isOfClass(theClass)) continue;
  82                                         if (!Modules::renderer().setMaterial(island->materialRes, shaderContext)) continue;
  83                                 }
  84                                 else
  85                                 {
  86                                         Modules::renderer().setShader(&debugViewShader);
  87                                 }
  88
  89                                 Vec3f localCamPos( curCam->getAbsTrans().x[12], curCam->getAbsTrans().x[13], curCam->getAbsTrans().x[14] );
  90                                 localCamPos = island->_absTrans.inverted() * localCamPos;
  91                                 // Draw terrain
  92                                 // TODO
  93                                 for (int i = 0; i < TILE_COUNT; i++)
  94                                 {
  95                                         if (island->terrainpatches[i] != 0)
  96                                         {
  97                                                 glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, island->indexBuffer[0]);
  98                                                 glBindBuffer(GL_ARRAY_BUFFER, island->terrainpatches[i]);
  99                                                 glVertexPointer(3, GL_FLOAT, sizeof(float) * 3, (char*)0);
 100                                                 glNormalPointer(GL_FLOAT, sizeof(float) * 3,
 101                                                         (char*)((TILE_SIZE + 1) * (TILE_SIZE + 1) * sizeof(float) * 3));
 102                                                 glEnableClientState(GL_VERTEX_ARRAY);
 103                                                 glEnableClientState(GL_NORMAL_ARRAY);
 104
 105                                                 // World transformation
 106                                                 ShaderCombination *curShader = Modules::renderer().getCurShader();
 107                                                 if (curShader->uni_worldMat >= 0)
 108                                                 {
 109                                                         glUniformMatrix4fv(curShader->uni_worldMat, 1, false, &island->_absTrans.x[0]);
 110                                                 }
 111                                                 if (curShader->uni_worldNormalMat >= 0)
 112                                                 {
 113                                                         Matrix4f normalMat4 = island->_absTrans.inverted().transposed();
 114                                                         float normalMat[9] = { normalMat4.x[0], normalMat4.x[1], normalMat4.x[2],
 115                                                                                                 normalMat4.x[4], normalMat4.x[5], normalMat4.x[6],
 116                                                                                                 normalMat4.x[8], normalMat4.x[9], normalMat4.x[10] };
 117                                                         glUniformMatrix3fv(curShader->uni_worldNormalMat, 1, false, normalMat );
 118                                                 }
 119
 120                                                 glDrawElements(GL_TRIANGLES, TILE_SIZE * TILE_SIZE * 6, GL_UNSIGNED_SHORT, (char *)0);
 121                                                 Modules::renderer().incStat(EngineStats::BatchCount, 1);
 122                                                 Modules::renderer().incStat(EngineStats::TriCount, TILE_SIZE * TILE_SIZE * 2);
 123
 124                                                 glDisableClientState(GL_VERTEX_ARRAY);
 125                                                 glDisableClientState(GL_NORMAL_ARRAY);
 126                                         }
 127                                 }
 128                         }
 129                 }
 130
 131                 bool IslandNode::canAttach(SceneNode &parent)
 132                 {
 133                         return true;
 134                 }
 135                 int IslandNode::getParami(int param)
 136                 {
 137                         switch( param )
 138                         {
 139                         case IslandNodeParams::MaterialRes:
 140                                 if( materialRes != 0x0 ) return materialRes->getHandle();
 141                                 else return 0;
 142                         case IslandNodeParams::SizeX:
 143                                 return sizeX;
 144                         case IslandNodeParams::SizeZ:
 145                                 return sizeZ;
 146                         default:
 147                                 return SceneNode::getParami( param );
 148                         }
 149                 }
 150                 bool IslandNode::setParami(int param, int value)
 151                 {
 152                         Resource *res;
 153                         switch( param )
 154                         {
 155                         case IslandNodeParams::MaterialRes:
 156                                 res = Modules::resMan().resolveResHandle( value );
 157                                 if (res == 0x0 || res->getType() != ResourceTypes::Material)
 158                                 {
 159                                         Modules::log().writeDebugInfo( "Invalid Material resource for Island node %i", _handle );
 160                                         return false;
 161                                 }
 162                                 materialRes = (MaterialResource*)res;
 163                                 return true;
 164                         case IslandNodeParams::SizeX:
 165                                 if ((value <= 0) || (value > 512))
 166                                 {
 167                                         Modules::log().writeDebugInfo( "Invalid size for Terrain node %i (must be 2^x + 1)", _handle );
 168                                         return false;
 169                                 }
 170
 171                                 if (sizeX == value)
 172                                         return true;
 173
 174                                 sizeX = value;
 175                                 // TODO: Recreate terrain
 176                                 return true;
 177                         case IslandNodeParams::SizeZ:
 178                                 if ((value <= 0) || (value > 512))
 179                                 {
 180                                         Modules::log().writeDebugInfo( "Invalid size for Terrain node %i (must be 2^x + 1)", _handle );
 181                                         return false;
 182                                 }
 183
 184                                 if (sizeZ == value)
 185                                         return true;
 186
 187                                 sizeZ = value;
 188                                 // TODO: Recreate terrain
 189                                 return true;
 190                         default:
 191                                 return SceneNode::setParami(param, value);
 192                         }
 193                 }
 194                 float IslandNode::getParamf(int param)
 195                 {
 196                         switch (param)
 197                         {
 198                         case IslandNodeParams::MeshQuality:
 199                                 return meshQuality;
 200                         default:
 201                                 return SceneNode::getParamf(param);
 202                         }
 203                 }
 204                 bool IslandNode::setParamf(int param, float value)
 205                 {
 206                         switch (param)
 207                         {
 208                         case IslandNodeParams::MeshQuality:
 209                                 meshQuality = value;
 210                                 return true;
 211                         default:
 212                                 return SceneNode::setParamf(param, value);
 213                         }
 214                 }
 215
 216                 IslandNode::IslandNode(const IslandNodeTpl &islandTpl) : SceneNode(islandTpl),
 217                         materialRes(islandTpl.matRes), sizeX(islandTpl.sizeX), sizeZ(islandTpl.sizeZ),
 218                         meshQuality(islandTpl.meshQuality), heightdata(islandTpl.heightdata)
 219                 {
 220                         _renderable = true;
 221                         localBBox.getMinCoords() = Vec3f(-1000, 0, -1000);
 222                         localBBox.getMaxCoords() = Vec3f(1000, 1, 1000);
 223                         for (int i = 0; i < TILE_COUNT; i++)
 224                         {
 225                                 terrainpatches[i] = 0;
 226                                 vertexdata[i] = 0;
 227                         }
 228                         heightdata = new float[(sizeX + 1) * (sizeZ + 1)];
 229                         for (int i = 0; i < (sizeX + 1) * (sizeZ + 1); i++)
 230                         {
 231                                 heightdata[i] = 0.5;
 232                         }
 233                         // Create index buffers
 234                         createIndexBuffers();
 235                         // Create terrain patches
 236                         createVertexBuffers();
 237                         // Create extension plane around the terrain
 238                         createExtension();
 239                         // Set height data
 240                         updateVertices(0, 0, sizeX + 1, sizeZ + 1);
 241                 }
 242
 243                 void IslandNode::createIndexBuffers()
 244                 {
 245                         int size = TILE_SIZE;
 246                         for (int i = 0; i < 5; i++)
 247                         {
 248                                 int factor = TILE_SIZE / size;
 249                                 // Create buffer
 250                                 unsigned short *indices = new unsigned short[size * size * 6];
 251                                 // Surface
 252                                 for (int z = 0; z < size; z++)
 253                                 {
 254                                         for (int x = 0; x < size; x++)
 255                                         {
 256                                                 indices[(z * size + x) * 6 + 0] = (z * factor + 0)      * (TILE_SIZE + 1) + x * factor + 0;
 257                                                 indices[(z * size + x) * 6 + 2] = (z * factor + 0)      * (TILE_SIZE + 1) + x * factor + factor;
 258                                                 indices[(z * size + x) * 6 + 1] = (z * factor + factor) * (TILE_SIZE + 1) + x * factor + 0;
 259                                                 indices[(z * size + x) * 6 + 3] = (z * factor + 0)      * (TILE_SIZE + 1) + x * factor + factor;
 260                                                 indices[(z * size + x) * 6 + 5] = (z * factor + factor) * (TILE_SIZE + 1) + x * factor + factor;
 261                                                 indices[(z * size + x) * 6 + 4] = (z * factor + factor) * (TILE_SIZE + 1) + x * factor + 0;
 262                                         }
 263                                 }
 264                                 // TODO: Skirts
 265                                 indexBuffer[i] = Modules::renderer().uploadIndices(indices, size * size * 6 * sizeof(short));
 266                                 delete[] indices;
 267                         }
 268                 }
 269
 270                 void IslandNode::createVertexBuffers()
 271                 {
 272                         int alignedx = ((sizeX - 1) + TILE_SIZE) & ~(TILE_SIZE - 1);
 273                         int alignedz = ((sizeZ - 1) + TILE_SIZE) & ~(TILE_SIZE - 1);
 274                         int size = (TILE_SIZE + 1) * (TILE_SIZE + 1) * 3;
 275                         // Create flat vertex buffers
 276                         for (int z = 0; z < alignedz / TILE_SIZE; z++)
 277                         {
 278                                 for (int x = 0; x < alignedx / TILE_SIZE; x++)
 279                                 {
 280                                         // Create and fill vertex buffer
 281                                         vertexdata[x + z * EDGE_TILES] = new float[size * 2];
 282                                         for (int z2 = 0; z2 < TILE_SIZE + 1; z2++)
 283                                         {
 284                                                 for (int x2 = 0; x2 < TILE_SIZE + 1; x2++)
 285                                                 {
 286                                                         float *vertex = &vertexdata[x + z * EDGE_TILES][(z2 * (TILE_SIZE + 1) + x2) * 3];
 287                                                         vertex[0] = x * TILE_SIZE + x2;
 288                                                         vertex[1] = 0;
 289                                                         vertex[2] = z * TILE_SIZE + z2;
 290                                                 }
 291                                         }
 292                                         // Normals
 293                                         for (int z2 = 0; z2 < TILE_SIZE + 1; z2++)
 294                                         {
 295                                                 for (int x2 = 0; x2 < TILE_SIZE + 1; x2++)
 296                                                 {
 297                                                         float *vertex = &vertexdata[x + z * EDGE_TILES][(z2 * (TILE_SIZE + 1) + x2) * 3 + size];
 298                                                         vertex[0] = 0;
 299                                                         vertex[1] = 1;
 300                                                         vertex[2] = 0;
 301                                                 }
 302                                         }
 303                                         // TODO: skirts
 304                                         // Create mesh
 305                                         terrainpatches[x + z * EDGE_TILES] = Modules::renderer().uploadVertices(vertexdata[x + z * EDGE_TILES],
 306                                                 size * sizeof(float) * 2);
 307                                 }
 308                         }
 309                 }
 310                 float IslandNode::getHeight(int x, int z)
 311                 {
 312                         if (x < 0) x = 0;
 313                         if (z < 0) z = 0;
 314                         if (x > sizeX) x = sizeX;
 315                         if (z > sizeZ) z = sizeZ;
 316
 317                         return heightdata[z * (sizeX + 1) + x];
 318                 }
 319                 void IslandNode::updateVertices(int x, int y, int width, int height)
 320                 {
 321                         int tilesx = sizeX / TILE_SIZE;
 322                         int tilesz = sizeZ / TILE_SIZE;
 323                         // Set vertex data
 324                         // TODO: Optimize this
 325                         for (int iz = 0; iz < height; iz++)
 326                         {
 327                                 int tilez = (iz + y) / TILE_SIZE;
 328                                 int offsetz = (iz + y) % TILE_SIZE;
 329                                 if (tilez == tilesz)
 330                                 {
 331                                         tilez--;
 332                                         offsetz = TILE_SIZE;
 333                                 }
 334                                 for (int ix = 0; ix < width; ix ++)
 335                                 {
 336                                         int tilex = (ix + x) / TILE_SIZE;
 337                                         int offsetx = (ix + x) % TILE_SIZE;
 338                                         if (tilex == tilesx)
 339                                         {
 340                                                 tilex--;
 341                                                 offsetx = TILE_SIZE;
 342                                         }
 343                                         float *vertex = &vertexdata[tilex + tilez * EDGE_TILES][(offsetz * (TILE_SIZE + 1) + offsetx) * 3];
 344                                         vertex[1] = heightdata[(iz + y) * (sizeX + 1) + (ix + x)];
 345                                         if ((offsetx == 0) && (tilex > 0))
 346                                         {
 347                                                 tilex--;
 348                                                 offsetx = TILE_SIZE;
 349                                                 float *vertex = &vertexdata[tilex + tilez * EDGE_TILES][(offsetz * (TILE_SIZE + 1) + offsetx) * 3];
 350                                                 vertex[1] = heightdata[(iz + y) * (sizeX + 1) + (ix + x)];
 351                                         }
 352                                 }
 353                                 if ((offsetz == 0) && (tilez > 0))
 354                                 {
 355                                         tilez--;
 356                                         offsetz = TILE_SIZE;
 357                                         for (int ix = 0; ix < width; ix ++)
 358                                         {
 359                                                 int tilex = (ix + x) / TILE_SIZE;
 360                                                 int offsetx = (ix + x) % TILE_SIZE;
 361                                                 if (tilex == tilesx)
 362                                                 {
 363                                                         tilex--;
 364                                                         offsetx = TILE_SIZE;
 365                                                 }
 366                                                 float *vertex = &vertexdata[tilex + tilez * EDGE_TILES][(offsetz * (TILE_SIZE + 1) + offsetx) * 3];
 367                                                 vertex[1] = heightdata[(iz + y) * (sizeX + 1) + (ix + x)];
 368                                                 if ((offsetx == 0) && (tilex > 0))
 369                                                 {
 370                                                         tilex--;
 371                                                         offsetx = TILE_SIZE;
 372                                                         float *vertex = &vertexdata[tilex + tilez * EDGE_TILES][(offsetz * (TILE_SIZE + 1) + offsetx) * 3];
 373                                                         vertex[1] = heightdata[(iz + y) * (sizeX + 1) + (ix + x)];
 374                                                 }
 375                                         }
 376                                 }
 377                         }
 378                         // Compute normals
 379                         for (int iz = 0; iz < height; iz++)
 380                         {
 381                                 for (int ix = 0; ix < width; ix ++)
 382                                 {
 383                                         float h1 = getHeight(x + ix - 1, y + iz);
 384                                         float h2 = getHeight(x + ix + 1, y + iz);
 385                                         float h3 = getHeight(x + ix, y + iz - 1);
 386                                         float h4 = getHeight(x + ix, y + iz + 1);
 387                                         Vec3f v1(2.0f, h2 - h1, 0.0f);
 388                                         Vec3f v2(0.0f, h4 - h3, 2.0f);
 389                                         Vec3f normal = v1.cross(v2);
 390                                 }
 391                         }
 392                         // Refresh vertex buffers
 393                         int size = (TILE_SIZE + 1) * (TILE_SIZE + 1) * 3;
 394                         for (int iz = y / TILE_SIZE; iz <= (y + height) / TILE_SIZE; iz++)
 395                         {
 396                                 for (int ix = x / TILE_SIZE; ix <= (x + width) / TILE_SIZE; ix++)
 397                                 {
 398                                         printf("Updating.\n");
 399                                         Modules::renderer().updateVertices(vertexdata[ix + iz * EDGE_TILES],
 400                                                 0, size * sizeof(float), terrainpatches[ix + iz * EDGE_TILES]);
 401                                 }
 402                         }
 403                 }
 404
 405                 void IslandNode::createExtension()
 406                 {
 407
 408                 }
 409
 410                 float *IslandNode::getHeightData()
 411                 {
 412                         return heightdata;
 413                 }
 414         }
 415 }