ilikecats/stk-code_catmod
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove unused entries in materials and fog settings

Browse Source
This commit is contained in:
Benau 2018-01-15 13:23:21 +08:00
parent 681ef66d8d
commit a3a00f70f8
12 changed files with 9 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
src/graphics/lod_node.cpp
View File

@ -20,8 +20,6 @@
#include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/lod_node.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/material.hpp"
#include "config/user_config.hpp"
#include "karts/abstract_kart.hpp"
@ -196,19 +194,6 @@ void LODNode::OnRegisterSceneNode()
assert(node != NULL);
mesh = node->getMesh();
}
for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
{
scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
video::ITexture* t = mb->getMaterial().getTexture(0);
if (t == NULL) continue;
Material* m = material_manager->getMaterialFor(t, mb);
if (m != NULL)
{
m->onMadeVisible(mb);
}
}
}
else if (m_previous_visibility == WAS_SHOWN && !shown)
{
@ -228,17 +213,6 @@ void LODNode::OnRegisterSceneNode()
mesh = node->getMesh();
}
for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
{
scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
video::ITexture* t = mb->getMaterial().getTexture(0);
if (t == NULL) continue;
Material* m = material_manager->getMaterialFor(t, mb);
if (m != NULL)
{
m->onHidden(mb);
}
}
}
else if (m_previous_visibility == FIRST_PASS && !shown)
{
@ -257,18 +231,6 @@ void LODNode::OnRegisterSceneNode()
assert(node != NULL);
mesh = node->getMesh();
}
for (unsigned int n=0; n<mesh->getMeshBufferCount(); n++)
{
scene::IMeshBuffer* mb = mesh->getMeshBuffer(n);
video::ITexture* t = mb->getMaterial().getTexture(0);
if(!t) continue;
Material* m = material_manager->getMaterialFor(t, mb);
if (m != NULL)
{
m->isInitiallyHidden(mb);
}
}
}
}

120
src/graphics/material.cpp
View File

