*/
#include "content_mapblock.h"
-
+#include "util/numeric.h"
+#include "util/directiontables.h"
#include "main.h" // For g_settings
#include "mapblock_mesh.h" // For MapBlock_LightColor() and MeshCollector
#include "settings.h"
#include "nodedef.h"
-#include "tile.h"
+#include "client/tile.h"
+#include "mesh.h"
+#include <IMeshManipulator.h>
#include "gamedef.h"
-#include "util/numeric.h"
-#include "util/directiontables.h"
+#include "log.h"
+
// Create a cuboid.
// collector - the MeshCollector for the resulting polygons
// (compatible with ContentFeatures). If you specified 0,0,1,1
// for each face, that would be the same as passing NULL.
void makeCuboid(MeshCollector *collector, const aabb3f &box,
- TileSpec *tiles, int tilecount,
- video::SColor &c, const f32* txc)
+ TileSpec *tiles, int tilecount, video::SColor &c, const f32* txc)
{
- assert(tilecount >= 1 && tilecount <= 6);
+ assert(tilecount >= 1 && tilecount <= 6); // pre-condition
v3f min = box.MinEdge;
v3f max = box.MaxEdge;
- if(txc == NULL)
- {
+ if(txc == NULL) {
static const f32 txc_default[24] = {
0,0,1,1,
0,0,1,1,
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- for(s32 j=0; j<24; j+=4)
- {
- int tileindex = MYMIN(j/4, tilecount-1);
- collector->append(tiles[tileindex],
- vertices+j, 4, indices, 6);
+ for (s32 j = 0; j < 24; j += 4) {
+ int tileindex = MYMIN(j / 4, tilecount - 1);
+ collector->append(tiles[tileindex], vertices + j, 4, indices, 6);
}
}
+/*
+ TODO: Fix alpha blending for special nodes
+ Currently only the last element rendered is blended correct
+*/
void mapblock_mesh_generate_special(MeshMakeData *data,
MeshCollector &collector)
{
INodeDefManager *nodedef = data->m_gamedef->ndef();
ITextureSource *tsrc = data->m_gamedef->tsrc();
+ scene::ISceneManager* smgr = data->m_gamedef->getSceneManager();
+ scene::IMeshManipulator* meshmanip = smgr->getMeshManipulator();
// 0ms
//TimeTaker timer("mapblock_mesh_generate_special()");
/*
Some settings
*/
+ bool enable_mesh_cache = g_settings->getBool("enable_mesh_cache");
bool new_style_water = g_settings->getBool("new_style_water");
float node_liquid_level = 1.0;
v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;
- // Create selection mesh
- v3s16 p = data->m_highlighted_pos_relative;
- if (data->m_show_hud &
- (p.X >= 0) & (p.X < MAP_BLOCKSIZE) &
- (p.Y >= 0) & (p.Y < MAP_BLOCKSIZE) &
- (p.Z >= 0) & (p.Z < MAP_BLOCKSIZE)) {
-
- MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + p);
- if(n.getContent() != CONTENT_AIR) {
- // Get selection mesh light level
- static const v3s16 dirs[7] = {
- v3s16( 0, 0, 0),
- v3s16( 0, 1, 0),
- v3s16( 0,-1, 0),
- v3s16( 1, 0, 0),
- v3s16(-1, 0, 0),
- v3s16( 0, 0, 1),
- v3s16( 0, 0,-1)
- };
-
- u16 l = 0;
- u16 l1 = 0;
- for (u8 i = 0; i < 7; i++) {
- MapNode n1 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dirs[i]);
- l1 = getInteriorLight(n1, -4, nodedef);
- if (l1 > l)
- l = l1;
- }
- video::SColor c = MapBlock_LightColor(255, l, 0);
- data->m_highlight_mesh_color = c;
- std::vector<aabb3f> boxes = n.getSelectionBoxes(nodedef);
- TileSpec h_tile;
- h_tile.material_flags |= MATERIAL_FLAG_HIGHLIGHTED;
- h_tile.texture = tsrc->getTexture("halo.png",&h_tile.texture_id);
- v3f pos = intToFloat(p, BS);
- f32 d = 0.05 * BS;
- for(std::vector<aabb3f>::iterator
- i = boxes.begin();
- i != boxes.end(); i++)
- {
- aabb3f box = *i;
- box.MinEdge += v3f(-d, -d, -d) + pos;
- box.MaxEdge += v3f(d, d, d) + pos;
- makeCuboid(&collector, box, &h_tile, 1, c, NULL);
- }
- }
- }
-
for(s16 z = 0; z < MAP_BLOCKSIZE; z++)
for(s16 y = 0; y < MAP_BLOCKSIZE; y++)
for(s16 x = 0; x < MAP_BLOCKSIZE; x++)
switch(f.drawtype){
default:
- infostream<<"Got "<<f.drawtype<<std::endl;
- assert(0);
+ infostream << "Got " << f.drawtype << std::endl;
+ FATAL_ERROR("Unknown drawtype");
break;
case NDT_AIRLIKE:
break;
for(u32 j=0; j<6; j++)
{
// Check this neighbor
- v3s16 n2p = blockpos_nodes + p + g_6dirs[j];
+ v3s16 dir = g_6dirs[j];
+ v3s16 n2p = blockpos_nodes + p + dir;
MapNode n2 = data->m_vmanip.getNodeNoEx(n2p);
// Don't make face if neighbor is of same type
if(n2.getContent() == n.getContent())
// The face at Z+
video::S3DVertex vertices[4] = {
- video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c, 0,0),
- video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c, 1,0),
+ video::S3DVertex(-BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 1,1),
+ video::S3DVertex(BS/2,-BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 0,1),
+ video::S3DVertex(BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 0,0),
+ video::S3DVertex(-BS/2,BS/2,BS/2, dir.X,dir.Y,dir.Z, c, 1,0),
};
// Rotations in the g_6dirs format
collector.append(tile, vertices, 4, indices, 6);
}
break;}
+ case NDT_GLASSLIKE_FRAMED_OPTIONAL:
+ // This is always pre-converted to something else
+ FATAL_ERROR("NDT_GLASSLIKE_FRAMED_OPTIONAL not pre-converted as expected");
+ break;
case NDT_GLASSLIKE_FRAMED:
{
static const v3s16 dirs[6] = {
break;}
case NDT_ALLFACES_OPTIONAL:
// This is always pre-converted to something else
- assert(0);
+ FATAL_ERROR("NDT_ALLFACES_OPTIONAL not pre-converted");
break;
case NDT_TORCHLIKE:
{
{
TileSpec tile = getNodeTileN(n, p, 0, data);
tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+
+ u16 l = getInteriorLight(n, 1, nodedef);
+ video::SColor c = MapBlock_LightColor(255, l, f.light_source);
+ float s = BS / 2 * f.visual_scale;
+
+ for (int j = 0; j < 2; j++)
+ {
+ video::S3DVertex vertices[4] =
+ {
+ video::S3DVertex(-s,-BS/2, 0, 0,0,0, c, 0,1),
+ video::S3DVertex( s,-BS/2, 0, 0,0,0, c, 1,1),
+ video::S3DVertex( s,-BS/2 + s*2,0, 0,0,0, c, 1,0),
+ video::S3DVertex(-s,-BS/2 + s*2,0, 0,0,0, c, 0,0),
+ };
+
+ if(j == 0)
+ {
+ for(u16 i = 0; i < 4; i++)
+ vertices[i].Pos.rotateXZBy(46 + n.param2 * 2);
+ }
+ else if(j == 1)
+ {
+ for(u16 i = 0; i < 4; i++)
+ vertices[i].Pos.rotateXZBy(-44 + n.param2 * 2);
+ }
+
+ for (int i = 0; i < 4; i++)
+ {
+ vertices[i].Pos *= f.visual_scale;
+ vertices[i].Pos.Y += BS/2 * (f.visual_scale - 1);
+ vertices[i].Pos += intToFloat(p, BS);
+ }
+
+ u16 indices[] = {0, 1, 2, 2, 3, 0};
+ // Add to mesh collector
+ collector.append(tile, vertices, 4, indices, 6);
+ }
+ break;}
+ case NDT_FIRELIKE:
+ {
+ TileSpec tile = getNodeTileN(n, p, 0, data);
+ tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+
u16 l = getInteriorLight(n, 1, nodedef);
video::SColor c = MapBlock_LightColor(255, l, f.light_source);
float s = BS/2*f.visual_scale;
- for(u32 j=0; j<2; j++)
+ content_t current = n.getContent();
+ content_t n2c;
+ MapNode n2;
+ v3s16 n2p;
+
+ static const v3s16 dirs[6] = {
+ v3s16( 0, 1, 0),
+ v3s16( 0,-1, 0),
+ v3s16( 1, 0, 0),
+ v3s16(-1, 0, 0),
+ v3s16( 0, 0, 1),
+ v3s16( 0, 0,-1)
+ };
+
+ int doDraw[6] = {0,0,0,0,0,0};
+
+ bool drawAllFaces = true;
+
+ bool drawBottomFacesOnly = false; // Currently unused
+
+ // Check for adjacent nodes
+ for(int i = 0; i < 6; i++)
{
+ n2p = blockpos_nodes + p + dirs[i];
+ n2 = data->m_vmanip.getNodeNoEx(n2p);
+ n2c = n2.getContent();
+ if (n2c != CONTENT_IGNORE && n2c != CONTENT_AIR && n2c != current) {
+ doDraw[i] = 1;
+ if(drawAllFaces)
+ drawAllFaces = false;
+
+ }
+ }
+
+ for(int j = 0; j < 6; j++)
+ {
+ int vOffset = 0; // Vertical offset of faces after rotation
+ int hOffset = 4; // Horizontal offset of faces to reach the edge
+
video::S3DVertex vertices[4] =
{
video::S3DVertex(-s,-BS/2, 0, 0,0,0, c, 0,1),
video::S3DVertex(-s,-BS/2 + s*2,0, 0,0,0, c, 0,0),
};
- if(j == 0)
+ // Calculate which faces should be drawn, (top or sides)
+ if(j == 0 && (drawAllFaces || (doDraw[3] == 1 || doDraw[1] == 1)))
{
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(46 + n.param2 * 2);
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateXZBy(90 + n.param2 * 2);
+ vertices[i].Pos.rotateXYBy(-10);
+ vertices[i].Pos.Y -= vOffset;
+ vertices[i].Pos.X -= hOffset;
+ }
}
- else if(j == 1)
+ else if(j == 1 && (drawAllFaces || (doDraw[5] == 1 || doDraw[1] == 1)))
{
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(-44 + n.param2 * 2);
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateXZBy(180 + n.param2 * 2);
+ vertices[i].Pos.rotateYZBy(10);
+ vertices[i].Pos.Y -= vOffset;
+ vertices[i].Pos.Z -= hOffset;
+ }
+ }
+ else if(j == 2 && (drawAllFaces || (doDraw[2] == 1 || doDraw[1] == 1)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateXZBy(270 + n.param2 * 2);
+ vertices[i].Pos.rotateXYBy(10);
+ vertices[i].Pos.Y -= vOffset;
+ vertices[i].Pos.X += hOffset;
+ }
+ }
+ else if(j == 3 && (drawAllFaces || (doDraw[4] == 1 || doDraw[1] == 1)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateYZBy(-10);
+ vertices[i].Pos.Y -= vOffset;
+ vertices[i].Pos.Z += hOffset;
+ }
}
- for(u16 i=0; i<4; i++)
+ // Center cross-flames
+ else if(j == 4 && (drawAllFaces || doDraw[1] == 1))
+ {
+ for(int i=0; i<4; i++) {
+ vertices[i].Pos.rotateXZBy(45 + n.param2 * 2);
+ vertices[i].Pos.Y -= vOffset;
+ }
+ }
+ else if(j == 5 && (drawAllFaces || doDraw[1] == 1))
+ {
+ for(int i=0; i<4; i++) {
+ vertices[i].Pos.rotateXZBy(-45 + n.param2 * 2);
+ vertices[i].Pos.Y -= vOffset;
+ }
+ }
+
+ // Render flames on bottom
+ else if(j == 0 && (drawBottomFacesOnly || (doDraw[0] == 1 && doDraw[1] == 0)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateYZBy(70);
+ vertices[i].Pos.rotateXZBy(90 + n.param2 * 2);
+ vertices[i].Pos.Y += 4.84;
+ vertices[i].Pos.X -= hOffset+0.7;
+ }
+ }
+ else if(j == 1 && (drawBottomFacesOnly || (doDraw[0] == 1 && doDraw[1] == 0)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateYZBy(70);
+ vertices[i].Pos.rotateXZBy(180 + n.param2 * 2);
+ vertices[i].Pos.Y += 4.84;
+ vertices[i].Pos.Z -= hOffset+0.7;
+ }
+ }
+ else if(j == 2 && (drawBottomFacesOnly || (doDraw[0] == 1 && doDraw[1] == 0)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateYZBy(70);
+ vertices[i].Pos.rotateXZBy(270 + n.param2 * 2);
+ vertices[i].Pos.Y += 4.84;
+ vertices[i].Pos.X += hOffset+0.7;
+ }
+ }
+ else if(j == 3 && (drawBottomFacesOnly || (doDraw[0] == 1 && doDraw[1] == 0)))
+ {
+ for(int i = 0; i < 4; i++) {
+ vertices[i].Pos.rotateYZBy(70);
+ vertices[i].Pos.Y += 4.84;
+ vertices[i].Pos.Z += hOffset+0.7;
+ }
+ }
+ else {
+ // Skip faces that aren't adjacent to a node
+ continue;
+ }
+
+ for(int i=0; i<4; i++)
{
vertices[i].Pos *= f.visual_scale;
vertices[i].Pos += intToFloat(p, BS);
break;}
case NDT_RAILLIKE:
{
- bool is_rail_x [] = { false, false }; /* x-1, x+1 */
- bool is_rail_z [] = { false, false }; /* z-1, z+1 */
-
- bool is_rail_z_minus_y [] = { false, false }; /* z-1, z+1; y-1 */
- bool is_rail_x_minus_y [] = { false, false }; /* x-1, z+1; y-1 */
- bool is_rail_z_plus_y [] = { false, false }; /* z-1, z+1; y+1 */
- bool is_rail_x_plus_y [] = { false, false }; /* x-1, x+1; y+1 */
-
- MapNode n_minus_x = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x-1,y,z));
- MapNode n_plus_x = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x+1,y,z));
- MapNode n_minus_z = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y,z-1));
- MapNode n_plus_z = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y,z+1));
- MapNode n_plus_x_plus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x+1, y+1, z));
- MapNode n_plus_x_minus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x+1, y-1, z));
- MapNode n_minus_x_plus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x-1, y+1, z));
- MapNode n_minus_x_minus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x-1, y-1, z));
- MapNode n_plus_z_plus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y+1, z+1));
- MapNode n_minus_z_plus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y+1, z-1));
- MapNode n_plus_z_minus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y-1, z+1));
- MapNode n_minus_z_minus_y = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y-1, z-1));
+ bool is_rail_x[6]; /* (-1,-1,0) X (1,-1,0) (-1,0,0) X (1,0,0) (-1,1,0) X (1,1,0) */
+ bool is_rail_z[6];
content_t thiscontent = n.getContent();
std::string groupname = "connect_to_raillike"; // name of the group that enables connecting to raillike nodes of different kind
- bool self_connect_to_raillike = ((ItemGroupList) nodedef->get(n).groups)[groupname] != 0;
-
- if ((nodedef->get(n_minus_x).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_x).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_x.getContent() == thiscontent)
- is_rail_x[0] = true;
-
- if ((nodedef->get(n_minus_x_minus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_x_minus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_x_minus_y.getContent() == thiscontent)
- is_rail_x_minus_y[0] = true;
-
- if ((nodedef->get(n_minus_x_plus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_x_plus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_x_plus_y.getContent() == thiscontent)
- is_rail_x_plus_y[0] = true;
-
- if ((nodedef->get(n_plus_x).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_x).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_x.getContent() == thiscontent)
- is_rail_x[1] = true;
-
- if ((nodedef->get(n_plus_x_minus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_x_minus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_x_minus_y.getContent() == thiscontent)
- is_rail_x_minus_y[1] = true;
-
- if ((nodedef->get(n_plus_x_plus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_x_plus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_x_plus_y.getContent() == thiscontent)
- is_rail_x_plus_y[1] = true;
-
- if ((nodedef->get(n_minus_z).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_z).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_z.getContent() == thiscontent)
- is_rail_z[0] = true;
-
- if ((nodedef->get(n_minus_z_minus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_z_minus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_z_minus_y.getContent() == thiscontent)
- is_rail_z_minus_y[0] = true;
-
- if ((nodedef->get(n_minus_z_plus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_minus_z_plus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_minus_z_plus_y.getContent() == thiscontent)
- is_rail_z_plus_y[0] = true;
-
- if ((nodedef->get(n_plus_z).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_z).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_z.getContent() == thiscontent)
- is_rail_z[1] = true;
-
- if ((nodedef->get(n_plus_z_minus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_z_minus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_z_minus_y.getContent() == thiscontent)
- is_rail_z_minus_y[1] = true;
-
- if ((nodedef->get(n_plus_z_plus_y).drawtype == NDT_RAILLIKE
- && ((ItemGroupList) nodedef->get(n_plus_z_plus_y).groups)[groupname] != 0
- && self_connect_to_raillike)
- || n_plus_z_plus_y.getContent() == thiscontent)
- is_rail_z_plus_y[1] = true;
-
- bool is_rail_x_all[] = {false, false};
- bool is_rail_z_all[] = {false, false};
- is_rail_x_all[0]=is_rail_x[0] || is_rail_x_minus_y[0] || is_rail_x_plus_y[0];
- is_rail_x_all[1]=is_rail_x[1] || is_rail_x_minus_y[1] || is_rail_x_plus_y[1];
- is_rail_z_all[0]=is_rail_z[0] || is_rail_z_minus_y[0] || is_rail_z_plus_y[0];
- is_rail_z_all[1]=is_rail_z[1] || is_rail_z_minus_y[1] || is_rail_z_plus_y[1];
+ int self_group = ((ItemGroupList) nodedef->get(n).groups)[groupname];
+
+ u8 index = 0;
+ for (s8 y0 = -1; y0 <= 1; y0++) {
+ // Prevent from indexing never used coordinates
+ for (s8 xz = -1; xz <= 1; xz++) {
+ if (xz == 0)
+ continue;
+ MapNode n_xy = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x + xz, y + y0, z));
+ MapNode n_zy = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x, y + y0, z + xz));
+ ContentFeatures def_xy = nodedef->get(n_xy);
+ ContentFeatures def_zy = nodedef->get(n_zy);
+
+ // Check if current node would connect with the rail
+ is_rail_x[index] = ((def_xy.drawtype == NDT_RAILLIKE
+ && ((ItemGroupList) def_xy.groups)[groupname] == self_group)
+ || n_xy.getContent() == thiscontent);
+
+ is_rail_z[index] = ((def_zy.drawtype == NDT_RAILLIKE
+ && ((ItemGroupList) def_zy.groups)[groupname] == self_group)
+ || n_zy.getContent() == thiscontent);
+ index++;
+ }
+ }
+
+ bool is_rail_x_all[2]; // [0] = negative x, [1] = positive x coordinate from the current node position
+ bool is_rail_z_all[2];
+ is_rail_x_all[0] = is_rail_x[0] || is_rail_x[2] || is_rail_x[4];
+ is_rail_x_all[1] = is_rail_x[1] || is_rail_x[3] || is_rail_x[5];
+ is_rail_z_all[0] = is_rail_z[0] || is_rail_z[2] || is_rail_z[4];
+ is_rail_z_all[1] = is_rail_z[1] || is_rail_z[3] || is_rail_z[5];
// reasonable default, flat straight unrotated rail
bool is_straight = true;
u8 tileindex = 0;
// check for sloped rail
- if (is_rail_x_plus_y[0] || is_rail_x_plus_y[1] || is_rail_z_plus_y[0] || is_rail_z_plus_y[1])
- {
- adjacencies = 5; //5 means sloped
+ if (is_rail_x[4] || is_rail_x[5] || is_rail_z[4] || is_rail_z[5]) {
+ adjacencies = 5; // 5 means sloped
is_straight = true; // sloped is always straight
- }
- else
- {
+ } else {
// is really straight, rails on both sides
is_straight = (is_rail_x_all[0] && is_rail_x_all[1]) || (is_rail_z_all[0] && is_rail_z_all[1]);
adjacencies = is_rail_x_all[0] + is_rail_x_all[1] + is_rail_z_all[0] + is_rail_z_all[1];
switch (adjacencies) {
case 1:
- if(is_rail_x_all[0] || is_rail_x_all[1])
+ if (is_rail_x_all[0] || is_rail_x_all[1])
angle = 90;
break;
case 2:
- if(!is_straight)
+ if (!is_straight)
tileindex = 1; // curved
- if(is_rail_x_all[0] && is_rail_x_all[1])
+ if (is_rail_x_all[0] && is_rail_x_all[1])
angle = 90;
- if(is_rail_z_all[0] && is_rail_z_all[1]){
- if (is_rail_z_plus_y[0])
+ if (is_rail_z_all[0] && is_rail_z_all[1]) {
+ if (is_rail_z[4])
angle = 180;
}
- else if(is_rail_x_all[0] && is_rail_z_all[0])
+ else if (is_rail_x_all[0] && is_rail_z_all[0])
angle = 270;
- else if(is_rail_x_all[0] && is_rail_z_all[1])
+ else if (is_rail_x_all[0] && is_rail_z_all[1])
angle = 180;
- else if(is_rail_x_all[1] && is_rail_z_all[1])
+ else if (is_rail_x_all[1] && is_rail_z_all[1])
angle = 90;
break;
case 3:
// here is where the potential to 'switch' a junction is, but not implemented at present
tileindex = 2; // t-junction
if(!is_rail_x_all[1])
- angle=180;
+ angle = 180;
if(!is_rail_z_all[0])
- angle=90;
+ angle = 90;
if(!is_rail_z_all[1])
- angle=270;
+ angle = 270;
break;
case 4:
tileindex = 3; // crossing
break;
case 5: //sloped
- if(is_rail_z_plus_y[0])
+ if (is_rail_z[4])
angle = 180;
- if(is_rail_x_plus_y[0])
+ if (is_rail_x[4])
angle = 90;
- if(is_rail_x_plus_y[1])
+ if (is_rail_x[5])
angle = -90;
break;
default:
video::SColor c = MapBlock_LightColor(255, l, f.light_source);
float d = (float)BS/64;
-
- char g=-1;
- if (is_rail_x_plus_y[0] || is_rail_x_plus_y[1] || is_rail_z_plus_y[0] || is_rail_z_plus_y[1])
- g=1; //Object is at a slope
+ float s = BS/2;
+
+ short g = -1;
+ if (is_rail_x[4] || is_rail_x[5] || is_rail_z[4] || is_rail_z[5])
+ g = 1; //Object is at a slope
video::S3DVertex vertices[4] =
{
- video::S3DVertex(-BS/2,-BS/2+d,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,-BS/2+d,-BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,g*BS/2+d,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,g*BS/2+d,BS/2, 0,0,0, c, 0,0),
+ video::S3DVertex(-s, -s+d,-s, 0,0,0, c,0,1),
+ video::S3DVertex( s, -s+d,-s, 0,0,0, c,1,1),
+ video::S3DVertex( s, g*s+d, s, 0,0,0, c,1,0),
+ video::S3DVertex(-s, g*s+d, s, 0,0,0, c,0,0),
};
for(s32 i=0; i<4; i++)
makeCuboid(&collector, box, tiles, 6, c, txc);
}
break;}
+ case NDT_MESH:
+ {
+ v3f pos = intToFloat(p, BS);
+ video::SColor c = MapBlock_LightColor(255, getInteriorLight(n, 1, nodedef), f.light_source);
+
+ u8 facedir = 0;
+ if (f.param_type_2 == CPT2_FACEDIR) {
+ facedir = n.getFaceDir(nodedef);
+ } else if (f.param_type_2 == CPT2_WALLMOUNTED) {
+ //convert wallmounted to 6dfacedir.
+ //when cache enabled, it is already converted
+ facedir = n.getWallMounted(nodedef);
+ if (!enable_mesh_cache) {
+ static const u8 wm_to_6d[6] = {20, 0, 16+1, 12+3, 8, 4+2};
+ facedir = wm_to_6d[facedir];
+ }
+ }
+
+ if (f.mesh_ptr[facedir]) {
+ // use cached meshes
+ for(u16 j = 0; j < f.mesh_ptr[0]->getMeshBufferCount(); j++) {
+ scene::IMeshBuffer *buf = f.mesh_ptr[facedir]->getMeshBuffer(j);
+ collector.append(getNodeTileN(n, p, j, data),
+ (video::S3DVertex *)buf->getVertices(), buf->getVertexCount(),
+ buf->getIndices(), buf->getIndexCount(), pos, c);
+ }
+ } else if (f.mesh_ptr[0]) {
+ // no cache, clone and rotate mesh
+ scene::IMesh* mesh = cloneMesh(f.mesh_ptr[0]);
+ rotateMeshBy6dFacedir(mesh, facedir);
+ recalculateBoundingBox(mesh);
+ meshmanip->recalculateNormals(mesh, true, false);
+ for(u16 j = 0; j < mesh->getMeshBufferCount(); j++) {
+ scene::IMeshBuffer *buf = mesh->getMeshBuffer(j);
+ collector.append(getNodeTileN(n, p, j, data),
+ (video::S3DVertex *)buf->getVertices(), buf->getVertexCount(),
+ buf->getIndices(), buf->getIndexCount(), pos, c);
+ }
+ mesh->drop();
+ }
+ break;}
+ }
+ }
+
+ /*
+ Caused by incorrect alpha blending, selection mesh needs to be created as
+ last element to ensure it gets blended correct over nodes with alpha channel
+ */
+ // Create selection mesh
+ v3s16 p = data->m_highlighted_pos_relative;
+ if (data->m_show_hud &&
+ (p.X >= 0) && (p.X < MAP_BLOCKSIZE) &&
+ (p.Y >= 0) && (p.Y < MAP_BLOCKSIZE) &&
+ (p.Z >= 0) && (p.Z < MAP_BLOCKSIZE)) {
+
+ MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + p);
+ if(n.getContent() != CONTENT_AIR) {
+ // Get selection mesh light level
+ static const v3s16 dirs[7] = {
+ v3s16( 0, 0, 0),
+ v3s16( 0, 1, 0),
+ v3s16( 0,-1, 0),
+ v3s16( 1, 0, 0),
+ v3s16(-1, 0, 0),
+ v3s16( 0, 0, 1),
+ v3s16( 0, 0,-1)
+ };
+
+ u16 l = 0;
+ u16 l1 = 0;
+ for (u8 i = 0; i < 7; i++) {
+ MapNode n1 = data->m_vmanip.getNodeNoEx(blockpos_nodes + p + dirs[i]);
+ l1 = getInteriorLight(n1, -4, nodedef);
+ if (l1 > l)
+ l = l1;
+ }
+ video::SColor c = MapBlock_LightColor(255, l, 0);
+ data->m_highlight_mesh_color = c;
+ std::vector<aabb3f> boxes = n.getSelectionBoxes(nodedef);
+ TileSpec h_tile;
+ h_tile.material_flags |= MATERIAL_FLAG_HIGHLIGHTED;
+ h_tile.texture = tsrc->getTexture("halo.png",&h_tile.texture_id);
+ v3f pos = intToFloat(p, BS);
+ f32 d = 0.05 * BS;
+ for (std::vector<aabb3f>::iterator i = boxes.begin();
+ i != boxes.end(); i++) {
+ aabb3f box = *i;
+ box.MinEdge += v3f(-d, -d, -d) + pos;
+ box.MaxEdge += v3f(d, d, d) + pos;
+ makeCuboid(&collector, box, &h_tile, 1, c, NULL);
+ }
}
}
}
projects / dragonfireclient.git / blobdiff