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

Try to add support for having dsome materials ignore fog. Works for lighthouse light, but not for lighthouse sky

Browse Source 
git-svn-id: svn+ssh://svn.code.sf.net/p/supertuxkart/code/main/trunk@8866 178a84e3-b1eb-0310-8ba1-8eac791a3b58
This commit is contained in:
auria
2011-06-09 01:29:25 +00:00
parent be5e9735b8
commit 23711c7174
6 changed files with 167 additions and 19 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/graphics/material.cpp
View File

@@ -90,7 +90,8 @@ Material::Material(const XMLNode *node, int index)
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("fog", &m_fog );
node->get("mask", &m_mask);
if (node->get("normal-map", &m_normal_map_tex))
@@ -224,6 +225,7 @@ void Material::init(unsigned int index)
m_crash_reset = false;
m_add = false;
m_disable_z_write = false;
m_fog = true;
m_max_speed_fraction = 1.0f;
m_slowdown_time = 1.0f;
m_sfx_name = "";
@@ -586,5 +588,13 @@ void Material::setMaterialProperties(video::SMaterial *m) const
if (UserConfigParams::m_fullscreen_antialiasing)
m->AntiAliasing = video::EAAM_LINE_SMOOTH;
} // setMaterialProperties
} // setMaterialProperties
//-----------------------------------------------------------------------------
void Material::adjustForFog(scene::ISceneNode* parent, video::SMaterial *m, bool use_fog) const
{
printf("<%s> Fog enable : %i\n", m_texname.c_str(), m_fog);
m->setFlag(video::EMF_FOG_ENABLE, m_fog && use_fog);
parent->setMaterialFlag(video::EMF_FOG_ENABLE, m_fog && use_fog);
}

7
src/graphics/material.hpp
View File

