src/content_mapblock.cpp

   1 /*
   2 Minetest-c55
   3 Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
   4
   5 This program is free software; you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation; either version 2 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License along
  16 with this program; if not, write to the Free Software Foundation, Inc.,
  17 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "content_mapblock.h"
  21 #include "content_mapnode.h"
  22 #include "main.h" // For g_settings and g_texturesource
  23 #include "mineral.h"
  24
  25 #ifndef SERVER
  26 // Create a cuboid.
  27 //  material  - the material to use (for all 6 faces)
  28 //  collector - the MeshCollector for the resulting polygons
  29 //  pa        - texture atlas pointer for the material
  30 //  c         - vertex colour - used for all
  31 //  pos       - the position of the centre of the cuboid
  32 //  rz,ry,rz  - the radius of the cuboid in each dimension
  33 //  txc       - texture coordinates - this is a list of texture coordinates
  34 //              for the opposite corners of each face - therefore, there
  35 //              should be (2+2)*6=24 values in the list. Alternatively, pass
  36 //              NULL to use the entire texture for each face. The order of
  37 //              the faces in the list is top-backi-right-front-left-bottom
  38 //              If you specified 0,0,1,1 for each face, that would be the
  39 //              same as passing NULL.
  40 void makeCuboid(video::SMaterial &material, MeshCollector *collector,
  41         AtlasPointer* pa, video::SColor &c,
  42         v3f &pos, f32 rx, f32 ry, f32 rz, f32* txc)
  43 {
  44         f32 tu0=pa->x0();
  45         f32 tu1=pa->x1();
  46         f32 tv0=pa->y0();
  47         f32 tv1=pa->y1();
  48         f32 txus=tu1-tu0;
  49         f32 txvs=tv1-tv0;
  50
  51         video::S3DVertex v[4] =
  52         {
  53                 video::S3DVertex(0,0,0, 0,0,0, c, tu0, tv1),
  54                 video::S3DVertex(0,0,0, 0,0,0, c, tu1, tv1),
  55                 video::S3DVertex(0,0,0, 0,0,0, c, tu1, tv0),
  56                 video::S3DVertex(0,0,0, 0,0,0, c, tu0, tv0)
  57         };
  58
  59         for(int i=0;i<6;i++)
  60         {
  61                 switch(i)
  62                 {
  63                         case 0: // top
  64                                 v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
  65                                 v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
  66                                 v[2].Pos.X= rx; v[2].Pos.Y= ry; v[2].Pos.Z= rz;
  67                                 v[3].Pos.X= rx; v[3].Pos.Y= ry, v[3].Pos.Z=-rz;
  68                                 break;
  69                         case 1: // back
  70                                 v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
  71                                 v[1].Pos.X= rx; v[1].Pos.Y= ry; v[1].Pos.Z=-rz;
  72                                 v[2].Pos.X= rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
  73                                 v[3].Pos.X=-rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
  74                                 break;
  75                         case 2: //right
  76                                 v[0].Pos.X= rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
  77                                 v[1].Pos.X= rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
  78                                 v[2].Pos.X= rx; v[2].Pos.Y=-ry; v[2].Pos.Z= rz;
  79                                 v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
  80                                 break;
  81                         case 3: // front
  82                                 v[0].Pos.X= rx; v[0].Pos.Y= ry; v[0].Pos.Z= rz;
  83                                 v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
  84                                 v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z= rz;
  85                                 v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z= rz;
  86                                 break;
  87                         case 4: // left
  88                                 v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z= rz;
  89                                 v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z=-rz;
  90                                 v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
  91                                 v[3].Pos.X=-rx; v[3].Pos.Y=-ry, v[3].Pos.Z= rz;
  92                                 break;
  93                         case 5: // bottom
  94                                 v[0].Pos.X= rx; v[0].Pos.Y=-ry; v[0].Pos.Z= rz;
  95                                 v[1].Pos.X=-rx; v[1].Pos.Y=-ry; v[1].Pos.Z= rz;
  96                                 v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
  97                                 v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
  98                                 break;
  99                 }
 100
 101                 if(txc!=NULL)
 102                 {
 103                         v[0].TCoords.X=tu0+txus*txc[0]; v[0].TCoords.Y=tv0+txvs*txc[3];
 104                         v[1].TCoords.X=tu0+txus*txc[2]; v[1].TCoords.Y=tv0+txvs*txc[3];
 105                         v[2].TCoords.X=tu0+txus*txc[2]; v[2].TCoords.Y=tv0+txvs*txc[1];
 106                         v[3].TCoords.X=tu0+txus*txc[0]; v[3].TCoords.Y=tv0+txvs*txc[1];
 107                         txc+=4;
 108                 }
 109
 110                 for(u16 i=0; i<4; i++)
 111                         v[i].Pos += pos;
 112                 u16 indices[] = {0,1,2,2,3,0};
 113                 collector->append(material, v, 4, indices, 6);
 114
 115         }
 116
 117 }
 118 #endif
 119
 120 #ifndef SERVER
 121 void mapblock_mesh_generate_special(MeshMakeData *data,
 122                 MeshCollector &collector)
 123 {
 124         // 0ms
 125         //TimeTaker timer("mapblock_mesh_generate_special()");
 126
 127         /*
 128                 Some settings
 129         */
 130         bool new_style_water = g_settings.getBool("new_style_water");
 131         bool new_style_leaves = g_settings.getBool("new_style_leaves");
 132         //bool smooth_lighting = g_settings.getBool("smooth_lighting");
 133         bool invisible_stone = g_settings.getBool("invisible_stone");
 134
 135         float node_water_level = 1.0;
 136         if(new_style_water)
 137                 node_water_level = 0.85;
 138
 139         v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;
 140
 141         // Flowing water material
 142         video::SMaterial material_water1;
 143         material_water1.setFlag(video::EMF_LIGHTING, false);
 144         material_water1.setFlag(video::EMF_BACK_FACE_CULLING, false);
 145         material_water1.setFlag(video::EMF_BILINEAR_FILTER, false);
 146         material_water1.setFlag(video::EMF_FOG_ENABLE, true);
 147         material_water1.MaterialType = video::EMT_TRANSPARENT_VERTEX_ALPHA;
 148         AtlasPointer pa_water1 = g_texturesource->getTexture(
 149                         g_texturesource->getTextureId("water.png"));
 150         material_water1.setTexture(0, pa_water1.atlas);
 151
 152         // New-style leaves material
 153         video::SMaterial material_leaves1;
 154         material_leaves1.setFlag(video::EMF_LIGHTING, false);
 155         //material_leaves1.setFlag(video::EMF_BACK_FACE_CULLING, false);
 156         material_leaves1.setFlag(video::EMF_BILINEAR_FILTER, false);
 157         material_leaves1.setFlag(video::EMF_FOG_ENABLE, true);
 158         material_leaves1.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 159         AtlasPointer pa_leaves1 = g_texturesource->getTexture(
 160                         g_texturesource->getTextureId("leaves.png"));
 161         material_leaves1.setTexture(0, pa_leaves1.atlas);
 162
 163         // Glass material
 164         video::SMaterial material_glass;
 165         material_glass.setFlag(video::EMF_LIGHTING, false);
 166         material_glass.setFlag(video::EMF_BILINEAR_FILTER, false);
 167         material_glass.setFlag(video::EMF_FOG_ENABLE, true);
 168         material_glass.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 169         AtlasPointer pa_glass = g_texturesource->getTexture(
 170                         g_texturesource->getTextureId("glass.png"));
 171         material_glass.setTexture(0, pa_glass.atlas);
 172
 173         // Wood material
 174         video::SMaterial material_wood;
 175         material_wood.setFlag(video::EMF_LIGHTING, false);
 176         material_wood.setFlag(video::EMF_BILINEAR_FILTER, false);
 177         material_wood.setFlag(video::EMF_FOG_ENABLE, true);
 178         material_wood.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 179         AtlasPointer pa_wood = g_texturesource->getTexture(
 180                         g_texturesource->getTextureId("wood.png"));
 181         material_wood.setTexture(0, pa_wood.atlas);
 182
 183         // General ground material for special output
 184         // Texture is modified just before usage
 185         video::SMaterial material_general;
 186         material_general.setFlag(video::EMF_LIGHTING, false);
 187         material_general.setFlag(video::EMF_BILINEAR_FILTER, false);
 188         material_general.setFlag(video::EMF_FOG_ENABLE, true);
 189         material_general.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 190
 191
 192         // Papyrus material
 193         video::SMaterial material_papyrus;
 194         material_papyrus.setFlag(video::EMF_LIGHTING, false);
 195         material_papyrus.setFlag(video::EMF_BILINEAR_FILTER, false);
 196         material_papyrus.setFlag(video::EMF_FOG_ENABLE, true);
 197         material_papyrus.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 198         AtlasPointer pa_papyrus = g_texturesource->getTexture(
 199                         g_texturesource->getTextureId("papyrus.png"));
 200         material_papyrus.setTexture(0, pa_papyrus.atlas);
 201
 202         // junglegrass material
 203         video::SMaterial material_junglegrass;
 204         material_junglegrass.setFlag(video::EMF_LIGHTING, false);
 205         material_junglegrass.setFlag(video::EMF_BILINEAR_FILTER, false);
 206         material_junglegrass.setFlag(video::EMF_FOG_ENABLE, true);
 207         material_junglegrass.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 208         AtlasPointer pa_junglegrass = g_texturesource->getTexture(
 209                         g_texturesource->getTextureId("junglegrass.png"));
 210         material_junglegrass.setTexture(0, pa_junglegrass.atlas);
 211
 212         for(s16 z=0; z<MAP_BLOCKSIZE; z++)
 213         for(s16 y=0; y<MAP_BLOCKSIZE; y++)
 214         for(s16 x=0; x<MAP_BLOCKSIZE; x++)
 215         {
 216                 v3s16 p(x,y,z);
 217
 218                 MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes+p);
 219
 220                 /*
 221                         Add torches to mesh
 222                 */
 223                 if(n.d == CONTENT_TORCH)
 224                 {
 225                         video::SColor c(255,255,255,255);
 226
 227                         // Wall at X+ of node
 228                         video::S3DVertex vertices[4] =
 229                         {
 230                                 video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c, 0,1),
 231                                 video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c, 1,1),
 232                                 video::S3DVertex(BS/2,BS/2,0, 0,0,0, c, 1,0),
 233                                 video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c, 0,0),
 234                         };
 235
 236                         v3s16 dir = unpackDir(n.dir);
 237
 238                         for(s32 i=0; i<4; i++)
 239                         {
 240                                 if(dir == v3s16(1,0,0))
 241                                         vertices[i].Pos.rotateXZBy(0);
 242                                 if(dir == v3s16(-1,0,0))
 243                                         vertices[i].Pos.rotateXZBy(180);
 244                                 if(dir == v3s16(0,0,1))
 245                                         vertices[i].Pos.rotateXZBy(90);
 246                                 if(dir == v3s16(0,0,-1))
 247                                         vertices[i].Pos.rotateXZBy(-90);
 248                                 if(dir == v3s16(0,-1,0))
 249                                         vertices[i].Pos.rotateXZBy(45);
 250                                 if(dir == v3s16(0,1,0))
 251                                         vertices[i].Pos.rotateXZBy(-45);
 252
 253                                 vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 254                         }
 255
 256                         // Set material
 257                         video::SMaterial material;
 258                         material.setFlag(video::EMF_LIGHTING, false);
 259                         material.setFlag(video::EMF_BACK_FACE_CULLING, false);
 260                         material.setFlag(video::EMF_BILINEAR_FILTER, false);
 261                         //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 262                         material.MaterialType
 263                                         = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 264
 265                         if(dir == v3s16(0,-1,0))
 266                                 material.setTexture(0,
 267                                                 g_texturesource->getTextureRaw("torch_on_floor.png"));
 268                         else if(dir == v3s16(0,1,0))
 269                                 material.setTexture(0,
 270                                                 g_texturesource->getTextureRaw("torch_on_ceiling.png"));
 271                         // For backwards compatibility
 272                         else if(dir == v3s16(0,0,0))
 273                                 material.setTexture(0,
 274                                                 g_texturesource->getTextureRaw("torch_on_floor.png"));
 275                         else
 276                                 material.setTexture(0,
 277                                                 g_texturesource->getTextureRaw("torch.png"));
 278
 279                         u16 indices[] = {0,1,2,2,3,0};
 280                         // Add to mesh collector
 281                         collector.append(material, vertices, 4, indices, 6);
 282                 }
 283                 /*
 284                         Signs on walls
 285                 */
 286                 else if(n.d == CONTENT_SIGN_WALL)
 287                 {
 288                         u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
 289                         video::SColor c(255,l,l,l);
 290
 291                         float d = (float)BS/16;
 292                         // Wall at X+ of node
 293                         video::S3DVertex vertices[4] =
 294                         {
 295                                 video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c, 0,1),
 296                                 video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c, 1,1),
 297                                 video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c, 1,0),
 298                                 video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c, 0,0),
 299                         };
 300
 301                         v3s16 dir = unpackDir(n.dir);
 302
 303                         for(s32 i=0; i<4; i++)
 304                         {
 305                                 if(dir == v3s16(1,0,0))
 306                                         vertices[i].Pos.rotateXZBy(0);
 307                                 if(dir == v3s16(-1,0,0))
 308                                         vertices[i].Pos.rotateXZBy(180);
 309                                 if(dir == v3s16(0,0,1))
 310                                         vertices[i].Pos.rotateXZBy(90);
 311                                 if(dir == v3s16(0,0,-1))
 312                                         vertices[i].Pos.rotateXZBy(-90);
 313                                 if(dir == v3s16(0,-1,0))
 314                                         vertices[i].Pos.rotateXYBy(-90);
 315                                 if(dir == v3s16(0,1,0))
 316                                         vertices[i].Pos.rotateXYBy(90);
 317
 318                                 vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 319                         }
 320
 321                         // Set material
 322                         video::SMaterial material;
 323                         material.setFlag(video::EMF_LIGHTING, false);
 324                         material.setFlag(video::EMF_BACK_FACE_CULLING, false);
 325                         material.setFlag(video::EMF_BILINEAR_FILTER, false);
 326                         material.setFlag(video::EMF_FOG_ENABLE, true);
 327                         //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
 328                         material.MaterialType
 329                                         = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
 330
 331                         material.setTexture(0,
 332                                         g_texturesource->getTextureRaw("sign_wall.png"));
 333
 334                         u16 indices[] = {0,1,2,2,3,0};
 335                         // Add to mesh collector
 336                         collector.append(material, vertices, 4, indices, 6);
 337                 }
 338                 /*
 339                         Add flowing water to mesh
 340                 */
 341                 else if(n.d == CONTENT_WATER)
 342                 {
 343                         bool top_is_water = false;
 344                         MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
 345                         if(ntop.d == CONTENT_WATER || ntop.d == CONTENT_WATERSOURCE)
 346                                 top_is_water = true;
 347
 348                         u8 l = 0;
 349                         // Use the light of the node on top if possible
 350                         if(content_features(ntop.d).param_type == CPT_LIGHT)
 351                                 l = decode_light(ntop.getLightBlend(data->m_daynight_ratio));
 352                         // Otherwise use the light of this node (the water)
 353                         else
 354                                 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
 355                         video::SColor c(WATER_ALPHA,l,l,l);
 356
 357                         // Neighbor water levels (key = relative position)
 358                         // Includes current node
 359                         core::map<v3s16, f32> neighbor_levels;
 360                         core::map<v3s16, u8> neighbor_contents;
 361                         core::map<v3s16, u8> neighbor_flags;
 362                         const u8 neighborflag_top_is_water = 0x01;
 363                         v3s16 neighbor_dirs[9] = {
 364                                 v3s16(0,0,0),
 365                                 v3s16(0,0,1),
 366                                 v3s16(0,0,-1),
 367                                 v3s16(1,0,0),
 368                                 v3s16(-1,0,0),
 369                                 v3s16(1,0,1),
 370                                 v3s16(-1,0,-1),
 371                                 v3s16(1,0,-1),
 372                                 v3s16(-1,0,1),
 373                         };
 374                         for(u32 i=0; i<9; i++)
 375                         {
 376                                 u8 content = CONTENT_AIR;
 377                                 float level = -0.5 * BS;
 378                                 u8 flags = 0;
 379                                 // Check neighbor
 380                                 v3s16 p2 = p + neighbor_dirs[i];
 381                                 MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
 382                                 if(n2.d != CONTENT_IGNORE)
 383                                 {
 384                                         content = n2.d;
 385
 386                                         if(n2.d == CONTENT_WATERSOURCE)
 387                                                 level = (-0.5+node_water_level) * BS;
 388                                         else if(n2.d == CONTENT_WATER)
 389                                                 level = (-0.5 + ((float)(n2.param2 & LIQUID_LEVEL_MASK) + 0.5) / 8.0
 390                                                                 * node_water_level) * BS;
 391
 392                                         // Check node above neighbor.
 393                                         // NOTE: This doesn't get executed if neighbor
 394                                         //       doesn't exist
 395                                         p2.Y += 1;
 396                                         n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
 397                                         if(n2.d == CONTENT_WATERSOURCE || n2.d == CONTENT_WATER)
 398                                                 flags |= neighborflag_top_is_water;
 399                                 }
 400
 401                                 neighbor_levels.insert(neighbor_dirs[i], level);
 402                                 neighbor_contents.insert(neighbor_dirs[i], content);
 403                                 neighbor_flags.insert(neighbor_dirs[i], flags);
 404                         }
 405
 406                         //float water_level = (-0.5 + ((float)n.param2 + 0.5) / 8.0) * BS;
 407                         //float water_level = neighbor_levels[v3s16(0,0,0)];
 408
 409                         // Corner heights (average between four waters)
 410                         f32 corner_levels[4];
 411
 412                         v3s16 halfdirs[4] = {
 413                                 v3s16(0,0,0),
 414                                 v3s16(1,0,0),
 415                                 v3s16(1,0,1),
 416                                 v3s16(0,0,1),
 417                         };
 418                         for(u32 i=0; i<4; i++)
 419                         {
 420                                 v3s16 cornerdir = halfdirs[i];
 421                                 float cornerlevel = 0;
 422                                 u32 valid_count = 0;
 423                                 for(u32 j=0; j<4; j++)
 424                                 {
 425                                         v3s16 neighbordir = cornerdir - halfdirs[j];
 426                                         u8 content = neighbor_contents[neighbordir];
 427                                         // Special case for source nodes
 428                                         if(content == CONTENT_WATERSOURCE)
 429                                         {
 430                                                 cornerlevel = (-0.5+node_water_level)*BS;
 431                                                 valid_count = 1;
 432                                                 break;
 433                                         }
 434                                         else if(content == CONTENT_WATER)
 435                                         {
 436                                                 cornerlevel += neighbor_levels[neighbordir];
 437                                                 valid_count++;
 438                                         }
 439                                         else if(content == CONTENT_AIR)
 440                                         {
 441                                                 cornerlevel += -0.5*BS;
 442                                                 valid_count++;
 443                                         }
 444                                 }
 445                                 if(valid_count > 0)
 446                                         cornerlevel /= valid_count;
 447                                 corner_levels[i] = cornerlevel;
 448                         }
 449
 450                         /*
 451                                 Generate sides
 452                         */
 453
 454                         v3s16 side_dirs[4] = {
 455                                 v3s16(1,0,0),
 456                                 v3s16(-1,0,0),
 457                                 v3s16(0,0,1),
 458                                 v3s16(0,0,-1),
 459                         };
 460                         s16 side_corners[4][2] = {
 461                                 {1, 2},
 462                                 {3, 0},
 463                                 {2, 3},
 464                                 {0, 1},
 465                         };
 466                         for(u32 i=0; i<4; i++)
 467                         {
 468                                 v3s16 dir = side_dirs[i];
 469
 470                                 /*
 471                                         If our topside is water and neighbor's topside
 472                                         is water, don't draw side face
 473                                 */
 474                                 if(top_is_water &&
 475                                                 neighbor_flags[dir] & neighborflag_top_is_water)
 476                                         continue;
 477
 478                                 u8 neighbor_content = neighbor_contents[dir];
 479
 480                                 // Don't draw face if neighbor is not air or water
 481                                 if(neighbor_content != CONTENT_AIR
 482                                                 && neighbor_content != CONTENT_WATER)
 483                                         continue;
 484
 485                                 bool neighbor_is_water = (neighbor_content == CONTENT_WATER);
 486
 487                                 // Don't draw any faces if neighbor is water and top is water
 488                                 if(neighbor_is_water == true && top_is_water == false)
 489                                         continue;
 490
 491                                 video::S3DVertex vertices[4] =
 492                                 {
 493                                         /*video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,1),
 494                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,1),
 495                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
 496                                         video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
 497                                         video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
 498                                                         pa_water1.x0(), pa_water1.y1()),
 499                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
 500                                                         pa_water1.x1(), pa_water1.y1()),
 501                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
 502                                                         pa_water1.x1(), pa_water1.y0()),
 503                                         video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
 504                                                         pa_water1.x0(), pa_water1.y0()),
 505                                 };
 506
 507                                 /*
 508                                         If our topside is water, set upper border of face
 509                                         at upper border of node
 510                                 */
 511                                 if(top_is_water)
 512                                 {
 513                                         vertices[2].Pos.Y = 0.5*BS;
 514                                         vertices[3].Pos.Y = 0.5*BS;
 515                                 }
 516                                 /*
 517                                         Otherwise upper position of face is corner levels
 518                                 */
 519                                 else
 520                                 {
 521                                         vertices[2].Pos.Y = corner_levels[side_corners[i][0]];
 522                                         vertices[3].Pos.Y = corner_levels[side_corners[i][1]];
 523                                 }
 524
 525                                 /*
 526                                         If neighbor is water, lower border of face is corner
 527                                         water levels
 528                                 */
 529                                 if(neighbor_is_water)
 530                                 {
 531                                         vertices[0].Pos.Y = corner_levels[side_corners[i][1]];
 532                                         vertices[1].Pos.Y = corner_levels[side_corners[i][0]];
 533                                 }
 534                                 /*
 535                                         If neighbor is not water, lower border of face is
 536                                         lower border of node
 537                                 */
 538                                 else
 539                                 {
 540                                         vertices[0].Pos.Y = -0.5*BS;
 541                                         vertices[1].Pos.Y = -0.5*BS;
 542                                 }
 543
 544                                 for(s32 j=0; j<4; j++)
 545                                 {
 546                                         if(dir == v3s16(0,0,1))
 547                                                 vertices[j].Pos.rotateXZBy(0);
 548                                         if(dir == v3s16(0,0,-1))
 549                                                 vertices[j].Pos.rotateXZBy(180);
 550                                         if(dir == v3s16(-1,0,0))
 551                                                 vertices[j].Pos.rotateXZBy(90);
 552                                         if(dir == v3s16(1,0,-0))
 553                                                 vertices[j].Pos.rotateXZBy(-90);
 554
 555                                         vertices[j].Pos += intToFloat(p + blockpos_nodes, BS);
 556                                 }
 557
 558                                 u16 indices[] = {0,1,2,2,3,0};
 559                                 // Add to mesh collector
 560                                 collector.append(material_water1, vertices, 4, indices, 6);
 561                         }
 562
 563                         /*
 564                                 Generate top side, if appropriate
 565                         */
 566
 567                         if(top_is_water == false)
 568                         {
 569                                 video::S3DVertex vertices[4] =
 570                                 {
 571                                         /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
 572                                         video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
 573                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
 574                                         video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
 575                                         video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
 576                                                         pa_water1.x0(), pa_water1.y1()),
 577                                         video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
 578                                                         pa_water1.x1(), pa_water1.y1()),
 579                                         video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
 580                                                         pa_water1.x1(), pa_water1.y0()),
 581                                         video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
 582                                                         pa_water1.x0(), pa_water1.y0()),
 583                                 };
 584
 585                                 // This fixes a strange bug
 586                                 s32 corner_resolve[4] = {3,2,1,0};
 587
 588                                 for(s32 i=0; i<4; i++)
 589                                 {
 590                                         //vertices[i].Pos.Y += water_level;
 591                                         //vertices[i].Pos.Y += neighbor_levels[v3s16(0,0,0)];
 592                                         s32 j = corner_resolve[i];
 593                                         vertices[i].Pos.Y += corner_levels[j];
 594                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 595                                 }
 596
 597                                 u16 indices[] = {0,1,2,2,3,0};
 598                                 // Add to mesh collector
 599                                 collector.append(material_water1, vertices, 4, indices, 6);
 600                         }
 601                 }
 602                 /*
 603                         Add water sources to mesh if using new style
 604                 */
 605                 else if(n.d == CONTENT_WATERSOURCE && new_style_water)
 606                 {
 607                         //bool top_is_water = false;
 608                         bool top_is_air = false;
 609                         MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
 610                         /*if(n.d == CONTENT_WATER || n.d == CONTENT_WATERSOURCE)
 611                                 top_is_water = true;*/
 612                         if(n.d == CONTENT_AIR)
 613                                 top_is_air = true;
 614
 615                         /*if(top_is_water == true)
 616                                 continue;*/
 617                         if(top_is_air == false)
 618                                 continue;
 619
 620                         u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
 621                         video::SColor c(WATER_ALPHA,l,l,l);
 622
 623                         video::S3DVertex vertices[4] =
 624                         {
 625                                 /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
 626                                 video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
 627                                 video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
 628                                 video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
 629                                 video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
 630                                                 pa_water1.x0(), pa_water1.y1()),
 631                                 video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
 632                                                 pa_water1.x1(), pa_water1.y1()),
 633                                 video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
 634                                                 pa_water1.x1(), pa_water1.y0()),
 635                                 video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
 636                                                 pa_water1.x0(), pa_water1.y0()),
 637                         };
 638
 639                         for(s32 i=0; i<4; i++)
 640                         {
 641                                 vertices[i].Pos.Y += (-0.5+node_water_level)*BS;
 642                                 vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 643                         }
 644
 645                         u16 indices[] = {0,1,2,2,3,0};
 646                         // Add to mesh collector
 647                         collector.append(material_water1, vertices, 4, indices, 6);
 648                 }
 649                 /*
 650                         Add leaves if using new style
 651                 */
 652                 else if(n.d == CONTENT_LEAVES && new_style_leaves)
 653                 {
 654                         /*u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));*/
 655                         u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
 656                         video::SColor c(255,l,l,l);
 657
 658                         for(u32 j=0; j<6; j++)
 659                         {
 660                                 video::S3DVertex vertices[4] =
 661                                 {
 662                                         /*video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c, 0,1),
 663                                         video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c, 1,1),
 664                                         video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c, 1,0),
 665                                         video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c, 0,0),*/
 666                                         video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
 667                                                 pa_leaves1.x0(), pa_leaves1.y1()),
 668                                         video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
 669                                                 pa_leaves1.x1(), pa_leaves1.y1()),
 670                                         video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
 671                                                 pa_leaves1.x1(), pa_leaves1.y0()),
 672                                         video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
 673                                                 pa_leaves1.x0(), pa_leaves1.y0()),
 674                                 };
 675
 676                                 if(j == 0)
 677                                 {
 678                                         for(u16 i=0; i<4; i++)
 679                                                 vertices[i].Pos.rotateXZBy(0);
 680                                 }
 681                                 else if(j == 1)
 682                                 {
 683                                         for(u16 i=0; i<4; i++)
 684                                                 vertices[i].Pos.rotateXZBy(180);
 685                                 }
 686                                 else if(j == 2)
 687                                 {
 688                                         for(u16 i=0; i<4; i++)
 689                                                 vertices[i].Pos.rotateXZBy(-90);
 690                                 }
 691                                 else if(j == 3)
 692                                 {
 693                                         for(u16 i=0; i<4; i++)
 694                                                 vertices[i].Pos.rotateXZBy(90);
 695                                 }
 696                                 else if(j == 4)
 697                                 {
 698                                         for(u16 i=0; i<4; i++)
 699                                                 vertices[i].Pos.rotateYZBy(-90);
 700                                 }
 701                                 else if(j == 5)
 702                                 {
 703                                         for(u16 i=0; i<4; i++)
 704                                                 vertices[i].Pos.rotateYZBy(90);
 705                                 }
 706
 707                                 for(u16 i=0; i<4; i++)
 708                                 {
 709                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 710                                 }
 711
 712                                 u16 indices[] = {0,1,2,2,3,0};
 713                                 // Add to mesh collector
 714                                 collector.append(material_leaves1, vertices, 4, indices, 6);
 715                         }
 716                 }
 717                 /*
 718                         Add glass
 719                 */
 720                 else if(n.d == CONTENT_GLASS)
 721                 {
 722                         u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
 723                         video::SColor c(255,l,l,l);
 724
 725                         for(u32 j=0; j<6; j++)
 726                         {
 727                                 video::S3DVertex vertices[4] =
 728                                 {
 729                                         video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
 730                                                 pa_glass.x0(), pa_glass.y1()),
 731                                         video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
 732                                                 pa_glass.x1(), pa_glass.y1()),
 733                                         video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
 734                                                 pa_glass.x1(), pa_glass.y0()),
 735                                         video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
 736                                                 pa_glass.x0(), pa_glass.y0()),
 737                                 };
 738
 739                                 if(j == 0)
 740                                 {
 741                                         for(u16 i=0; i<4; i++)
 742                                                 vertices[i].Pos.rotateXZBy(0);
 743                                 }
 744                                 else if(j == 1)
 745                                 {
 746                                         for(u16 i=0; i<4; i++)
 747                                                 vertices[i].Pos.rotateXZBy(180);
 748                                 }
 749                                 else if(j == 2)
 750                                 {
 751                                         for(u16 i=0; i<4; i++)
 752                                                 vertices[i].Pos.rotateXZBy(-90);
 753                                 }
 754                                 else if(j == 3)
 755                                 {
 756                                         for(u16 i=0; i<4; i++)
 757                                                 vertices[i].Pos.rotateXZBy(90);
 758                                 }
 759                                 else if(j == 4)
 760                                 {
 761                                         for(u16 i=0; i<4; i++)
 762                                                 vertices[i].Pos.rotateYZBy(-90);
 763                                 }
 764                                 else if(j == 5)
 765                                 {
 766                                         for(u16 i=0; i<4; i++)
 767                                                 vertices[i].Pos.rotateYZBy(90);
 768                                 }
 769
 770                                 for(u16 i=0; i<4; i++)
 771                                 {
 772                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 773                                 }
 774
 775                                 u16 indices[] = {0,1,2,2,3,0};
 776                                 // Add to mesh collector
 777                                 collector.append(material_glass, vertices, 4, indices, 6);
 778                         }
 779                 }
 780                 /*
 781                         Add fence
 782                 */
 783                 else if(n.d == CONTENT_FENCE)
 784                 {
 785                         u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
 786                         video::SColor c(255,l,l,l);
 787
 788                         const f32 post_rad=(f32)BS/10;
 789                         const f32 bar_rad=(f32)BS/20;
 790                         const f32 bar_len=(f32)(BS/2)-post_rad;
 791
 792                         // The post - always present
 793                         v3f pos = intToFloat(p+blockpos_nodes, BS);
 794                         f32 postuv[24]={
 795                                         0.4,0.4,0.6,0.6,
 796                                         0.35,0,0.65,1,
 797                                         0.35,0,0.65,1,
 798                                         0.35,0,0.65,1,
 799                                         0.35,0,0.65,1,
 800                                         0.4,0.4,0.6,0.6};
 801                         makeCuboid(material_wood, &collector,
 802                                 &pa_wood, c, pos,
 803                                 post_rad,BS/2,post_rad, postuv);
 804
 805                         // Now a section of fence, +X, if there's a post there
 806                         v3s16 p2 = p;
 807                         p2.X++;
 808                         MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
 809                         if(n2.d == CONTENT_FENCE)
 810                         {
 811                                 pos = intToFloat(p+blockpos_nodes, BS);
 812                                 pos.X += BS/2;
 813                                 pos.Y += BS/4;
 814                                 f32 xrailuv[24]={
 815                                         0,0.4,1,0.6,
 816                                         0,0.4,1,0.6,
 817                                         0,0.4,1,0.6,
 818                                         0,0.4,1,0.6,
 819                                         0,0.4,1,0.6,
 820                                         0,0.4,1,0.6};
 821                                 makeCuboid(material_wood, &collector,
 822                                         &pa_wood, c, pos,
 823                                         bar_len,bar_rad,bar_rad, xrailuv);
 824
 825                                 pos.Y -= BS/2;
 826                                 makeCuboid(material_wood, &collector,
 827                                         &pa_wood, c, pos,
 828                                         bar_len,bar_rad,bar_rad, xrailuv);
 829                         }
 830
 831                         // Now a section of fence, +Z, if there's a post there
 832                         p2 = p;
 833                         p2.Z++;
 834                         n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p2);
 835                         if(n2.d == CONTENT_FENCE)
 836                         {
 837                                 pos = intToFloat(p+blockpos_nodes, BS);
 838                                 pos.Z += BS/2;
 839                                 pos.Y += BS/4;
 840                                 f32 zrailuv[24]={
 841                                         0,0.4,1,0.6,
 842                                         0,0.4,1,0.6,
 843                                         0,0.4,1,0.6,
 844                                         0,0.4,1,0.6,
 845                                         0,0.4,1,0.6,
 846                                         0,0.4,1,0.6};
 847                                 makeCuboid(material_wood, &collector,
 848                                         &pa_wood, c, pos,
 849                                         bar_rad,bar_rad,bar_len, zrailuv);
 850                                 pos.Y -= BS/2;
 851                                 makeCuboid(material_wood, &collector,
 852                                         &pa_wood, c, pos,
 853                                         bar_rad,bar_rad,bar_len, zrailuv);
 854
 855                         }
 856
 857                 }
 858 #if 1
 859                 /*
 860                         Add stones with minerals if stone is invisible
 861                 */
 862                 else if(n.d == CONTENT_STONE && invisible_stone && n.getMineral() != MINERAL_NONE)
 863                 {
 864                         for(u32 j=0; j<6; j++)
 865                         {
 866                                 // NOTE: Hopefully g_6dirs[j] is the right direction...
 867                                 v3s16 dir = g_6dirs[j];
 868                                 /*u8 l = 0;
 869                                 MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + dir);
 870                                 if(content_features(n2.d).param_type == CPT_LIGHT)
 871                                         l = decode_light(n2.getLightBlend(data->m_daynight_ratio));
 872                                 else
 873                                         l = 255;*/
 874                                 u8 l = 255;
 875                                 video::SColor c(255,l,l,l);
 876
 877                                 // Get the right texture
 878                                 TileSpec ts = n.getTile(dir);
 879                                 AtlasPointer ap = ts.texture;
 880                                 material_general.setTexture(0, ap.atlas);
 881                                 video::S3DVertex vertices[4] =
 882                                 {
 883                                         /*video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c, 0,1),
 884                                         video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c, 1,1),
 885                                         video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c, 1,0),
 886                                         video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c, 0,0),*/
 887                                         video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
 888                                                 ap.x0(), ap.y1()),
 889                                         video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
 890                                                 ap.x1(), ap.y1()),
 891                                         video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
 892                                                 ap.x1(), ap.y0()),
 893                                         video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
 894                                                 ap.x0(), ap.y0()),
 895                                 };
 896
 897                                 if(j == 0)
 898                                 {
 899                                         for(u16 i=0; i<4; i++)
 900                                                 vertices[i].Pos.rotateXZBy(0);
 901                                 }
 902                                 else if(j == 1)
 903                                 {
 904                                         for(u16 i=0; i<4; i++)
 905                                                 vertices[i].Pos.rotateXZBy(180);
 906                                 }
 907                                 else if(j == 2)
 908                                 {
 909                                         for(u16 i=0; i<4; i++)
 910                                                 vertices[i].Pos.rotateXZBy(-90);
 911                                 }
 912                                 else if(j == 3)
 913                                 {
 914                                         for(u16 i=0; i<4; i++)
 915                                                 vertices[i].Pos.rotateXZBy(90);
 916                                 }
 917                                 else if(j == 4)
 918
 919                                 for(u16 i=0; i<4; i++)
 920                                 {
 921                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 922                                 }
 923
 924                                 u16 indices[] = {0,1,2,2,3,0};
 925                                 // Add to mesh collector
 926                                 collector.append(material_general, vertices, 4, indices, 6);
 927                         }
 928                 }
 929 #endif
 930                 else if(n.d == CONTENT_PAPYRUS)
 931                 {
 932                         u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
 933                         video::SColor c(255,l,l,l);
 934
 935                         for(u32 j=0; j<4; j++)
 936                         {
 937                                 video::S3DVertex vertices[4] =
 938                                 {
 939                                         video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c,
 940                                                 pa_papyrus.x0(), pa_papyrus.y1()),
 941                                         video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c,
 942                                                 pa_papyrus.x1(), pa_papyrus.y1()),
 943                                         video::S3DVertex(BS/2,BS/2,0, 0,0,0, c,
 944                                                 pa_papyrus.x1(), pa_papyrus.y0()),
 945                                         video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c,
 946                                                 pa_papyrus.x0(), pa_papyrus.y0()),
 947                                 };
 948
 949                                 if(j == 0)
 950                                 {
 951                                         for(u16 i=0; i<4; i++)
 952                                                 vertices[i].Pos.rotateXZBy(45);
 953                                 }
 954                                 else if(j == 1)
 955                                 {
 956                                         for(u16 i=0; i<4; i++)
 957                                                 vertices[i].Pos.rotateXZBy(-45);
 958                                 }
 959                                 else if(j == 2)
 960                                 {
 961                                         for(u16 i=0; i<4; i++)
 962                                                 vertices[i].Pos.rotateXZBy(135);
 963                                 }
 964                                 else if(j == 3)
 965                                 {
 966                                         for(u16 i=0; i<4; i++)
 967                                                 vertices[i].Pos.rotateXZBy(-135);
 968                                 }
 969
 970                                 for(u16 i=0; i<4; i++)
 971                                 {
 972                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
 973                                 }
 974
 975                                 u16 indices[] = {0,1,2,2,3,0};
 976                                 // Add to mesh collector
 977                                 collector.append(material_papyrus, vertices, 4, indices, 6);
 978                         }
 979                 }
 980                 else if(n.d == CONTENT_JUNGLEGRASS)
 981                 {
 982                         u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
 983                         video::SColor c(255,l,l,l);
 984
 985                         for(u32 j=0; j<4; j++)
 986                         {
 987                                 video::S3DVertex vertices[4] =
 988                                 {
 989                                         video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c,
 990                                                 pa_papyrus.x0(), pa_papyrus.y1()),
 991                                         video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c,
 992                                                 pa_papyrus.x1(), pa_papyrus.y1()),
 993                                         video::S3DVertex(BS/2,BS/1,0, 0,0,0, c,
 994                                                 pa_papyrus.x1(), pa_papyrus.y0()),
 995                                         video::S3DVertex(-BS/2,BS/1,0, 0,0,0, c,
 996                                                 pa_papyrus.x0(), pa_papyrus.y0()),
 997                                 };
 998
 999                                 if(j == 0)
