- /*
+/*
Minetest-c55
Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
#include "content_mapblock.h"
#include "content_mapnode.h"
-#include "main.h" // For g_settings and g_texturesource
+#include "main.h" // For g_settings
#include "mineral.h"
#include "mapblock_mesh.h" // For MapBlock_LightColor()
+#include "settings.h"
+#include "nodedef.h"
+#include "gamedef.h"
#ifndef SERVER
// Create a cuboid.
#ifndef SERVER
void mapblock_mesh_generate_special(MeshMakeData *data,
- MeshCollector &collector)
+ MeshCollector &collector, IGameDef *gamedef)
{
+ ITextureSource *tsrc = gamedef->tsrc();
+ INodeDefManager *nodedef = gamedef->ndef();
+
// 0ms
//TimeTaker timer("mapblock_mesh_generate_special()");
/*
Some settings
*/
- bool new_style_water = g_settings.getBool("new_style_water");
- bool new_style_leaves = g_settings.getBool("new_style_leaves");
- //bool smooth_lighting = g_settings.getBool("smooth_lighting");
- bool invisible_stone = g_settings.getBool("invisible_stone");
+ bool new_style_water = g_settings->getBool("new_style_water");
+ bool new_style_leaves = g_settings->getBool("new_style_leaves");
+ //bool smooth_lighting = g_settings->getBool("smooth_lighting");
+ bool invisible_stone = g_settings->getBool("invisible_stone");
float node_liquid_level = 1.0;
if(new_style_water)
// New-style leaves material
video::SMaterial material_leaves1;
material_leaves1.setFlag(video::EMF_LIGHTING, false);
- //material_leaves1.setFlag(video::EMF_BACK_FACE_CULLING, 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 = g_texturesource->getTexture(
- g_texturesource->getTextureId("leaves.png"));
+ AtlasPointer pa_leaves1 = tsrc->getTexture(
+ tsrc->getTextureId("leaves.png"));
material_leaves1.setTexture(0, pa_leaves1.atlas);
// Glass material
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 = g_texturesource->getTexture(
- g_texturesource->getTextureId("glass.png"));
+ AtlasPointer pa_glass = tsrc->getTexture(
+ tsrc->getTextureId("glass.png"));
material_glass.setTexture(0, pa_glass.atlas);
// Wood material
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 = g_texturesource->getTexture(
- g_texturesource->getTextureId("wood.png"));
+ AtlasPointer pa_wood = tsrc->getTexture(
+ tsrc->getTextureId("wood.png"));
material_wood.setTexture(0, pa_wood.atlas);
// General ground material for special output
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 = g_texturesource->getTexture(
- g_texturesource->getTextureId("papyrus.png"));
+ AtlasPointer pa_papyrus = tsrc->getTexture(
+ tsrc->getTextureId("papyrus.png"));
material_papyrus.setTexture(0, pa_papyrus.atlas);
// Apple material
material_apple.setFlag(video::EMF_BILINEAR_FILTER, false);
material_apple.setFlag(video::EMF_FOG_ENABLE, true);
material_apple.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_apple = g_texturesource->getTexture(
- g_texturesource->getTextureId("apple.png"));
+ AtlasPointer pa_apple = tsrc->getTexture(
+ tsrc->getTextureId("apple.png"));
material_apple.setTexture(0, pa_apple.atlas);
+
+ // Sapling material
+ video::SMaterial material_sapling;
+ material_sapling.setFlag(video::EMF_LIGHTING, false);
+ material_sapling.setFlag(video::EMF_BILINEAR_FILTER, false);
+ material_sapling.setFlag(video::EMF_FOG_ENABLE, true);
+ material_sapling.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+ AtlasPointer pa_sapling = tsrc->getTexture(
+ tsrc->getTextureId("sapling.png"));
+ material_sapling.setTexture(0, pa_sapling.atlas);
+
+
// junglegrass material
video::SMaterial material_junglegrass;
material_junglegrass.setFlag(video::EMF_LIGHTING, false);
material_junglegrass.setFlag(video::EMF_BILINEAR_FILTER, false);
material_junglegrass.setFlag(video::EMF_FOG_ENABLE, true);
material_junglegrass.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- AtlasPointer pa_junglegrass = g_texturesource->getTexture(
- g_texturesource->getTextureId("junglegrass.png"));
+ AtlasPointer pa_junglegrass = tsrc->getTexture(
+ tsrc->getTextureId("junglegrass.png"));
material_junglegrass.setTexture(0, pa_junglegrass.atlas);
for(s16 z=0; z<MAP_BLOCKSIZE; z++)
v3s16 p(x,y,z);
MapNode n = data->m_vmanip.getNodeNoEx(blockpos_nodes+p);
-
+
/*
Add torches to mesh
*/
if(n.getContent() == CONTENT_TORCH)
{
+ v3s16 dir = unpackDir(n.param2);
+
+ const char *texturename = "torch.png";
+ if(dir == v3s16(0,-1,0)){
+ texturename = "torch_on_floor.png";
+ } else if(dir == v3s16(0,1,0)){
+ texturename = "torch_on_ceiling.png";
+ // For backwards compatibility
+ } else if(dir == v3s16(0,0,0)){
+ texturename = "torch_on_floor.png";
+ } else {
+ texturename = "torch.png";
+ }
+
+ AtlasPointer ap = tsrc->getTexture(texturename);
+
+ // 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);
+
video::SColor c(255,255,255,255);
// Wall at X+ of node
video::S3DVertex vertices[4] =
{
- video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,BS/2,0, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c, 0,0),
+ video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c,
+ ap.x0(), ap.y1()),
+ video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c,
+ ap.x1(), ap.y1()),
+ video::S3DVertex(BS/2,BS/2,0, 0,0,0, c,
+ ap.x1(), ap.y0()),
+ video::S3DVertex(-BS/2,BS/2,0, 0,0,0, c,
+ ap.x0(), ap.y0()),
};
- v3s16 dir = unpackDir(n.param2);
-
for(s32 i=0; i<4; i++)
{
if(dir == v3s16(1,0,0))
vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
}
- // 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.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
- material.MaterialType
- = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
-
- if(dir == v3s16(0,-1,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_floor.png"));
- else if(dir == v3s16(0,1,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_ceiling.png"));
- // For backwards compatibility
- else if(dir == v3s16(0,0,0))
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch_on_floor.png"));
- else
- material.setTexture(0,
- g_texturesource->getTextureRaw("torch.png"));
-
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
collector.append(material, vertices, 4, indices, 6);
*/
else if(n.getContent() == CONTENT_SIGN_WALL)
{
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
+ AtlasPointer ap = tsrc->getTexture("sign_wall.png");
+
+ // 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;
+ material.setTexture(0, ap.atlas);
+
+ u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
video::SColor c = MapBlock_LightColor(255, l);
float d = (float)BS/16;
// Wall at X+ of node
video::S3DVertex vertices[4] =
{
- video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c, 0,0),
+ video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c,
+ ap.x0(), ap.y1()),
+ video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c,
+ ap.x1(), ap.y1()),
+ video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c,
+ ap.x1(), ap.y0()),
+ video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c,
+ ap.x0(), ap.y0()),
};
v3s16 dir = unpackDir(n.param2);
vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
}
- // 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,
- g_texturesource->getTextureRaw("sign_wall.png"));
-
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
collector.append(material, vertices, 4, indices, 6);
/*
Add flowing liquid to mesh
*/
- else if(content_features(n).liquid_type == LIQUID_FLOWING)
+ else if(nodedef->get(n).liquid_type == LIQUID_FLOWING)
{
- assert(content_features(n).special_material);
+ assert(nodedef->get(n).special_material);
video::SMaterial &liquid_material =
- *content_features(n).special_material;
- assert(content_features(n).special_atlas);
+ *nodedef->get(n).special_material;
+ video::SMaterial &liquid_material_bfculled =
+ *nodedef->get(n).special_material2;
+
+ assert(nodedef->get(n).special_atlas);
AtlasPointer &pa_liquid1 =
- *content_features(n).special_atlas;
+ *nodedef->get(n).special_atlas;
bool top_is_same_liquid = false;
MapNode ntop = data->m_vmanip.getNodeNoEx(blockpos_nodes + v3s16(x,y+1,z));
- content_t c_flowing = content_features(n).liquid_alternative_flowing;
- content_t c_source = content_features(n).liquid_alternative_source;
+ content_t c_flowing = nodedef->get(n).liquid_alternative_flowing;
+ content_t c_source = nodedef->get(n).liquid_alternative_source;
if(ntop.getContent() == c_flowing || ntop.getContent() == c_source)
top_is_same_liquid = true;
u8 l = 0;
// Use the light of the node on top if possible
- if(content_features(ntop).param_type == CPT_LIGHT)
- l = decode_light(ntop.getLightBlend(data->m_daynight_ratio));
+ if(nodedef->get(ntop).param_type == CPT_LIGHT)
+ l = decode_light(ntop.getLightBlend(data->m_daynight_ratio, nodedef));
// Otherwise use the light of this node (the liquid)
else
- l = decode_light(n.getLightBlend(data->m_daynight_ratio));
+ l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
video::SColor c = MapBlock_LightColor(
- content_features(n).vertex_alpha, l);
+ nodedef->get(n).vertex_alpha, l);
// Neighbor liquid levels (key = relative position)
// Includes current node
continue;
content_t neighbor_content = neighbor_contents[dir];
+ const ContentFeatures &n_feat = nodedef->get(neighbor_content);
- // Don't draw face if neighbor is not air or liquid
- if(neighbor_content != CONTENT_AIR
- && content_liquid(neighbor_content) == false)
+ // Don't draw face if neighbor is blocking the view
+ if(n_feat.solidness == 2)
continue;
bool neighbor_is_same_liquid = (neighbor_content == c_source
if(neighbor_is_same_liquid == true
&& top_is_same_liquid == false)
continue;
+
+ // Use backface culled material if neighbor doesn't have a
+ // solidness of 0
+ video::SMaterial *current_material = &liquid_material;
+ if(n_feat.solidness != 0 || n_feat.visual_solidness != 0)
+ current_material = &liquid_material_bfculled;
video::S3DVertex vertices[4] =
{
- /*video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
pa_liquid1.x0(), pa_liquid1.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
// Do this to not cause glitches when two liquids are
// side-by-side
- if(neighbor_is_same_liquid == false){
+ /*if(neighbor_is_same_liquid == false){
vertices[j].Pos.X *= 0.98;
vertices[j].Pos.Z *= 0.98;
- }
+ }*/
vertices[j].Pos += intToFloat(p + blockpos_nodes, BS);
}
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
- collector.append(liquid_material, vertices, 4, indices, 6);
+ collector.append(*current_material, vertices, 4, indices, 6);
}
/*
{
video::S3DVertex vertices[4] =
{
- /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
pa_liquid1.x0(), pa_liquid1.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
/*
Add water sources to mesh if using new style
*/
- else if(content_features(n).liquid_type == LIQUID_SOURCE
+ else if(nodedef->get(n).liquid_type == LIQUID_SOURCE
&& new_style_water)
{
- assert(content_features(n).special_material);
+ assert(nodedef->get(n).special_material);
video::SMaterial &liquid_material =
- *content_features(n).special_material;
- assert(content_features(n).special_atlas);
+ *nodedef->get(n).special_material;
+ assert(nodedef->get(n).special_atlas);
AtlasPointer &pa_liquid1 =
- *content_features(n).special_atlas;
+ *nodedef->get(n).special_atlas;
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));
+ u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
video::SColor c = MapBlock_LightColor(
- content_features(n).vertex_alpha, l);
+ nodedef->get(n).vertex_alpha, l);
video::S3DVertex vertices[4] =
{
- /*video::S3DVertex(-BS/2,0,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2,0,-BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2,0,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c, 0,0),*/
video::S3DVertex(-BS/2,0,BS/2, 0,0,0, c,
pa_liquid1.x0(), pa_liquid1.y1()),
video::S3DVertex(BS/2,0,BS/2, 0,0,0, c,
*/
else if(n.getContent() == CONTENT_LEAVES && new_style_leaves)
{
- /*u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));*/
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ /*u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));*/
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
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, 0,1),
- 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, 1,0),
- 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,
pa_leaves1.x0(), pa_leaves1.y1()),
video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
*/
else if(n.getContent() == CONTENT_GLASS)
{
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<6; j++)
*/
else if(n.getContent() == CONTENT_FENCE)
{
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
video::SColor c = MapBlock_LightColor(255, l);
const f32 post_rad=(f32)BS/10;
/*
Add stones with minerals if stone is invisible
*/
- else if(n.getContent() == CONTENT_STONE && invisible_stone && n.getMineral() != MINERAL_NONE)
+ else if(n.getContent() == CONTENT_STONE && invisible_stone && n.getMineral(nodedef) != MINERAL_NONE)
{
for(u32 j=0; j<6; j++)
{
v3s16 dir = g_6dirs[j];
/*u8 l = 0;
MapNode n2 = data->m_vmanip.getNodeNoEx(blockpos_nodes + dir);
- if(content_features(n2).param_type == CPT_LIGHT)
- l = decode_light(n2.getLightBlend(data->m_daynight_ratio));
+ if(nodedef->get(n2).param_type == CPT_LIGHT)
+ l = decode_light(n2.getLightBlend(data->m_daynight_ratio, nodedef));
else
l = 255;*/
u8 l = 255;
video::SColor c = MapBlock_LightColor(255, l);
// Get the right texture
- TileSpec ts = n.getTile(dir);
+ TileSpec ts = n.getTile(dir, tsrc, nodedef);
AtlasPointer ap = ts.texture;
material_general.setTexture(0, ap.atlas);
video::S3DVertex vertices[4] =
{
- /*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, 1,1),
- video::S3DVertex(BS/2,BS/2,BS/2, 0,0,0, c, 1,0),
- 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,
ap.x0(), ap.y1()),
video::S3DVertex(BS/2,-BS/2,BS/2, 0,0,0, c,
#endif
else if(n.getContent() == CONTENT_PAPYRUS)
{
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<4; j++)
}
else if(n.getContent() == CONTENT_JUNGLEGRASS)
{
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<4; j++)
video::S3DVertex vertices[4] =
{
video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c,
- pa_papyrus.x0(), pa_papyrus.y1()),
+ pa_junglegrass.x0(), pa_junglegrass.y1()),
video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c,
- pa_papyrus.x1(), pa_papyrus.y1()),
+ pa_junglegrass.x1(), pa_junglegrass.y1()),
video::S3DVertex(BS/2,BS/1,0, 0,0,0, c,
- pa_papyrus.x1(), pa_papyrus.y0()),
+ pa_junglegrass.x1(), pa_junglegrass.y0()),
video::S3DVertex(-BS/2,BS/1,0, 0,0,0, c,
- pa_papyrus.x0(), pa_papyrus.y0()),
+ pa_junglegrass.x0(), pa_junglegrass.y0()),
};
if(j == 0)
}
else if(n.getContent() == CONTENT_RAIL)
{
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
- video::SColor c = MapBlock_LightColor(255, l);
-
bool is_rail_x [] = { false, false }; /* x-1, x+1 */
bool is_rail_z [] = { false, false }; /* z-1, z+1 */
if(n_plus_z.getContent() == CONTENT_RAIL)
is_rail_z[1] = true;
- float d = (float)BS/16;
- video::S3DVertex vertices[4] =
+ int adjacencies = is_rail_x[0] + is_rail_x[1] + is_rail_z[0] + is_rail_z[1];
+
+ // Assign textures
+ const char *texturename = "rail.png";
+ if(adjacencies < 2)
+ texturename = "rail.png";
+ else if(adjacencies == 2)
{
- 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,-BS/2+d,BS/2, 0,0,0, c,
- 1, 0),
- video::S3DVertex(-BS/2,-BS/2+d,BS/2, 0,0,0, c,
- 0, 0),
- };
+ if((is_rail_x[0] && is_rail_x[1]) || (is_rail_z[0] && is_rail_z[1]))
+ texturename = "rail.png";
+ else
+ texturename = "rail_curved.png";
+ }
+ else if(adjacencies == 3)
+ texturename = "rail_t_junction.png";
+ else if(adjacencies == 4)
+ texturename = "rail_crossing.png";
+
+ AtlasPointer ap = tsrc->getTexture(texturename);
video::SMaterial material_rail;
material_rail.setFlag(video::EMF_LIGHTING, false);
material_rail.setFlag(video::EMF_FOG_ENABLE, true);
material_rail.MaterialType
= video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+ material_rail.setTexture(0, ap.atlas);
- int adjacencies = is_rail_x[0] + is_rail_x[1] + is_rail_z[0] + is_rail_z[1];
+ u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
+ video::SColor c = MapBlock_LightColor(255, l);
- // Assign textures
- if(adjacencies < 2)
- material_rail.setTexture(0, g_texturesource->getTextureRaw("rail.png"));
- else if(adjacencies == 2)
+ float d = (float)BS/16;
+ video::S3DVertex vertices[4] =
{
- if((is_rail_x[0] && is_rail_x[1]) || (is_rail_z[0] && is_rail_z[1]))
- material_rail.setTexture(0, g_texturesource->getTextureRaw("rail.png"));
- else
- material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_curved.png"));
- }
- else if(adjacencies == 3)
- material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_t_junction.png"));
- else if(adjacencies == 4)
- material_rail.setTexture(0, g_texturesource->getTextureRaw("rail_crossing.png"));
+ 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()),
+ };
// Rotate textures
int angle = 0;
collector.append(material_rail, vertices, 4, indices, 6);
}
else if (n.getContent() == CONTENT_LADDER) {
- u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio));
+ AtlasPointer ap = tsrc->getTexture("ladder.png");
+
+ // Set material
+ video::SMaterial material_ladder;
+ material_ladder.setFlag(video::EMF_LIGHTING, false);
+ material_ladder.setFlag(video::EMF_BACK_FACE_CULLING, false);
+ material_ladder.setFlag(video::EMF_BILINEAR_FILTER, false);
+ material_ladder.setFlag(video::EMF_FOG_ENABLE, true);
+ material_ladder.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
+ material_ladder.setTexture(0, ap.atlas);
+
+ u8 l = decode_light(n.getLightBlend(data->m_daynight_ratio, nodedef));
video::SColor c(255,l,l,l);
float d = (float)BS/16;
// Assume wall is at X+
video::S3DVertex vertices[4] =
{
- video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c, 0,1),
- video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c, 1,1),
- video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c, 1,0),
- video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c, 0,0),
+ video::S3DVertex(BS/2-d,-BS/2,-BS/2, 0,0,0, c,
+ ap.x0(), ap.y1()),
+ video::S3DVertex(BS/2-d,-BS/2,BS/2, 0,0,0, c,
+ ap.x1(), ap.y1()),
+ video::S3DVertex(BS/2-d,BS/2,BS/2, 0,0,0, c,
+ ap.x1(), ap.y0()),
+ video::S3DVertex(BS/2-d,BS/2,-BS/2, 0,0,0, c,
+ ap.x0(), ap.y0()),
};
v3s16 dir = unpackDir(n.param2);
vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
}
- video::SMaterial material_ladder;
- material_ladder.setFlag(video::EMF_LIGHTING, false);
- material_ladder.setFlag(video::EMF_BACK_FACE_CULLING, false);
- material_ladder.setFlag(video::EMF_BILINEAR_FILTER, false);
- material_ladder.setFlag(video::EMF_FOG_ENABLE, true);
- material_ladder.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
- material_ladder.setTexture(0, g_texturesource->getTextureRaw("ladder.png"));
-
u16 indices[] = {0,1,2,2,3,0};
// Add to mesh collector
collector.append(material_ladder, vertices, 4, indices, 6);
}
else if(n.getContent() == CONTENT_APPLE)
{
- u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio)));
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
video::SColor c = MapBlock_LightColor(255, l);
for(u32 j=0; j<4; j++)
collector.append(material_apple, vertices, 4, indices, 6);
}
}
+ else if(n.getContent() == CONTENT_SAPLING) {
+ u8 l = decode_light(undiminish_light(n.getLightBlend(data->m_daynight_ratio, nodedef)));
+ video::SColor c = MapBlock_LightColor(255, l);
+
+ for(u32 j=0; j<4; j++)
+ {
+ video::S3DVertex vertices[4] =
+ {
+ video::S3DVertex(-BS/2,-BS/2,0, 0,0,0, c,
+ pa_sapling.x0(), pa_sapling.y1()),
+ video::S3DVertex(BS/2,-BS/2,0, 0,0,0, c,
+ pa_sapling.x1(), pa_sapling.y1()),
+ video::S3DVertex(BS/2,BS/1,0, 0,0,0, c,
+ pa_sapling.x1(), pa_sapling.y0()),
+ video::S3DVertex(-BS/2,BS/1,0, 0,0,0, c,
+ pa_sapling.x0(), pa_sapling.y0()),
+ };
+
+ if(j == 0)
+ {
+ for(u16 i=0; i<4; i++)
+ vertices[i].Pos.rotateXZBy(45);
+ }
+ else if(j == 1)
+ {
+ for(u16 i=0; i<4; i++)
+ vertices[i].Pos.rotateXZBy(-45);
+ }
+ else if(j == 2)
+ {
+ for(u16 i=0; i<4; i++)
+ vertices[i].Pos.rotateXZBy(135);
+ }
+ else if(j == 3)
+ {
+ for(u16 i=0; i<4; i++)
+ vertices[i].Pos.rotateXZBy(-135);
+ }
+
+ for(u16 i=0; i<4; i++)
+ {
+ vertices[i].Pos += intToFloat(p + blockpos_nodes, BS);
+ }
+
+ u16 indices[] = {0,1,2,2,3,0};
+ // Add to mesh collector
+ collector.append(material_sapling, vertices, 4, indices, 6);
+ }
+ }
}
}
#endif
projects / oweals / minetest.git / blobdiff