@@ -27,6 +27,7 @@
namespace irr
{
namespace video { class ITexture; class SMaterial; }
namespace scene { class ISceneNode; }
}
using namespace irr;
@@ -84,6 +85,8 @@ private:
bool m_ignore;
bool m_add;
bool m_fog;
ParticleKind* m_particles_effects[EMIT_KINDS_COUNT];
/** For normal maps */
@@ -159,6 +162,8 @@ public:
void setSFXSpeed(SFXBase *sfx, float speed) const;
void setMaterialProperties(video::SMaterial *m) const;
void adjustForFog(scene::ISceneNode* parent, video::SMaterial *m, bool use_fog) const;
/** Returns the ITexture associated with this material. */
video::ITexture *getTexture() const { return m_texture; }
bool isIgnore () const { return m_ignore; }
@@ -212,6 +217,8 @@ public:
const std::string &
getSFXName () const { return m_sfx_name; }
bool isFogEnabled() const { return m_fog; }
/**
* \brief Get the kind of particles that are to be used on this material, in the given conditions
* \return The particles to use, or NULL if none

21
src/graphics/material_manager.cpp
View File

@@ -89,7 +89,28 @@ void MaterialManager::setAllMaterialFlags(video::ITexture* t,
}
} // setAllMaterialFlags
//-----------------------------------------------------------------------------
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) const
{
for(int i = (int)m_materials.size()-1; i>=0; i-- )

6
src/graphics/material_manager.hpp
View File

@@ -25,7 +25,7 @@
namespace irr
{
namespace video { class ITexture; }
namespace scene { class IMeshBuffer; }
namespace scene { class IMeshBuffer; class ISceneNode; }
}
using namespace irr;
@@ -52,6 +52,10 @@ public:
void loadMaterial ();
void setAllMaterialFlags(video::ITexture* t,
scene::IMeshBuffer *mb) const;
void adjustForFog(video::ITexture* t,
scene::IMeshBuffer *mb,
scene::ISceneNode* parent,
bool use_fog) const;
void setAllUntexturedMaterialFlags(scene::IMeshBuffer *mb) const;

57
src/tracks/track.cpp
View File

@@ -1281,14 +1281,14 @@ void Track::loadTrackModel(World* parent, unsigned int mode_id)
}
// Enable for for all track nodes if fog is used
if(m_use_fog)
{
//if(m_use_fog)
//{
const unsigned int count = 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
@@ -1377,14 +1377,61 @@ void Track::loadTrackModel(World* parent, unsigned int mode_id)
*/
void Track::adjustForFog(scene::ISceneNode *node)
{
node->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
//irr_driver->setAllMaterialFlags(scene::IMesh *mesh)
if (node->getType() == scene::ESNT_MESH || node->getType() == scene::ESNT_OCTREE)
{
scene::IMeshSceneNode* mnode = (scene::IMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
//irr_driver->setAllMaterialFlags(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, mnode, m_use_fog);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
else if (node->getType() == scene::ESNT_ANIMATED_MESH)
{
scene::IAnimatedMeshSceneNode* mnode = (scene::IAnimatedMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
//irr_driver->setAllMaterialFlags(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, mnode, m_use_fog);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
else
{
unsigned int t = node->getType();
const char* type = (const char*)&t;
printf("Unknown mesh type %c%c%c%c\n", type[0], type[1], type[2], type[3]);
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++)
{
subnodes[n]->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
adjustForFog(subnodes[n]);
//subnodes[n]->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
}
}
} // adjustForFog

79
src/tracks/track_object_manager.cpp
View File

@@ -23,10 +23,13 @@
#include "animations/billboard_animation.hpp"
#include "animations/three_d_animation.hpp"
#include "graphics/lod_node.hpp"
#include "graphics/material_manager.hpp"
#include "io/xml_node.hpp"
#include "physics/physical_object.hpp"
#include "tracks/track_object.hpp"
#include <IMeshSceneNode.h>
TrackObjectManager::TrackObjectManager()
{
} // TrackObjectManager
@@ -116,6 +119,69 @@ void TrackObjectManager::update(float dt)
}
} // update
void adjustForFog(scene::ISceneNode *node, bool enable)
{
//irr_driver->setAllMaterialFlags(scene::IMesh *mesh)
if (node->getType() == scene::ESNT_MESH || node->getType() == scene::ESNT_OCTREE)
{
scene::IMeshSceneNode* mnode = (scene::IMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
//irr_driver->setAllMaterialFlags(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, mnode, enable);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
else if (node->getType() == scene::ESNT_ANIMATED_MESH)
{
scene::IAnimatedMeshSceneNode* mnode = (scene::IAnimatedMeshSceneNode*)node;
scene::IMesh* mesh = mnode->getMesh();
//irr_driver->setAllMaterialFlags(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, mnode, enable);
} // for j<MATERIAL_MAX_TEXTURES
} // for i<getMeshBufferCount()
}
else
{
unsigned int t = node->getType();
const char* type = (const char*)&t;
printf("Unknown mesh type %c%c%c%c\n", type[0], type[1], type[2], type[3]);
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);
//subnodes[n]->setMaterialFlag(video::EMF_FOG_ENABLE, m_use_fog);
}
}
} // adjustForFog
// ----------------------------------------------------------------------------
void TrackObjectManager::enableFog(bool enable)
@@ -123,15 +189,8 @@ void TrackObjectManager::enableFog(bool enable)
TrackObject* curr;
for_in (curr, m_all_objects)
{
curr->getNode()->setMaterialFlag(video::EMF_FOG_ENABLE, enable);
if (curr->getNode()->getType() == scene::ESNT_LOD_NODE)
{
std::vector<scene::ISceneNode*>& nodes = ((LODNode*)curr->getNode())->getAllNodes();
for (unsigned int n=0; n<nodes.size(); n++)
{
nodes[n]->setMaterialFlag(video::EMF_FOG_ENABLE, enable);
}
}
//curr->getNode()->setMaterialFlag(video::EMF_FOG_ENABLE, enable);
adjustForFog(curr->getNode(), enable);
}
}