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

Remove vector int in RenderInfo

Browse Source
This commit is contained in:
Benau 2016-07-15 12:31:00 +08:00
parent 8408a7c158
commit 1d6c7fa60f
10 changed files with 81 additions and 68 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/graphics/render_info.cpp
View File

@ -29,16 +29,3 @@ RenderInfo::RenderInfo(float hue, bool transparent)
m_hue = hue;
m_transparent = transparent;
} // RenderInfo
// ----------------------------------------------------------------------------
void RenderInfo::setColorizableParts(irr::scene::IMesh* m)
{
for (int i = 0; i < int(m->getMeshBufferCount()); i++)
{
scene::IMeshBuffer* mb = m->getMeshBuffer(i);
Material* material = material_manager->getMaterialFor(mb
->getMaterial().getTexture(0), mb);
if (material->isColorizable())
m_colorizable_parts.push_back(i);
}
} // setColorizableParts

14
src/graphics/render_info.hpp
View File

@ -21,9 +21,6 @@
#include "utils/leak_check.hpp"
#include <algorithm>
#include <vector>
namespace irr
{
namespace scene { class IMesh; }
@ -48,8 +45,6 @@ private:
bool m_transparent;
std::vector<int> m_colorizable_parts;
public:
LEAK_CHECK();
// ------------------------------------------------------------------------
@ -57,8 +52,6 @@ public:
// ------------------------------------------------------------------------
~RenderInfo() {}
// ------------------------------------------------------------------------
void setColorizableParts(irr::scene::IMesh* m);
// ------------------------------------------------------------------------
void setHue(float hue) { m_hue = hue; }
// ------------------------------------------------------------------------
void setTransparent(bool transparent) { m_transparent = transparent; }
@ -67,13 +60,6 @@ public:
// ------------------------------------------------------------------------
bool isTransparent() const { return m_transparent; }
// ------------------------------------------------------------------------
bool isColorizable(int mesh_buffer_index) const
{
return m_colorizable_parts.empty() ||
std::find(m_colorizable_parts.begin(), m_colorizable_parts.end(),
mesh_buffer_index) != m_colorizable_parts.end();
}
// ------------------------------------------------------------------------
void setKartModelRenderInfo(KartRenderType krt)
{
setHue(krt == RenderInfo::KRT_BLUE ? 0.66f :

5
src/graphics/stk_animated_mesh.cpp
View File

@ -107,7 +107,10 @@ void STKAnimatedMesh::updateNoGL()
if (!m_all_parts_colorized && mb && m_mesh_render_info)
{
// Test if material is affected by hue change
affected = m_mesh_render_info->isColorizable(i);
Material* m = material_manager->getMaterialFor(mb
->getMaterial().getTexture(0), mb);
if (m->isColorizable())
affected = true;
}
GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name,

5
src/graphics/stk_mesh_scene_node.cpp
View File

@ -84,7 +84,10 @@ void STKMeshSceneNode::createGLMeshes(RenderInfo* render_info, bool all_parts_co
if (!all_parts_colorized && mb && render_info)
{
// Test if material is affected by hue change
affected = render_info->isColorizable(i);
Material* m = material_manager->getMaterialFor(mb
->getMaterial().getTexture(0), mb);
if (m->isColorizable())
affected = true;
}
GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name,

1
src/graphics/texture_manager.cpp
View File

@ -34,6 +34,7 @@
GLuint getTextureGLuint(irr::video::ITexture *tex)
{
assert(tex != NULL);
#if defined(USE_GLES2)
return static_cast<irr::video::COGLES2Texture*>(tex)->getOpenGLTextureName();
#else

19
src/karts/kart_model.cpp
View File

@ -27,6 +27,8 @@
#include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/lod_node.hpp"
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/mesh_tools.hpp"
#include "io/file_manager.hpp"
#include "io/xml_node.hpp"
@ -140,7 +142,7 @@ KartModel::KartModel(bool is_master)
m_current_animation = AF_DEFAULT;
m_play_non_loop = false;
m_krt = RenderInfo::KRT_DEFAULT;
m_render_info = RenderInfo();
m_support_colorization = false;
} // KartModel
// ----------------------------------------------------------------------------
@ -298,7 +300,7 @@ KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
km->m_kart_width = m_kart_width;
km->m_kart_length = m_kart_length;
km->m_kart_height = m_kart_height;
km->m_kart_highest_point= m_kart_highest_point;
km->m_kart_highest_point = m_kart_highest_point;
km->m_kart_lowest_point = m_kart_lowest_point;
km->m_mesh = irr_driver->copyAnimatedMesh(m_mesh);
km->m_model_filename = m_model_filename;
@ -308,7 +310,7 @@ KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
km->m_hat_offset = m_hat_offset;
km->m_hat_name = m_hat_name;
km->m_krt = krt;
km->m_render_info = m_render_info;
km->m_support_colorization = m_support_colorization;
km->m_nitro_emitter_position[0] = m_nitro_emitter_position[0];
km->m_nitro_emitter_position[1] = m_nitro_emitter_position[1];
@ -520,8 +522,15 @@ bool KartModel::loadModels(const KartProperties &kart_properties)
MeshTools::minMax3D(m_mesh->getMesh(m_animation_frame[AF_STRAIGHT]),
&kart_min, &kart_max);
// Enable colorization for karts later when attachModel
m_render_info.setColorizableParts(m_mesh);
// Test if kart model support colorization
for (int i = 0; i < int(m_mesh->getMeshBufferCount()); i++)
{
scene::IMeshBuffer* mb = m_mesh->getMeshBuffer(i);
Material* material = material_manager->getMaterialFor(mb
->getMaterial().getTexture(0), mb);
m_support_colorization =
m_support_colorization || material->isColorizable();
}
#undef MOVE_KART_MESHES
#ifdef MOVE_KART_MESHES

16
src/karts/kart_model.hpp
View File

@ -235,6 +235,8 @@ private:
RenderInfo m_render_info;
bool m_support_colorization;
public:
KartModel(bool is_master);
~KartModel();
@ -335,9 +337,19 @@ public:
// ------------------------------------------------------------------------
core::vector3df getHatOffset() { return m_hat_offset; }
// ------------------------------------------------------------------------
RenderInfo* getRenderInfo() { return &m_render_info; }
RenderInfo* getRenderInfo()
{
return m_support_colorization || m_krt == RenderInfo::KRT_TRANSPARENT ?
&m_render_info : NULL;
}
// ------------------------------------------------------------------------
const RenderInfo* getRenderInfo() const { return &m_render_info; }
const RenderInfo* getRenderInfo() const
{
return m_support_colorization || m_krt == RenderInfo::KRT_TRANSPARENT ?
&m_render_info : NULL;
}
// ------------------------------------------------------------------------
bool supportColorization() const { return m_support_colorization; }
}; // KartModel
#endif

14
src/modes/soccer_world.cpp
View File

@ -305,9 +305,6 @@ void SoccerWorld::countdownReachedZero()
//-----------------------------------------------------------------------------
void SoccerWorld::initKartList()
{
// Color of karts can be changed using shaders
if (CVS->isGLSL()) return;
const unsigned int kart_amount = (unsigned int)m_karts.size();
//Loading the indicator textures
@ -317,10 +314,15 @@ void SoccerWorld::initKartList()
irr_driver->getTexture(FileManager::GUI, "soccer_player_blue.png");
//Assigning indicators
for(unsigned int i=0; i<kart_amount; i++)
for(unsigned int i = 0; i < kart_amount; i++)
{
scene::ISceneNode *arrow_node;
float arrow_pos_height = m_karts[i]->getKartModel()->getHeight()+0.5f;
scene::ISceneNode *arrow_node = NULL;
KartModel* km = m_karts[i]->getKartModel();
// Color of karts can be changed using shaders if the model supports
if (km->supportColorization() && CVS->isGLSL()) continue;
float arrow_pos_height = km->getHeight() + 0.5f;
SoccerTeam team = getKartTeam(i);
arrow_node = irr_driver->addBillboard(core::dimension2d<irr::f32>(0.3f,

13
src/states_screens/soccer_setup_screen.cpp
View File

@ -146,12 +146,13 @@ void SoccerSetupScreen::beforeAddingWidget()
(i&1 ? SOCCER_TEAM_BLUE : SOCCER_TEAM_RED));
// addModel requires loading the RenderInfo first
kart_view->getModelViewRenderInfo().setRenderInfo
(kart_model.getRenderInfo());
info.support_colorization = kart_model.supportColorization();
if (info.support_colorization)
{
kart_view->getModelViewRenderInfo().setKartModelRenderInfo
(info.team == SOCCER_TEAM_BLUE ?
RenderInfo::KRT_BLUE : RenderInfo::KRT_RED);
}
// Add the kart model (including wheels and speed weight objects)
kart_view->addModel( kart_model.getModel(), Vec3(0,0,0),
@ -291,8 +292,11 @@ GUIEngine::EventPropagation SoccerSetupScreen::filterActions(PlayerAction action
team_switch = SOCCER_TEAM_RED;
// Change the kart color
if (m_kart_view_info[playerId].support_colorization)
{
m_kart_view_info[playerId].view->getModelViewRenderInfo()
.setKartModelRenderInfo(RenderInfo::KRT_RED);
}
for(int i=0 ; i < nb_players ; i++)
{
@ -308,8 +312,11 @@ GUIEngine::EventPropagation SoccerSetupScreen::filterActions(PlayerAction action
team_switch = SOCCER_TEAM_BLUE;
// Change the kart color
if (m_kart_view_info[playerId].support_colorization)
{
m_kart_view_info[playerId].view->getModelViewRenderInfo()
.setKartModelRenderInfo(RenderInfo::KRT_BLUE);
}
for(int i=0 ; i < nb_players ; i++)
{

7
src/states_screens/soccer_setup_screen.hpp
View File

@ -28,7 +28,8 @@ namespace GUIEngine { class Widget; class LabelWidget; class ModelViewWidget; }
* \brief Screen with soccer setup options
* \ingroup states_screens
*/
class SoccerSetupScreen : public GUIEngine::Screen, public GUIEngine::ScreenSingleton<SoccerSetupScreen>
class SoccerSetupScreen : public GUIEngine::Screen,
public GUIEngine::ScreenSingleton<SoccerSetupScreen>
{
friend class GUIEngine::ScreenSingleton<SoccerSetupScreen>;
@ -38,10 +39,12 @@ class SoccerSetupScreen : public GUIEngine::Screen, public GUIEngine::ScreenSing
{
GUIEngine::ModelViewWidget* view;
bool confirmed;
bool support_colorization;
SoccerTeam team;
RenderInfo render_info;
KartViewInfo() : view(), confirmed(false), team(SOCCER_TEAM_NONE) {}
KartViewInfo() : view(), confirmed(false), support_colorization(false),
team(SOCCER_TEAM_NONE) {}
};
AlignedArray<KartViewInfo> m_kart_view_info;