@ -154,12 +154,9 @@ Material::Material(const XMLNode *node, bool deprecated)
node->get("max-speed", &m_max_speed_fraction );
node->get("slowdown-time", &m_slowdown_time );
node->get("backface-culling", &m_backface_culling );
node->get("disable-z-write", &m_disable_z_write );
node->get("colorizable", &m_colorizable );
node->get("colorization-factor", &m_colorization_factor);
node->get("hue-settings", &m_hue_settings );
node->get("fog", &m_fog );
node->get("mask", &m_mask );
node->get("colorization-mask", &m_colorization_mask );
@ -451,12 +448,6 @@ Material::Material(const XMLNode *node, bool deprecated)
texfname.make_lower();
m_texname = texfname.c_str();
if (m_disable_z_write && m_shader_type != SHADERTYPE_ALPHA_BLEND && m_shader_type != SHADERTYPE_ADDITIVE)
{
Log::debug("material", "Disabling writes to z buffer only makes sense when compositing is blending or additive (for %s)", m_texname.c_str());
m_disable_z_write = false;
}
// Terrain-specifc sound effect
const unsigned int children_count = node->getNumNodes();
for (unsigned int i=0; i<children_count; i++)
@ -588,7 +579,6 @@ void Material::init()
m_texture = NULL;
m_clamp_tex = 0;
m_shader_type = SHADERTYPE_SOLID;
m_backface_culling = true;
m_high_tire_adhesion = false;
m_below_surface = false;
m_falling_effect = false;
@ -597,11 +587,9 @@ void Material::init()
m_drive_reset = false;
m_mirror_axis_when_reverse = ' ';
m_collision_reaction = NORMAL;
m_disable_z_write = false;
m_colorizable = false;
m_colorization_factor = 0.0f;
m_colorization_mask = "";
m_fog = true;
m_max_speed_fraction = 1.0f;
m_slowdown_time = 1.0f;
m_sfx_name = "";
@ -878,10 +866,8 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
m_texname.c_str());
}
// Backface culling
if(!m_backface_culling)
m->setFlag(video::EMF_BACK_FACE_CULLING, false);
// Default solid
m->MaterialType = video::EMT_SOLID;
if (race_manager->getReverseTrack() &&
m_mirror_axis_when_reverse != ' ')
{
@ -900,20 +886,18 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
}
} // reverse track and texture needs mirroring
if (m_shader_type == SHADERTYPE_SOLID_UNLIT)
if (m_shader_name == "unlit")
{
m->AmbientColor = video::SColor(255, 255, 255, 255);
m->DiffuseColor = video::SColor(255, 255, 255, 255);
m->EmissiveColor = video::SColor(255, 255, 255, 255);
m->SpecularColor = video::SColor(255, 255, 255, 255);
}
if (m_shader_type == SHADERTYPE_ALPHA_TEST)
else if (m_shader_name == "alphatest")
{
m->MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
}
if (m_shader_type == SHADERTYPE_ALPHA_BLEND)
else if (m_shader_name == "alphablend")
{
// EMT_TRANSPARENT_ALPHA_CHANNEL doesn't include vertex color alpha into
// account, which messes up fading in/out effects. So we use the more
@ -925,8 +909,7 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
video::EMFN_MODULATE_1X,
video::EAS_TEXTURE | video::EAS_VERTEX_COLOR);
}
if (m_shader_type == SHADERTYPE_ADDITIVE)
else if (m_shader_name == "additive")
{
// EMT_TRANSPARENT_ADD_COLOR doesn't include vertex color alpha into
// account, which messes up fading in/out effects. So we use the
@ -938,31 +921,7 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
video::EAS_TEXTURE |
video::EAS_VERTEX_COLOR);
}
if (m_shader_type == SHADERTYPE_SPHERE_MAP)
{
m->MaterialType = video::EMT_SPHERE_MAP;
}
if (m_shader_type == SHADERTYPE_SPLATTING)
{
m->MaterialType = video::EMT_SOLID;
}
// Modify lightmap materials so that vertex colors are taken into account.
// But disable lighting because we assume all lighting is already part
// of the lightmap
if (m->MaterialType == video::EMT_LIGHTMAP)
{
m->MaterialType = video::EMT_LIGHTMAP_LIGHTING;
m->AmbientColor = video::SColor(255, 255, 255, 255);
m->DiffuseColor = video::SColor(255, 255, 255, 255);
m->EmissiveColor = video::SColor(255, 255, 255, 255);
m->SpecularColor = video::SColor(255, 255, 255, 255);
}
if (m_shader_type == SHADERTYPE_VEGETATION)
else if (m_shader_name == "grass")
{
m->MaterialType = video::EMT_TRANSPARENT_ALPHA_CHANNEL_REF;
@ -979,7 +938,7 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
#endif
}
if (m_disable_z_write)
if (m_shader_name == "alphablend" || m_shader_name == "additive")
{
m->ZWriteEnable = false;
}
@ -1039,66 +998,3 @@ void Material::setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* m
#endif
} // setMaterialProperties
//-----------------------------------------------------------------------------
void Material::adjustForFog(scene::ISceneNode* parent, video::SMaterial *m,
bool use_fog) const
{
#ifndef SERVER_ONLY
if (CVS->isGLSL())
{
// to disable fog in the new pipeline, we slightly abuse the steps :
// moving an object into the transparent pass will make it rendered
// above fog and thus unaffected by it
if (use_fog && !m_fog && m_shader_type != SHADERTYPE_ALPHA_BLEND && m_shader_type != SHADERTYPE_ADDITIVE)
{
//m->ZWriteEnable = true;
//m->MaterialType = video::EMT_ONETEXTURE_BLEND;
//m->MaterialTypeParam =
// pack_textureBlendFunc(video::EBF_SRC_ALPHA,
// video::EBF_ONE_MINUS_SRC_ALPHA,
// video::EMFN_MODULATE_1X,
// video::EAS_TEXTURE | video::EAS_VERTEX_COLOR);
}
}
else
{
m->setFlag(video::EMF_FOG_ENABLE, m_fog && use_fog);
if (parent != NULL)
parent->setMaterialFlag(video::EMF_FOG_ENABLE, m_fog && use_fog);
}
#endif
} // adjustForFog
//-----------------------------------------------------------------------------
/** Callback from LOD nodes to create some effects */
void Material::onMadeVisible(scene::IMeshBuffer* who)
{
#ifndef SERVER_ONLY
if (!CVS->isGLSL()) return;
#endif
}
//-----------------------------------------------------------------------------
/** Callback from LOD nodes to create some effects */
void Material::onHidden(scene::IMeshBuffer* who)
{
#ifndef SERVER_ONLY
if (!CVS->isGLSL()) return;
#endif
}
//-----------------------------------------------------------------------------
void Material::isInitiallyHidden(scene::IMeshBuffer* who)
{
#ifndef SERVER_ONLY
if (!CVS->isGLSL()) return;
#endif
}
//-----------------------------------------------------------------------------