1000                                 {
1001                                         for(u16 i=0; i<4; i++)
1002                                                 vertices[i].Pos.rotateXZBy(45);
1003                                 }
1004                                 else if(j == 1)
1005                                 {
1006                                         for(u16 i=0; i<4; i++)
1007                                                 vertices[i].Pos.rotateXZBy(-45);
1008                                 }
1009                                 else if(j == 2)
1010                                 {
1011                                         for(u16 i=0; i<4; i++)
1012                                                 vertices[i].Pos.rotateXZBy(135);
1013                                 }
1014                                 else if(j == 3)
1015                                 {
1016                                         for(u16 i=0; i<4; i++)
1017                                                 vertices[i].Pos.rotateXZBy(-135);
1018                                 }
1019
1020                                 for(u16 i=0; i<4; i++)
1021                                 {
1022                                         vertices[i].Pos *= 1.3;
1023                                         vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
1024                                 }
1025
1026                                 u16 indices[] = {0,1,2,2,3,0};
1027                                 // Add to mesh collector
1028                                 collector.append(material_junglegrass, vertices, 4, indices, 6);
1029                         }
1030                 }
1031                 else if(n.d == CONTENT_RAIL)
1032                 {
1033                         u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
1034                         video::SColor c(255,l,l,l);
1035
1036                         bool is_rail_x [] = { false, false };  /* x-1, x+1 */
1037                         bool is_rail_z [] = { false, false };  /* z-1, z+1 */
1038
1039                         MapNode n_minus_x = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x-1,y,z));
1040                         MapNode n_plus_x = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x+1,y,z));
1041                         MapNode n_minus_z = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y,z-1));
1042                         MapNode n_plus_z = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y,z+1));
1043
1044                         if(n_minus_x.d == CONTENT_RAIL)
1045                                 is_rail_x[0] = true;
1046                         if(n_plus_x.d == CONTENT_RAIL)
1047                                 is_rail_x[1] = true;
1048                         if(n_minus_z.d == CONTENT_RAIL)
1049                                 is_rail_z[0] = true;
1050                         if(n_plus_z.d == CONTENT_RAIL)
1051                                 is_rail_z[1] = true;
1052
1053                         float d = (float)BS/16;
1054                         video::S3DVertex vertices[4] =
1055                         {
1056                                 video::S3DVertex(-BS/2,-BS/2+d,-BS/2, 0,0,0, c,
1057                                         0, 1),
1058                                 video::S3DVertex(BS/2,-BS/2+d,-BS/2, 0,0,0, c,
1059                                         1, 1),
1060                                 video::S3DVertex(BS/2,-BS/2+d,BS/2, 0,0,0, c,
1061                                         1, 0),
1062                                 video::S3DVertex(-BS/2,-BS/2+d,BS/2, 0,0,0, c,
1063                                         0, 0),
1064                         };
1065
1066                         video::SMaterial material_rail;
1067                         material_rail.setFlag(video::EMF_LIGHTING, false);
1068                         material_rail.setFlag(video::EMF_BACK_FACE_CULLING, false);
1069                         material_rail.setFlag(video::EMF_BILINEAR_FILTER, false);
1070                         material_rail.setFlag(video::EMF_FOG_ENABLE, true);
1071                         material_rail.MaterialType
1072                                         = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
1073
1074                         int adjacencies = is_rail_x[0] + is_rail_x[1] + is_rail_z[0] + is_rail_z[1];
1075
1076                         // Assign textures
1077                         if(adjacencies < 2)
1078                                 material_rail.setTexture(0, g_texturesource->getTextureRaw("rail.png"));
1079                         else if(adjacencies == 2)
1080                         {
1081                                 if((is_rail_x[0] && is_rail_x[1]) || (is_rail_z[0] && is_rail_z[1]))
1082                                         material_rail.setTexture(0, g_texturesource->getTextureRaw("rail.png"));
1083                                 else
1084                                         material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_curved.png"));
1085                         }
1086                         else if(adjacencies == 3)
1087                                 material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_t_junction.png"));
1088                         else if(adjacencies == 4)
1089                                 material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_crossing.png"));
1090
1091                         // Rotate textures
1092                         int angle = 0;
1093
1094                         if(adjacencies == 1)
1095                         {
1096                                 if(is_rail_x[0] || is_rail_x[1])
1097                                         angle = 90;
1098                         }
1099                         else if(adjacencies == 2)
1100                         {
1101                                 if(is_rail_x[0] && is_rail_x[1])
1102                                         angle = 90;
1103                                 else if(is_rail_x[0] && is_rail_z[0])
1104                                         angle = 270;
1105                                 else if(is_rail_x[0] && is_rail_z[1])
1106                                         angle = 180;
1107                                 else if(is_rail_x[1] && is_rail_z[1])
1108                                         angle = 90;
1109                         }
1110                         else if(adjacencies == 3)
1111                         {
1112                                 if(!is_rail_x[0])
1113                                         angle=0;
1114                                 if(!is_rail_x[1])
1115                                         angle=180;
1116                                 if(!is_rail_z[0])
1117                                         angle=90;
1118                                 if(!is_rail_z[1])
1119                                         angle=270;
1120                         }
1121
1122                         if(angle != 0) {
1123                                 for(u16 i=0; i<4; i++)
1124                                         vertices[i].Pos.rotateXZBy(angle);
1125                         }
1126
1127                         for(s32 i=0; i<4; i++)
1128                         {
1129                                 vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
1130                         }
1131
1132                         u16 indices[] = {0,1,2,2,3,0};
1133                         collector.append(material_rail, vertices, 4, indices, 6);
1134                 }
1135         }
1136 }
1137 #endif
1138