Add minimap and adjust unlit shader for it

This commit is contained in:
Benau 2017-12-26 14:34:34 +08:00
parent 7797115867
commit daf1294e6f
10 changed files with 213 additions and 69 deletions

View File

@ -1,11 +1,8 @@
#ifdef Use_Bindless_Texture
flat in sampler2D tex_layer_0;
flat in sampler2D tex_layer_2;
#else
// spm layer 1 texture
uniform sampler2D tex_layer_0;
// gloss map
uniform sampler2D tex_layer_2;
#endif
#ifdef Use_Array_Texture
@ -50,17 +47,8 @@ void main(void)
o_diffuse_color = vec4(final_color, 1.0);
#if defined(Advanced_Lighting_Enabled)
#ifdef Use_Array_Texture
vec4 layer_2 = texture(tex_array, vec3(uv, array_2));
#else
vec4 layer_2 = texture(tex_layer_2, uv);
#endif
o_normal_depth.xy = 0.5 * EncodeNormal(normalize(normal)) + 0.5;
o_normal_depth.z = layer_2.x;
o_gloss_map = vec2(0.0);
o_normal_depth.z = 0.0;
o_gloss_map = vec2(0.0, 0.1);
#endif
}

View File

@ -412,7 +412,7 @@ void LightingPasses::renderEnvMap(GLuint normal_depth_texture,
glBlendEquation(GL_FUNC_ADD);
glBlendFunc(GL_ONE, GL_ONE);
if (UserConfigParams::m_degraded_IBL)
if (specular_probe == 0 || UserConfigParams::m_degraded_IBL)
{
DegradedIBLShader::getInstance()->use();
glBindVertexArray(SharedGPUObjects::getFullScreenQuadVAO());

View File

@ -144,8 +144,7 @@ Material* MaterialManager::getMaterialSPM(std::string lay_one_tex_lc,
}
//-----------------------------------------------------------------------------
Material* MaterialManager::getMaterialFor(video::ITexture* t,
const std::string& lay_two_tex_lc)
Material* MaterialManager::getMaterialFor(video::ITexture* t)
{
const io::path& img_path = t->getName().getInternalName();
@ -156,18 +155,7 @@ Material* MaterialManager::getMaterialFor(video::ITexture* t,
{
if (m_materials[i]->getTexFullPath() == img_path.c_str())
{
const std::string& mat_lay_two = m_materials[i]->getUVTwoTexture();
if (mat_lay_two.empty() && lay_two_tex_lc.empty())
{
return m_materials[i];
}
else if (!mat_lay_two.empty() && !lay_two_tex_lc.empty())
{
if (mat_lay_two == lay_two_tex_lc)
{
return m_materials[i];
}
}
return m_materials[i];
}
}
}
@ -180,18 +168,7 @@ Material* MaterialManager::getMaterialFor(video::ITexture* t,
{
if (m_materials[i]->getTexFname() == image.c_str())
{
const std::string& mat_lay_two = m_materials[i]->getUVTwoTexture();
if (mat_lay_two.empty() && lay_two_tex_lc.empty())
{
return m_materials[i];
}
else if (!mat_lay_two.empty() && !lay_two_tex_lc.empty())
{
if (mat_lay_two == lay_two_tex_lc)
{
return m_materials[i];
}
}
return m_materials[i];
}
} // for i
}

View File

@ -62,8 +62,7 @@ public:
scene::IMeshBuffer *mb);
Material* getMaterialFor(video::ITexture* t,
video::E_MATERIAL_TYPE material_type);
Material* getMaterialFor(video::ITexture* t,
const std::string& lay_two_tex_lc = "");
Material* getMaterialFor(video::ITexture* t);
Material* getMaterialSPM(std::string lay_one_tex_lc,
std::string lay_two_tex_lc);
void setAllMaterialFlags(video::ITexture* t,

View File

@ -157,6 +157,8 @@ public:
// ------------------------------------------------------------------------
s32 getJointIDWithArm(const c8* name, unsigned* arm_id) const;
// ------------------------------------------------------------------------
void addSPMeshBuffer(SPMeshBuffer* spmb) { m_buffer.push_back(spmb); }
// ------------------------------------------------------------------------
SPMeshBuffer* getSPMeshBuffer(u32 nr) const;
};

View File

@ -264,6 +264,16 @@ public:
m_vertices.push_back(v);
}
// ------------------------------------------------------------------------
void addIndex(uint16_t idx)
{
m_indices.push_back(idx);
}
// ------------------------------------------------------------------------
void setSPMVertices(std::vector<video::S3DVertexSkinnedMesh>& vertices)
{
m_vertices = std::move(vertices);
}
// ------------------------------------------------------------------------
void setIndices(std::vector<uint16_t>& indices)
{
m_indices = std::move(indices);

View File

@ -19,9 +19,12 @@
#include "tracks/graph.hpp"
#include "config/user_config.hpp"
#include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_target.hpp"
#include "graphics/stk_tex_manager.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/sp/sp_mesh.hpp"
#include "graphics/sp/sp_mesh_buffer.hpp"
#include "modes/profile_world.hpp"
#include "tracks/arena_node_3d.hpp"
#include "tracks/drive_node_2d.hpp"
@ -66,15 +69,32 @@ void Graph::createDebugMesh()
{
if (getNumNodes() <= 0) return; // no debug output if not graph
createMesh(/*show_invisible*/true,
/*enable_transparency*/true);
video::S3DVertex *v = (video::S3DVertex*)m_mesh_buffer->getVertices();
for (unsigned int i = 0; i < m_mesh_buffer->getVertexCount(); i++)
#ifndef SERVER_ONY
if (CVS->isGLSL())
{
// Swap the alpha and back
v[i].Color.setAlpha((i%2) ? 64 : 255);
createMeshSP(/*show_invisible*/true,
/*enable_transparency*/true);
video::S3DVertexSkinnedMesh *v =
(video::S3DVertexSkinnedMesh*)m_mesh_buffer->getVertices();
for (unsigned int i = 0; i < m_mesh_buffer->getVertexCount(); i++)
{
// Swap the alpha and back
v[i].m_color.setAlpha((i%2) ? 64 : 255);
}
}
else
{
createMesh(/*show_invisible*/true,
/*enable_transparency*/true);
video::S3DVertex *v = (video::S3DVertex*)m_mesh_buffer->getVertices();
for (unsigned int i = 0; i < m_mesh_buffer->getVertexCount(); i++)
{
// Swap the alpha and back
v[i].Color.setAlpha((i%2) ? 64 : 255);
}
}
#endif
m_node = irr_driver->addMesh(m_mesh, "track-debug-mesh");
#ifdef DEBUG
m_node->setName("track-debug-mesh");
@ -109,9 +129,6 @@ void Graph::createMesh(bool show_invisible, bool enable_transparency,
m.Lighting = false;
if (enable_transparency)
m.MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL;
m.setTexture(0, STKTexManager::getInstance()->getUnicolorTexture(video::SColor(255, 255, 255, 255)));
m.setTexture(1, STKTexManager::getInstance()->getUnicolorTexture(video::SColor(0, 0, 0, 0)));
m.setTexture(2, STKTexManager::getInstance()->getUnicolorTexture(video::SColor(0, 0, 0, 0)));
m_mesh = irr_driver->createQuadMesh(&m);
m_mesh_buffer = m_mesh->getMeshBuffer(0);
assert(m_mesh_buffer->getVertexType()==video::EVT_STANDARD);
@ -206,18 +223,7 @@ void Graph::createMesh(bool show_invisible, bool enable_transparency,
// i.e. part of the lap line might not be visible.
for (unsigned int i = 0; i < 4; i++)
lap_v[i].Pos.Y += 0.1f;
#ifndef USE_TEXTURED_LINE
m_mesh_buffer->append(lap_v, 4, lap_ind, 6);
#else
lap_v[0].TCoords = core::vector2df(0,0);
lap_v[1].TCoords = core::vector2df(3,0);
lap_v[2].TCoords = core::vector2df(3,1);
lap_v[3].TCoords = core::vector2df(0,1);
m_mesh_buffer->append(lap_v, 4, lap_ind, 6);
video::SMaterial &m = m_mesh_buffer->getMaterial();
video::ITexture *t = irr_driver->getTexture("chess.png");
m.setTexture(0, t);
#endif
}
// Instead of setting the bounding boxes, we could just disable culling,
@ -234,6 +240,121 @@ void Graph::createMesh(bool show_invisible, bool enable_transparency,
#endif
} // createMesh
// -----------------------------------------------------------------------------
/** Creates the actual mesh that is used by createDebugMesh() or makeMiniMap()
*/
void Graph::createMeshSP(bool show_invisible, bool enable_transparency,
const video::SColor *track_color)
{
#ifndef SERVER_ONLY
SP::SPMesh* spm = new SP::SPMesh();
SP::SPMeshBuffer* spmb = new SP::SPMeshBuffer(true/*vertex_color*/);
m_mesh = spm;
m_mesh_buffer = spmb;
unsigned int n = 0;
const unsigned int total_nodes = getNumNodes();
// Count the number of quads to display (some quads might be invisible)
for (unsigned int i = 0; i < total_nodes; i++)
{
if (show_invisible || !m_all_nodes[i]->isInvisible())
n++;
}
// Four vertices for each of the n-1 remaining quads
std::vector<video::S3DVertexSkinnedMesh> vertices;
vertices.resize(4 * n);
// Each quad consists of 2 triangles with 3 elements, so
// we need 2*3 indices for each quad.
std::vector<uint16_t> indices;
indices.resize(6 * n);
video::SColor c(255, 255, 0, 0);
if (track_color)
c = *track_color;
// Now add all quads
int i = 0;
for (unsigned int count = 0; count < total_nodes; count++)
{
// Ignore invisible quads
if (!show_invisible && m_all_nodes[count]->isInvisible())
continue;
// Swap the colours from red to blue and back
if (!track_color)
{
c.setRed ((i % 2) ? 255 : 0);
c.setBlue((i % 2) ? 0 : 255);
}
video::SColor this_color = c;
differentNodeColor(count, &this_color);
// Transfer the 4 points of the current quad to the list of vertices
m_all_nodes[count]->getSPMVertices(vertices.data() + (4 * i), this_color);
// Set up the indices for the triangles
indices[6 * i] = 4 * i + 2; // First triangle: vertex 0, 1, 2
indices[6 * i + 1] = 4 * i + 1;
indices[6 * i + 2] = 4 * i;
indices[6 * i + 3] = 4 * i + 3; // second triangle: vertex 0, 1, 3
indices[6 * i + 4] = 4 * i + 2;
indices[6 * i + 5] = 4 * i;
i++;
}
if (hasLapLine())
{
video::S3DVertexSkinnedMesh lap_v[4];
uint16_t lap_ind[6];
video::SColor lap_color(128, 255, 0, 0);
m_all_nodes[0]->getSPMVertices(lap_v, lap_color);
// Now scale the length (distance between vertix 0 and 3
// and between 1 and 2) to be 'length':
// Length of the lap line about 3% of the 'height'
// of the track.
const float length = (m_bb_max.getZ() - m_bb_min.getZ()) * 0.03f;
core::vector3df dl = lap_v[3].m_position-lap_v[0].m_position;
float ll2 = dl.getLengthSQ();
if (ll2 < 0.001)
lap_v[3].m_position = lap_v[0].m_position + core::vector3df(0, 0, 1);
else
lap_v[3].m_position = lap_v[0].m_position + dl * length / sqrt(ll2);
core::vector3df dr = lap_v[2].m_position - lap_v[1].m_position;
float lr2 = dr.getLengthSQ();
if (lr2 < 0.001)
lap_v[2].m_position = lap_v[1].m_position + core::vector3df(0, 0, 1);
else
lap_v[2].m_position = lap_v[1].m_position + dr * length / sqrt(lr2);
lap_ind[0] = 4 * n + 2;
lap_ind[1] = 4 * n + 1;
lap_ind[2] = 4 * n;
lap_ind[3] = 4 * n + 3;
lap_ind[4] = 4 * n + 2;
lap_ind[5] = 4 * n;
// Set it a bit higher to avoid issued with z fighting,
// i.e. part of the lap line might not be visible.
for (unsigned int i = 0; i < 4; i++)
lap_v[i].m_position.Y += 0.1f;
std::copy(lap_v, lap_v + 4, std::back_inserter(vertices));
std::copy(lap_ind, lap_ind +6, std::back_inserter(indices));
}
spmb->setSPMVertices(vertices);
spmb->setIndices(indices);
spmb->recalculateBoundingBox();
spmb->setSTKMaterial(material_manager->getSPMaterial(
enable_transparency ? "alphablend" : "unlit"));
spm->addSPMeshBuffer(spmb);
spm->setBoundingBox(spmb->getBoundingBox());
#endif
} // createMeshSP
// -----------------------------------------------------------------------------
/** Takes a snapshot of the graph so they can be used as minimap.
*/
@ -253,9 +374,20 @@ RenderTarget* Graph::makeMiniMap(const core::dimension2du &dimension,
irr_driver->getSceneManager()
->setAmbientLight(video::SColor(255, 255, 255, 255));
createMesh(/*show_invisible part of the track*/ false,
/*enable_transparency*/ false,
/*track_color*/ &fill_color);
#ifndef SERVER_ONY
if (CVS->isGLSL())
{
createMeshSP(/*show_invisible part of the track*/ false,
/*enable_transparency*/ false,
/*track_color*/ &fill_color);
}
else
{
createMesh(/*show_invisible part of the track*/ false,
/*enable_transparency*/ false,
/*track_color*/ &fill_color);
}
#endif
m_node = irr_driver->addMesh(m_mesh, "mini_map");
#ifdef DEBUG

View File

@ -95,6 +95,10 @@ private:
bool enable_transparency=false,
const video::SColor *track_color=NULL);
// ------------------------------------------------------------------------
void createMeshSP(bool show_invisible=true,
bool enable_transparency=false,
const video::SColor *track_color=NULL);
// ------------------------------------------------------------------------
void cleanupDebugMesh();
// ------------------------------------------------------------------------
virtual bool hasLapLine() const = 0;

View File

@ -18,6 +18,7 @@
#include "tracks/quad.hpp"
#include "tracks/graph.hpp"
#include "utils/mini_glm.hpp"
#include "utils/log.hpp"
#include <algorithm>
@ -68,6 +69,34 @@ void Quad::getVertices(video::S3DVertex *v, const video::SColor &color) const
v[3].Color = color;
} // setVertices
// ----------------------------------------------------------------------------
/** Sets the vertices in an spm vertex array to the 4 points of this quad.
* \param v The vertex array in which to set the vertices.
* \param color The color to use for this quad.
*/
void Quad::getSPMVertices(video::S3DVertexSkinnedMesh *v,
const video::SColor &color) const
{
// Eps is used to raise the track debug quads a little bit higher than
// the ground, so that they are actually visible.
core::vector3df normal = getNormal().toIrrVector();
core::vector3df eps = normal * 0.1f;
v[0].m_position = m_p[0].toIrrVector()+eps;
v[1].m_position = m_p[1].toIrrVector()+eps;
v[2].m_position = m_p[2].toIrrVector()+eps;
v[3].m_position = m_p[3].toIrrVector()+eps;
v[0].m_normal = MiniGLM::compressVector3(normal);
v[1].m_normal = MiniGLM::compressVector3(normal);
v[2].m_normal = MiniGLM::compressVector3(normal);
v[3].m_normal = MiniGLM::compressVector3(normal);
v[0].m_color = color;
v[1].m_color = color;
v[2].m_color = color;
v[3].m_color = color;
} // setVertices
// ----------------------------------------------------------------------------
bool Quad::pointInside(const Vec3& p, bool ignore_vertical) const
{

View File

@ -27,7 +27,7 @@
namespace irr
{
namespace video { struct S3DVertex; }
namespace video { struct S3DVertex; struct S3DVertexSkinnedMesh; }
}
using namespace irr;
@ -75,6 +75,9 @@ public:
// ------------------------------------------------------------------------
void getVertices(video::S3DVertex *v, const video::SColor &color) const;
// ------------------------------------------------------------------------
void getSPMVertices(video::S3DVertexSkinnedMesh *v,
const video::SColor &color) const;
// ------------------------------------------------------------------------
/** Returns the i-th. point of a quad. */
const Vec3& operator[](int i) const { return m_p[i]; }
// ------------------------------------------------------------------------