#include "content_mapblock.h"
#include "main.h" // For g_settings
-#include "mineral.h"
-#include "mapblock_mesh.h" // For MapBlock_LightColor()
+#include "mapblock_mesh.h" // For MapBlock_LightColor() and MeshCollector
#include "settings.h"
#include "nodedef.h"
+#include "tile.h"
#include "gamedef.h"
-#ifndef SERVER
// Create a cuboid.
-// material - the material to use (for all 6 faces)
// collector - the MeshCollector for the resulting polygons
-// pa - texture atlas pointer for the material
+// box - the position and size of the box
+// tiles - the tiles (materials) to use (for all 6 faces)
+// tilecount - number of entries in tiles, 1<=tilecount<=6
// c - vertex colour - used for all
-// pos - the position of the centre of the cuboid
-// rz,ry,rz - the radius of the cuboid in each dimension
// txc - texture coordinates - this is a list of texture coordinates
// for the opposite corners of each face - therefore, there
// should be (2+2)*6=24 values in the list. Alternatively, pass
// NULL to use the entire texture for each face. The order of
-// the faces in the list is top-backi-right-front-left-bottom
-// If you specified 0,0,1,1 for each face, that would be the
-// same as passing NULL.
-void makeCuboid(video::SMaterial &material, MeshCollector *collector,
- AtlasPointer* pa, video::SColor &c,
- v3f &pos, f32 rx, f32 ry, f32 rz, f32* txc)
+// the faces in the list is up-down-right-left-back-front
+// (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,
+ const TileSpec *tiles, int tilecount,
+ video::SColor &c, const f32* txc)
{
- f32 tu0=pa->x0();
- f32 tu1=pa->x1();
- f32 tv0=pa->y0();
- f32 tv1=pa->y1();
- f32 txus=tu1-tu0;
- f32 txvs=tv1-tv0;
-
- video::S3DVertex v[4] =
+ assert(tilecount >= 1 && tilecount <= 6);
+
+ v3f min = box.MinEdge;
+ v3f max = box.MaxEdge;
+
+ if(txc == NULL)
{
- video::S3DVertex(0,0,0, 0,0,0, c, tu0, tv1),
- video::S3DVertex(0,0,0, 0,0,0, c, tu1, tv1),
- video::S3DVertex(0,0,0, 0,0,0, c, tu1, tv0),
- video::S3DVertex(0,0,0, 0,0,0, c, tu0, tv0)
- };
+ static const f32 txc_default[24] = {
+ 0,0,1,1,
+ 0,0,1,1,
+ 0,0,1,1,
+ 0,0,1,1,
+ 0,0,1,1,
+ 0,0,1,1
+ };
+ txc = txc_default;
+ }
- for(int i=0;i<6;i++)
+ video::S3DVertex vertices[24] =
{
- switch(i)
- {
- case 0: // top
- v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
- v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
- v[2].Pos.X= rx; v[2].Pos.Y= ry; v[2].Pos.Z= rz;
- v[3].Pos.X= rx; v[3].Pos.Y= ry, v[3].Pos.Z=-rz;
- break;
- case 1: // back
- v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
- v[1].Pos.X= rx; v[1].Pos.Y= ry; v[1].Pos.Z=-rz;
- v[2].Pos.X= rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
- v[3].Pos.X=-rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
- break;
- case 2: //right
- v[0].Pos.X= rx; v[0].Pos.Y= ry; v[0].Pos.Z=-rz;
- v[1].Pos.X= rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
- v[2].Pos.X= rx; v[2].Pos.Y=-ry; v[2].Pos.Z= rz;
- v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
- break;
- case 3: // front
- v[0].Pos.X= rx; v[0].Pos.Y= ry; v[0].Pos.Z= rz;
- v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z= rz;
- v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z= rz;
- v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z= rz;
- break;
- case 4: // left
- v[0].Pos.X=-rx; v[0].Pos.Y= ry; v[0].Pos.Z= rz;
- v[1].Pos.X=-rx; v[1].Pos.Y= ry; v[1].Pos.Z=-rz;
- v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
- v[3].Pos.X=-rx; v[3].Pos.Y=-ry, v[3].Pos.Z= rz;
- break;
- case 5: // bottom
- v[0].Pos.X= rx; v[0].Pos.Y=-ry; v[0].Pos.Z= rz;
- v[1].Pos.X=-rx; v[1].Pos.Y=-ry; v[1].Pos.Z= rz;
- v[2].Pos.X=-rx; v[2].Pos.Y=-ry; v[2].Pos.Z=-rz;
- v[3].Pos.X= rx; v[3].Pos.Y=-ry, v[3].Pos.Z=-rz;
- break;
- }
+ // up
+ video::S3DVertex(min.X,max.Y,max.Z, 0,1,0, c, txc[0],txc[1]),
+ video::S3DVertex(max.X,max.Y,max.Z, 0,1,0, c, txc[2],txc[1]),
+ video::S3DVertex(max.X,max.Y,min.Z, 0,1,0, c, txc[2],txc[3]),
+ video::S3DVertex(min.X,max.Y,min.Z, 0,1,0, c, txc[0],txc[3]),
+ // down
+ video::S3DVertex(min.X,min.Y,min.Z, 0,-1,0, c, txc[4],txc[5]),
+ video::S3DVertex(max.X,min.Y,min.Z, 0,-1,0, c, txc[6],txc[5]),
+ video::S3DVertex(max.X,min.Y,max.Z, 0,-1,0, c, txc[6],txc[7]),
+ video::S3DVertex(min.X,min.Y,max.Z, 0,-1,0, c, txc[4],txc[7]),
+ // right
+ video::S3DVertex(max.X,max.Y,min.Z, 1,0,0, c, txc[ 8],txc[9]),
+ video::S3DVertex(max.X,max.Y,max.Z, 1,0,0, c, txc[10],txc[9]),
+ video::S3DVertex(max.X,min.Y,max.Z, 1,0,0, c, txc[10],txc[11]),
+ video::S3DVertex(max.X,min.Y,min.Z, 1,0,0, c, txc[ 8],txc[11]),
+ // left
+ video::S3DVertex(min.X,max.Y,max.Z, -1,0,0, c, txc[12],txc[13]),
+ video::S3DVertex(min.X,max.Y,min.Z, -1,0,0, c, txc[14],txc[13]),
+ video::S3DVertex(min.X,min.Y,min.Z, -1,0,0, c, txc[14],txc[15]),
+ video::S3DVertex(min.X,min.Y,max.Z, -1,0,0, c, txc[12],txc[15]),
+ // back
+ video::S3DVertex(max.X,max.Y,max.Z, 0,0,1, c, txc[16],txc[17]),
+ video::S3DVertex(min.X,max.Y,max.Z, 0,0,1, c, txc[18],txc[17]),
+ video::S3DVertex(min.X,min.Y,max.Z, 0,0,1, c, txc[18],txc[19]),
+ video::S3DVertex(max.X,min.Y,max.Z, 0,0,1, c, txc[16],txc[19]),
+ // front
+ video::S3DVertex(min.X,max.Y,min.Z, 0,0,-1, c, txc[20],txc[21]),
+ video::S3DVertex(max.X,max.Y,min.Z, 0,0,-1, c, txc[22],txc[21]),
+ video::S3DVertex(max.X,min.Y,min.Z, 0,0,-1, c, txc[22],txc[23]),
+ video::S3DVertex(min.X,min.Y,min.Z, 0,0,-1, c, txc[20],txc[23]),
+ };
- if(txc!=NULL)
- {
- v[0].TCoords.X=tu0+txus*txc[0]; v[0].TCoords.Y=tv0+txvs*txc[3];
- v[1].TCoords.X=tu0+txus*txc[2]; v[1].TCoords.Y=tv0+txvs*txc[3];
- v[2].TCoords.X=tu0+txus*txc[2]; v[2].TCoords.Y=tv0+txvs*txc[1];
- v[3].TCoords.X=tu0+txus*txc[0]; v[3].TCoords.Y=tv0+txvs*txc[1];
- txc+=4;
- }
+ for(s32 j=0; j<24; j++)
+ {
+ int tileindex = MYMIN(j/4, tilecount-1);
+ vertices[j].TCoords *= tiles[tileindex].texture.size;
+ vertices[j].TCoords += tiles[tileindex].texture.pos;
+ }
- for(u16 i=0; i<4; i++)
- v[i].Pos += pos;
- u16 indices[] = {0,1,2,2,3,0};
- collector->append(material, v, 4, indices, 6);
+ 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);
}
-
}
-#endif
-#ifndef SERVER
void mapblock_mesh_generate_special(MeshMakeData *data,
- MeshCollector &collector, IGameDef *gamedef)
+ MeshCollector &collector)
{
- INodeDefManager *nodedef = gamedef->ndef();
+ INodeDefManager *nodedef = data->m_gamedef->ndef();
// 0ms
//TimeTaker timer("mapblock_mesh_generate_special()");
v3s16 blockpos_nodes = data->m_blockpos*MAP_BLOCKSIZE;
- /*// General ground material for special output
- // Texture is modified just before usage
- video::SMaterial material_general;
- material_general.setFlag(video::EMF_LIGHTING, false);
- material_general.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_general.setFlag(video::EMF_FOG_ENABLE, true);
- material_general.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;*/
-
for(s16 z=0; z<MAP_BLOCKSIZE; z++)
for(s16 y=0; y<MAP_BLOCKSIZE; y++)
for(s16 x=0; x<MAP_BLOCKSIZE; x++)
/*
Add water sources to mesh if using new style
*/
- assert(nodedef->get(n).special_materials[0]);
- //assert(nodedef->get(n).special_materials[1]);
- assert(nodedef->get(n).special_aps[0]);
-
- video::SMaterial &liquid_material =
- *nodedef->get(n).special_materials[0];
- /*video::SMaterial &liquid_material_bfculled =
- *nodedef->get(n).special_materials[1];*/
- AtlasPointer &pa_liquid1 =
- *nodedef->get(n).special_aps[0];
+ TileSpec tile_liquid = f.special_tiles[0];
+ AtlasPointer &pa_liquid = tile_liquid.texture;
bool top_is_air = false;
MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
if(top_is_air == false)
continue;
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
- video::SColor c = MapBlock_LightColor(
- nodedef->get(n).alpha, l);
+ u16 l = getInteriorLight(n, 0, data);
+ video::SColor c = MapBlock_LightColor(f.alpha, l);
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y1()),
+ pa_liquid.x0(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y1()),
+ pa_liquid.x1(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y0()),
+ pa_liquid.x1(), pa_liquid.y0()),
video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y0()),
+ pa_liquid.x0(), pa_liquid.y0()),
};
+ v3f offset(p.X, p.Y + (-0.5+node_liquid_level)*BS, p.Z);
for(s32 i=0; i<4; i++)
{
- vertices[i].Pos.Y += (-0.5+node_liquid_level)*BS;
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += offset;
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(liquid_material, vertices, 4, indices, 6);
+ collector.append(tile_liquid, vertices, 4, indices, 6);
break;}
case NDT_FLOWINGLIQUID:
{
/*
Add flowing liquid to mesh
*/
- assert(nodedef->get(n).special_materials[0]);
- assert(nodedef->get(n).special_materials[1]);
- assert(nodedef->get(n).special_aps[0]);
-
- video::SMaterial &liquid_material =
- *nodedef->get(n).special_materials[0];
- video::SMaterial &liquid_material_bfculled =
- *nodedef->get(n).special_materials[1];
- AtlasPointer &pa_liquid1 =
- *nodedef->get(n).special_aps[0];
+ TileSpec tile_liquid = f.special_tiles[0];
+ TileSpec tile_liquid_bfculled = f.special_tiles[1];
+ AtlasPointer &pa_liquid = tile_liquid.texture;
bool top_is_same_liquid = false;
MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
- content_t c_flowing = nodedef->getId(nodedef->get(n).liquid_alternative_flowing);
- content_t c_source = nodedef->getId(nodedef->get(n).liquid_alternative_source);
+ content_t c_flowing = nodedef->getId(f.liquid_alternative_flowing);
+ content_t c_source = nodedef->getId(f.liquid_alternative_source);
if(ntop.getContent() == c_flowing || ntop.getContent() == c_source)
top_is_same_liquid = true;
- u8 l = 0;
+ u16 l = 0;
// Use the light of the node on top if possible
if(nodedef->get(ntop).param_type == CPT_LIGHT)
- l = decode_light(ntop.getLightBlend(data->m_daynight_ratio, nodedef));
+ l = getInteriorLight(ntop, 0, data);
// Otherwise use the light of this node (the liquid)
else
- l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
- video::SColor c = MapBlock_LightColor(
- nodedef->get(n).alpha, l);
+ l = getInteriorLight(n, 0, data);
+ video::SColor c = MapBlock_LightColor(f.alpha, l);
// Neighbor liquid levels (key = relative position)
// Includes current node
// Use backface culled material if neighbor doesn't have a
// solidness of 0
- video::SMaterial *current_material = &liquid_material;
+ const TileSpec *current_tile = &tile_liquid;
if(n_feat.solidness != 0 || n_feat.visual_solidness != 0)
- current_material = &liquid_material_bfculled;
+ current_tile = &tile_liquid_bfculled;
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y1()),
+ pa_liquid.x0(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y1()),
+ pa_liquid.x1(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y0()),
+ pa_liquid.x1(), pa_liquid.y0()),
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y0()),
+ pa_liquid.x0(), pa_liquid.y0()),
};
/*
vertices[j].Pos.Z *= 0.98;
}*/
- vertices[j].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[j].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(*current_material, vertices, 4, indices, 6);
+ collector.append(*current_tile, vertices, 4, indices, 6);
}
/*
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y1()),
+ pa_liquid.x0(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y1()),
+ pa_liquid.x1(), pa_liquid.y1()),
video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c,
- pa_liquid1.x1(), pa_liquid1.y0()),
+ pa_liquid.x1(), pa_liquid.y0()),
video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c,
- pa_liquid1.x0(), pa_liquid1.y0()),
+ pa_liquid.x0(), pa_liquid.y0()),
};
// This fixes a strange bug
//vertices[i].Pos.Y += neighbor_levels[v3s16(0,0,0)];
s32 j = corner_resolve[i];
vertices[i].Pos.Y += corner_levels[j];
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(liquid_material, vertices, 4, indices, 6);
+ collector.append(tile_liquid, vertices, 4, indices, 6);
}
break;}
case NDT_GLASSLIKE:
{
- video::SMaterial material_glass;
- material_glass.setFlag(video::EMF_LIGHTING, false);
- material_glass.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_glass.setFlag(video::EMF_FOG_ENABLE, true);
- material_glass.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_glass = f.tiles[0].texture;
- material_glass.setTexture(0, pa_glass.atlas);
-
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
+ TileSpec tile = getNodeTile(n, p, v3s16(0,0,0), data);
+ AtlasPointer ap = tile.texture;
+
+ u16 l = getInteriorLight(n, 1, data);
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<6; j++)
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_glass.x0(), pa_glass.y1()),
+ ap.x0(), ap.y1()),
video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_glass.x1(), pa_glass.y1()),
+ ap.x1(), ap.y1()),
video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
- pa_glass.x1(), pa_glass.y0()),
+ ap.x1(), ap.y0()),
video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
- pa_glass.x0(), pa_glass.y0()),
+ ap.x0(), ap.y0()),
};
// Rotations in the g_6dirs format
vertices[i].Pos.rotateXZBy(90);
for(u16 i=0; i<4; i++){
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(material_glass, vertices, 4, indices, 6);
+ collector.append(tile, vertices, 4, indices, 6);
}
break;}
case NDT_ALLFACES:
{
- video::SMaterial material_leaves1;
- material_leaves1.setFlag(video::EMF_LIGHTING, false);
- material_leaves1.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_leaves1.setFlag(video::EMF_FOG_ENABLE, true);
- material_leaves1.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_leaves1 = f.tiles[0].texture;
- material_leaves1.setTexture(0, pa_leaves1.atlas);
-
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
- video::SColor c = MapBlock_LightColor(255, l);
+ TileSpec tile_leaves = getNodeTile(n, p,
+ v3s16(0,0,0), data);
+ AtlasPointer pa_leaves = tile_leaves.texture;
- for(u32 j=0; j<6; j++)
- {
- video::S3DVertex vertices[4] =
- {
- video::S3DVertex(-BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x0(), pa_leaves1.y1()),
- video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x1(), pa_leaves1.y1()),
- video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x1(), pa_leaves1.y0()),
- video::S3DVertex(-BS/2,BS/2,BS/2, 0,0,0, c,
- pa_leaves1.x0(), pa_leaves1.y0()),
- };
-
- // Rotations in the g_6dirs format
- if(j == 0) // Z+
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(0);
- else if(j == 1) // Y+
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateYZBy(-90);
- else if(j == 2) // X+
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(-90);
- else if(j == 3) // Z-
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(180);
- else if(j == 4) // Y-
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateYZBy(90);
- else if(j == 5) // X-
- for(u16 i=0; i<4; i++)
- vertices[i].Pos.rotateXZBy(90);
-
- for(u16 i=0; i<4; i++){
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
- }
+ u16 l = getInteriorLight(n, 1, data);
+ video::SColor c = MapBlock_LightColor(255, l);
- u16 indices[] = {0,1,2,2,3,0};
- // Add to mesh collector
- collector.append(material_leaves1, vertices, 4, indices, 6);
- }
+ v3f pos = intToFloat(p, BS);
+ aabb3f box(-BS/2,-BS/2,-BS/2,BS/2,BS/2,BS/2);
+ box.MinEdge += pos;
+ box.MaxEdge += pos;
+ makeCuboid(&collector, box, &tile_leaves, 1, c, NULL);
break;}
case NDT_ALLFACES_OPTIONAL:
// This is always pre-converted to something else
break;
case NDT_TORCHLIKE:
{
- v3s16 dir = unpackDir(n.param2);
+ v3s16 dir = n.getWallMountedDir(nodedef);
- AtlasPointer ap(0);
+ u8 tileindex = 0;
if(dir == v3s16(0,-1,0)){
- ap = f.tiles[0].texture; // floor
+ tileindex = 0; // floor
} else if(dir == v3s16(0,1,0)){
- ap = f.tiles[1].texture; // ceiling
+ tileindex = 1; // ceiling
// For backwards compatibility
} else if(dir == v3s16(0,0,0)){
- ap = f.tiles[0].texture; // floor
+ tileindex = 0; // floor
} else {
- ap = f.tiles[2].texture; // side
+ tileindex = 2; // side
}
- // Set material
- video::SMaterial material;
- material.setFlag(video::EMF_LIGHTING, false);
- material.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material.setFlag(video::EMF_BILINEAR_FILTER, false);
- material.setFlag(video::EMF_FOG_ENABLE, true);
- //material.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- material.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- material.setTexture(0, ap.atlas);
+ TileSpec tile = getNodeTileN(n, p, tileindex, data);
+ tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
+ tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+
+ AtlasPointer ap = tile.texture;
video::SColor c(255,255,255,255);
if(dir == v3s16(0,1,0))
vertices[i].Pos.rotateXZBy(-45);
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(material, vertices, 4, indices, 6);
+ collector.append(tile, vertices, 4, indices, 6);
break;}
case NDT_SIGNLIKE:
{
- // Set material
- video::SMaterial material;
- material.setFlag(video::EMF_LIGHTING, false);
- material.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material.setFlag(video::EMF_BILINEAR_FILTER, false);
- material.setFlag(video::EMF_FOG_ENABLE, true);
- material.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer ap = f.tiles[0].texture;
- material.setTexture(0, ap.atlas);
-
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
+ TileSpec tile = getNodeTileN(n, p, 0, data);
+ tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
+ tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+ AtlasPointer ap = tile.texture;
+
+ u16 l = getInteriorLight(n, 0, data);
video::SColor c = MapBlock_LightColor(255, l);
float d = (float)BS/16;
ap.x0(), ap.y1()),
};
- v3s16 dir = unpackDir(n.param2);
+ v3s16 dir = n.getWallMountedDir(nodedef);
for(s32 i=0; i<4; i++)
{
if(dir == v3s16(0,1,0))
vertices[i].Pos.rotateXYBy(90);
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(material, vertices, 4, indices, 6);
+ collector.append(tile, vertices, 4, indices, 6);
break;}
case NDT_PLANTLIKE:
{
- video::SMaterial material_papyrus;
- material_papyrus.setFlag(video::EMF_LIGHTING, false);
- material_papyrus.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_papyrus.setFlag(video::EMF_FOG_ENABLE, true);
- material_papyrus.MaterialType=video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_papyrus = f.tiles[0].texture;
- material_papyrus.setTexture(0, pa_papyrus.atlas);
+ TileSpec tile = getNodeTileN(n, p, 0, data);
+ tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+ AtlasPointer ap = tile.texture;
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
+ u16 l = getInteriorLight(n, 1, data);
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<4; j++)
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2*f.visual_scale,-BS/2,0, 0,0,0, c,
- pa_papyrus.x0(), pa_papyrus.y1()),
+ ap.x0(), ap.y1()),
video::S3DVertex( BS/2*f.visual_scale,-BS/2,0, 0,0,0, c,
- pa_papyrus.x1(), pa_papyrus.y1()),
+ ap.x1(), ap.y1()),
video::S3DVertex( BS/2*f.visual_scale,
-BS/2 + f.visual_scale*BS,0, 0,0,0, c,
- pa_papyrus.x1(), pa_papyrus.y0()),
+ ap.x1(), ap.y0()),
video::S3DVertex(-BS/2*f.visual_scale,
-BS/2 + f.visual_scale*BS,0, 0,0,0, c,
- pa_papyrus.x0(), pa_papyrus.y0()),
+ ap.x0(), ap.y0()),
};
if(j == 0)
for(u16 i=0; i<4; i++)
{
vertices[i].Pos *= f.visual_scale;
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(material_papyrus, vertices, 4, indices, 6);
+ collector.append(tile, vertices, 4, indices, 6);
}
break;}
case NDT_FENCELIKE:
{
- video::SMaterial material_wood;
- material_wood.setFlag(video::EMF_LIGHTING, false);
- material_wood.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_wood.setFlag(video::EMF_FOG_ENABLE, true);
- material_wood.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_wood = f.tiles[0].texture;
- material_wood.setTexture(0, pa_wood.atlas);
-
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
+ TileSpec tile = getNodeTile(n, p, v3s16(0,0,0), data);
+ TileSpec tile_nocrack = tile;
+ tile_nocrack.material_flags &= ~MATERIAL_FLAG_CRACK;
+
+ u16 l = getInteriorLight(n, 1, data);
video::SColor c = MapBlock_LightColor(255, l);
const f32 post_rad=(f32)BS/10;
const f32 bar_rad=(f32)BS/20;
const f32 bar_len=(f32)(BS/2)-post_rad;
+ v3f pos = intToFloat(p, BS);
+
// The post - always present
- v3f pos = intToFloat(p+blockpos_nodes, BS);
+ aabb3f post(-post_rad,-BS/2,-post_rad,post_rad,BS/2,post_rad);
+ post.MinEdge += pos;
+ post.MaxEdge += pos;
f32 postuv[24]={
+ 0.4,0.4,0.6,0.6,
0.4,0.4,0.6,0.6,
0.35,0,0.65,1,
0.35,0,0.65,1,
0.35,0,0.65,1,
- 0.35,0,0.65,1,
- 0.4,0.4,0.6,0.6};
- makeCuboid(material_wood, &collector,
- &pa_wood, c, pos,
- post_rad,BS/2,post_rad, postuv);
+ 0.35,0,0.65,1};
+ makeCuboid(&collector, post, &tile, 1, c, postuv);
// Now a section of fence, +X, if there's a post there
v3s16 p2 = p;
const ContentFeatures *f2 = &nodedef->get(n2);
if(f2->drawtype == NDT_FENCELIKE)
{
- pos = intToFloat(p+blockpos_nodes, BS);
- pos.X += BS/2;
- pos.Y += BS/4;
+ aabb3f bar(-bar_len+BS/2,-bar_rad+BS/4,-bar_rad,
+ bar_len+BS/2,bar_rad+BS/4,bar_rad);
+ bar.MinEdge += pos;
+ bar.MaxEdge += pos;
f32 xrailuv[24]={
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6};
- makeCuboid(material_wood, &collector,
- &pa_wood, c, pos,
- bar_len,bar_rad,bar_rad, xrailuv);
-
- pos.Y -= BS/2;
- makeCuboid(material_wood, &collector,
- &pa_wood, c, pos,
- bar_len,bar_rad,bar_rad, xrailuv);
+ makeCuboid(&collector, bar, &tile_nocrack, 1,
+ c, xrailuv);
+ bar.MinEdge.Y -= BS/2;
+ bar.MaxEdge.Y -= BS/2;
+ // TODO: no crack
+ makeCuboid(&collector, bar, &tile_nocrack, 1,
+ c, xrailuv);
}
// Now a section of fence, +Z, if there's a post there
f2 = &nodedef->get(n2);
if(f2->drawtype == NDT_FENCELIKE)
{
- pos = intToFloat(p+blockpos_nodes, BS);
- pos.Z += BS/2;
- pos.Y += BS/4;
+ aabb3f bar(-bar_rad,-bar_rad+BS/4,-bar_len+BS/2,
+ bar_rad,bar_rad+BS/4,bar_len+BS/2);
+ bar.MinEdge += pos;
+ bar.MaxEdge += pos;
f32 zrailuv[24]={
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6,
0,0.4,1,0.6};
- makeCuboid(material_wood, &collector,
- &pa_wood, c, pos,
- bar_rad,bar_rad,bar_len, zrailuv);
- pos.Y -= BS/2;
- makeCuboid(material_wood, &collector,
- &pa_wood, c, pos,
- bar_rad,bar_rad,bar_len, zrailuv);
+ makeCuboid(&collector, bar, &tile_nocrack, 1,
+ c, zrailuv);
+ bar.MinEdge.Y -= BS/2;
+ bar.MaxEdge.Y -= BS/2;
+ makeCuboid(&collector, bar, &tile_nocrack, 1,
+ c, zrailuv);
}
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));
content_t thiscontent = n.getContent();
if(n_minus_x.getContent() == thiscontent)
is_rail_x[0] = true;
+ if (n_minus_x_minus_y.getContent() == thiscontent)
+ is_rail_x_minus_y[0] = true;
+ if(n_minus_x_plus_y.getContent() == thiscontent)
+ is_rail_x_plus_y[0] = true;
+
if(n_plus_x.getContent() == thiscontent)
is_rail_x[1] = true;
+ if (n_plus_x_minus_y.getContent() == thiscontent)
+ is_rail_x_minus_y[1] = true;
+ if(n_plus_x_plus_y.getContent() == thiscontent)
+ is_rail_x_plus_y[1] = true;
+
if(n_minus_z.getContent() == thiscontent)
is_rail_z[0] = true;
+ if (n_minus_z_minus_y.getContent() == thiscontent)
+ is_rail_z_minus_y[0] = true;
+ if(n_minus_z_plus_y.getContent() == thiscontent)
+ is_rail_z_plus_y[0] = true;
+
if(n_plus_z.getContent() == thiscontent)
is_rail_z[1] = true;
+ if (n_plus_z_minus_y.getContent() == thiscontent)
+ is_rail_z_minus_y[1] = true;
+ if(n_plus_z_plus_y.getContent() == thiscontent)
+ is_rail_z_plus_y[1] = true;
+
- int adjacencies = is_rail_x[0] + is_rail_x[1] + is_rail_z[0] + is_rail_z[1];
+ 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];
+
+ bool is_straight = (is_rail_x_all[0] && is_rail_x_all[1]) || (is_rail_z_all[0] && is_rail_z_all[1]);//is really straight, rails on both sides
+ int adjacencies = is_rail_x_all[0] + is_rail_x_all[1] + is_rail_z_all[0] + is_rail_z_all[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]) //is straight because sloped
+ {
+ adjacencies = 5; //5 means sloped
+ is_straight = true;
+ }
// Assign textures
- AtlasPointer ap = f.tiles[0].texture; // straight
+ u8 tileindex = 0; // straight
if(adjacencies < 2)
- ap = f.tiles[0].texture; // straight
+ tileindex = 0; // straight
else if(adjacencies == 2)
{
- if((is_rail_x[0] && is_rail_x[1]) || (is_rail_z[0] && is_rail_z[1]))
- ap = f.tiles[0].texture; // straight
+ if(is_straight)
+ tileindex = 0; // straight
else
- ap = f.tiles[1].texture; // curved
+ tileindex = 1; // curved
}
else if(adjacencies == 3)
- ap = f.tiles[2].texture; // t-junction
+ tileindex = 2; // t-junction
else if(adjacencies == 4)
- ap = f.tiles[3].texture; // crossing
+ tileindex = 3; // crossing
+
+ TileSpec tile = getNodeTileN(n, p, tileindex, data);
+ tile.material_flags &= ~MATERIAL_FLAG_BACKFACE_CULLING;
+ tile.material_flags |= MATERIAL_FLAG_CRACK_OVERLAY;
+
+ AtlasPointer ap = tile.texture;
- video::SMaterial material_rail;
- material_rail.setFlag(video::EMF_LIGHTING, false);
- material_rail.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material_rail.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_rail.setFlag(video::EMF_FOG_ENABLE, true);
- material_rail.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- material_rail.setTexture(0, ap.atlas);
-
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
+ u16 l = getInteriorLight(n, 0, data);
video::SColor c = MapBlock_LightColor(255, l);
- float d = (float)BS/16;
+ 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
+
video::S3DVertex vertices[4] =
{
- video::S3DVertex(-BS/2,-BS/2+d,-BS/2, 0,0,0, c,
- ap.x0(), ap.y1()),
- video::S3DVertex(BS/2,-BS/2+d,-BS/2, 0,0,0, c,
- ap.x1(), ap.y1()),
- video::S3DVertex(BS/2,-BS/2+d,BS/2, 0,0,0, c,
- ap.x1(), ap.y0()),
- video::S3DVertex(-BS/2,-BS/2+d,BS/2, 0,0,0, c,
- ap.x0(), ap.y0()),
+ video::S3DVertex(-BS/2,-BS/2+d,-BS/2, 0,0,0, c,
+ ap.x0(), ap.y1()),
+ video::S3DVertex(BS/2,-BS/2+d,-BS/2, 0,0,0, c,
+ ap.x1(), ap.y1()),
+ video::S3DVertex(BS/2,g*BS/2+d,BS/2, 0,0,0, c,
+ ap.x1(), ap.y0()),
+ video::S3DVertex(-BS/2,g*BS/2+d,BS/2, 0,0,0, c,
+ ap.x0(), ap.y0()),
};
+
// Rotate textures
int angle = 0;
if(adjacencies == 1)
{
- if(is_rail_x[0] || is_rail_x[1])
+ if(is_rail_x_all[0] || is_rail_x_all[1])
angle = 90;
}
- else if(adjacencies == 2)
+ if(adjacencies == 2)
{
- if(is_rail_x[0] && is_rail_x[1])
+ if(is_rail_x_all[0] && is_rail_x_all[1])
+ {
angle = 90;
- else if(is_rail_x[0] && is_rail_z[0])
+ }
+ if(is_rail_z_all[0] && is_rail_z_all[1])
+ {
+ if (n_minus_z_plus_y.getContent() == thiscontent) angle = 180;
+ }
+ else if(is_rail_x_all[0] && is_rail_z_all[0])
angle = 270;
- else if(is_rail_x[0] && is_rail_z[1])
+ else if(is_rail_x_all[0] && is_rail_z_all[1])
angle = 180;
- else if(is_rail_x[1] && is_rail_z[1])
+ else if(is_rail_x_all[1] && is_rail_z_all[1])
angle = 90;
}
- else if(adjacencies == 3)
+ if(adjacencies == 3)
{
- if(!is_rail_x[0])
+ if(!is_rail_x_all[0])
angle=0;
- if(!is_rail_x[1])
+ if(!is_rail_x_all[1])
angle=180;
- if(!is_rail_z[0])
+ if(!is_rail_z_all[0])
angle=90;
- if(!is_rail_z[1])
+ if(!is_rail_z_all[1])
angle=270;
}
+ //adjacencies 4: Crossing
+ if(adjacencies == 5) //sloped
+ {
+ if(is_rail_z_plus_y[0])
+ angle = 180;
+ if(is_rail_x_plus_y[0])
+ angle = 90;
+ if(is_rail_x_plus_y[1])
+ angle = -90;
+ }
if(angle != 0) {
for(u16 i=0; i<4; i++)
for(s32 i=0; i<4; i++)
{
- vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ vertices[i].Pos += intToFloat(p, BS);
}
u16 indices[] = {0,1,2,2,3,0};
- collector.append(material_rail, vertices, 4, indices, 6);
+ collector.append(tile, vertices, 4, indices, 6);
break;}
}
}
}
-#endif
projects / minetest.git / blobdiff