20
src/graphics/material.hpp
View File

@ -135,14 +135,6 @@ private:
* plants that a kart can just drive through. */
bool m_ignore;
bool m_fog;
/** True if backface culliing should be enabled. */
bool m_backface_culling;
/** Set to true to disable writing to the Z buffer. Usually to be used with alpha blending */
bool m_disable_z_write;
/** True if the material shouldn't be "slippy" at an angle */
bool m_high_tire_adhesion;
@ -250,11 +242,6 @@ public:
void setSFXSpeed(SFXBase *sfx, float speed, bool should_be_paused) const;
void setMaterialProperties(video::SMaterial *m, scene::IMeshBuffer* mb);
void adjustForFog(scene::ISceneNode* parent, video::SMaterial *m,
bool use_fog) const;
void onMadeVisible(scene::IMeshBuffer* who);
void onHidden(scene::IMeshBuffer* who);
void isInitiallyHidden(scene::IMeshBuffer* who);
/** Returns the ITexture associated with this material. */
video::ITexture *getTexture(bool srgb = true, bool premul_alpha = false);
@ -334,11 +321,6 @@ public:
/** Returns the name of a special sfx to play while a kart is on this
* terrain. The string will be "" if no special sfx exists. */
const std::string &getSFXName() const { return m_sfx_name; }
// ------------------------------------------------------------------------
/** Returns if fog is enabled. */
bool isFogEnabled() const { return m_fog; }
// ------------------------------------------------------------------------
/** \brief Get the kind of particles that are to be used on this material,
* in the given conditions.
@ -397,8 +379,6 @@ public:
const std::string& getUVTwoTexture() const
{ return m_uv_two_tex; }
// ------------------------------------------------------------------------
bool backFaceCulling() const { return m_backface_culling; }
// ------------------------------------------------------------------------
bool use2UV() const { return !m_uv_two_tex.empty(); }
// ------------------------------------------------------------------------
const std::string& getSamplerPath(unsigned layer) const

22
src/graphics/material_manager.cpp
View File

@ -220,28 +220,7 @@ Material* MaterialManager::getDefaultSPMaterial(const std::string& shader_name,
return m;
} // getDefaultSPMaterial
//-----------------------------------------------------------------------------
void MaterialManager::adjustForFog(video::ITexture* t,
scene::IMeshBuffer *mb,
scene::ISceneNode* parent,
bool use_fog) const
{
const std::string image = StringUtils::getBasename(core::stringc(t->getName()).c_str());
// Search backward so that temporary (track) textures are found first
for(int i = (int)m_materials.size()-1; i>=0; i-- )
{
if (m_materials[i]->getTexFname()==image)
{
m_materials[i]->adjustForFog(parent, &(mb->getMaterial()), use_fog);
return;
}
} // for i
} // adjustForFog
//-----------------------------------------------------------------------------
void MaterialManager::setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb)
{
irr::video::SMaterial& material = mb->getMaterial();
@ -257,6 +236,7 @@ void MaterialManager::setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb)
}
}
//-----------------------------------------------------------------------------
int MaterialManager::addEntity(Material *m)
{

5
src/graphics/material_manager.hpp
View File

@ -66,11 +66,6 @@ public:
const std::string& def_shader_name = "solid");
void setAllMaterialFlags(video::ITexture* t,
scene::IMeshBuffer *mb);
void adjustForFog(video::ITexture* t,
scene::IMeshBuffer *mb,
scene::ISceneNode* parent,
bool use_fog) const;
void setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb);
int addEntity (Material *m);

4
src/items/item.cpp
View File

@ -78,7 +78,6 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
debug_name += m_type;
m_node->setName(debug_name.c_str());
#endif
Track::getCurrentTrack()->adjustForFog(m_node);
m_node->setAutomaticCulling(scene::EAC_FRUSTUM_BOX);
m_node->setPosition(xyz.toIrrVector());
Vec3 hpr;
@ -192,8 +191,6 @@ void Item::switchTo(ItemType type, scene::IMesh *mesh, scene::IMesh *lowmesh)
m_original_type = m_type;
setMesh(mesh, lowmesh);
setType(type);
Track::getCurrentTrack()->adjustForFog(m_node);
} // switchTo
//-----------------------------------------------------------------------------
@ -214,7 +211,6 @@ void Item::switchBack()
setType(m_original_type);
m_original_type = ITEM_NONE;
Track::getCurrentTrack()->adjustForFog(m_node);
Vec3 hpr;
hpr.setHPR(m_original_rotation);
m_node->setRotation(hpr.toIrrHPR());

1
src/modes/three_strikes_battle.cpp
View File

@ -730,7 +730,6 @@ void ThreeStrikesBattle::loadCustomModels()
m_karts.push_back(sta);
race_manager->addSpareTireKart(sta_list[i]);
Track::getCurrentTrack()->adjustForFog(sta->getNode());
// Copy STA pointer to m_spare_tire_karts array, allowing them
// to respawn easily

1
src/modes/world.cpp
View File

@ -215,7 +215,6 @@ void World::init()
race_manager->getKartType(i),
race_manager->getPlayerDifficulty(i));
m_karts.push_back(newkart);
track->adjustForFog(newkart->getNode());
} // for i

78
src/tracks/track.cpp
View File

@ -1182,7 +1182,6 @@ bool Track::loadMainTrack(const XMLNode &root)
merged_mesh->finalize();
#ifndef SERVER_ONLY
tangent_mesh = merged_mesh;
adjustForFog(tangent_mesh, NULL);
#else
tangent_mesh = merged_mesh;
#endif
@ -1932,14 +1931,6 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
}
#endif
// Enable for for all track nodes if fog is used
const unsigned int count = (int)m_all_nodes.size();
for(unsigned int i=0; i<count; i++)
{
adjustForFog(m_all_nodes[i]);
}
m_track_object_manager->enableFog(m_use_fog);
// Sky dome and boxes support
// --------------------------
irr_driver->suppressSkyBox();
@ -2231,75 +2222,6 @@ void Track::loadObjects(const XMLNode* root, const std::string& path, ModelDefin
} // for i<root->getNumNodes()
}
//-----------------------------------------------------------------------------
/** Changes all materials of the given mesh to use the current fog
* setting (true/false).
* \param node Scene node for which fog should be en/dis-abled.
*/
void Track::adjustForFog(scene::IMesh* mesh, scene::ISceneNode* parent_scene_node)
{
#ifndef SERVER_ONLY
if (CVS->isGLSL())
{
return;
}
#endif
unsigned int n = mesh->getMeshBufferCount();
for (unsigned int i=0; i<n; i++)
{
scene::IMeshBuffer *mb = mesh->getMeshBuffer(i);
video::SMaterial &irr_material=mb->getMaterial();
for (unsigned int j=0; j<video::MATERIAL_MAX_TEXTURES; j++)
{
video::ITexture* t = irr_material.getTexture(j);
if (t) material_manager->adjustForFog(t, mb, parent_scene_node, m_use_fog);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
//-----------------------------------------------------------------------------
/** Changes all materials of the given scene node to use the current fog
* setting (true/false).
* \param node Scene node for which fog should be en/dis-abled.
*/
void Track::adjustForFog(scene::ISceneNode *node)
{
//irr_driver->setAllMaterialFlags(scene::IMesh *mesh)
if (node->getType() == scene::ESNT_OCTREE)
{
// do nothing
}
else if (node->getType() == scene::ESNT_MESH)
{
scene::IMeshSceneNode* mnode = (scene::IMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
adjustForFog(mesh, mnode);
}
else if (node->getType() == scene::ESNT_ANIMATED_MESH)
{
scene::IAnimatedMeshSceneNode* mnode = (scene::IAnimatedMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
adjustForFog(mesh, mnode);
}
else
{
node->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
}
if (node->getType() == scene::ESNT_LOD_NODE)
{
std::vector<scene::ISceneNode*>& subnodes = ((LODNode*)node)->getAllNodes();
for (unsigned int n=0; n<subnodes.size(); n++)
{
adjustForFog(subnodes[n]);
//subnodes[n]->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
}
}
} // adjustForFog
//-----------------------------------------------------------------------------
/** Handles a sky-dome or sky-box. It takes the xml node with the
* corresponding data for the sky and stores the corresponding data in

3
src/tracks/track.hpp
View File

@ -420,9 +420,6 @@ public:
void createPhysicsModel(unsigned int main_track_count);
void update(float dt);
void reset();
void adjustForFog(scene::ISceneNode *node);
void adjustForFog(scene::IMesh* mesh,
scene::ISceneNode* parent_scene_node);
void itemCommand(const XMLNode *node);
core::stringw getName() const;
core::stringw getSortName() const;

71
src/tracks/track_object_manager.cpp
View File

@ -210,73 +210,6 @@ void TrackObjectManager::castRay(const btVector3 &from,
} // castRay
// ----------------------------------------------------------------------------
/** Enables or disables fog for a given scene node.
* \param node The node to adjust.
* \param enable True if fog is enabled, otherwise fog is disabled.
*/
void adjustForFog(scene::ISceneNode *node, bool enable)
{
if (node->getType() == scene::ESNT_MESH ||
node->getType() == scene::ESNT_OCTREE ||
node->getType() == scene::ESNT_ANIMATED_MESH)
{
scene::IMesh* mesh;
if (node->getType() == scene::ESNT_ANIMATED_MESH) {
mesh = ((scene::IAnimatedMeshSceneNode*)node)->getMesh();
}
else {
mesh = ((scene::IMeshSceneNode*)node)->getMesh();
}
unsigned int n = mesh->getMeshBufferCount();
for (unsigned int i=0; i<n; i++)
{
scene::IMeshBuffer *mb = mesh->getMeshBuffer(i);
video::SMaterial &irr_material=mb->getMaterial();
for (unsigned int j=0; j<video::MATERIAL_MAX_TEXTURES; j++)
{
video::ITexture* t = irr_material.getTexture(j);
if (t) material_manager->adjustForFog(t, mb, node, enable);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
else
{
node->setMaterialFlag(video::EMF_FOG_ENABLE, enable);
}
if (node->getType() == scene::ESNT_LOD_NODE)
{
std::vector<scene::ISceneNode*>&
subnodes = ((LODNode*)node)->getAllNodes();
for (unsigned int n=0; n<subnodes.size(); n++)
{
adjustForFog(subnodes[n], enable);
}
}
} // adjustForFog
// ----------------------------------------------------------------------------
/** Enable or disable fog on objects.
*/
void TrackObjectManager::enableFog(bool enable)
{
TrackObject* curr;
for_in (curr, m_all_objects)
{
TrackObjectPresentationMesh* meshPresentation =
curr->getPresentation<TrackObjectPresentationMesh>();
if (meshPresentation!= NULL)
{
adjustForFog(meshPresentation->getNode(), enable);
}
}
} // enableFog
// ----------------------------------------------------------------------------
void TrackObjectManager::insertObject(TrackObject* object)
{
m_all_objects.push_back(object);
@ -292,7 +225,3 @@ void TrackObjectManager::removeObject(TrackObject* obj)
m_all_objects.remove(obj);
delete obj;
} // removeObject
// ----------------------------------------------------------------------------

3
src/tracks/track_object_manager.hpp
View File

@ -67,9 +67,6 @@ public:
const Material **material, btVector3 *normal = NULL,
bool interpolate_normal = false) const;
/** Enable or disable fog on objects */
void enableFog(bool enable);
void insertObject(TrackObject* object);
void removeObject(TrackObject* who);