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

Clean up:

Browse Source 
Try to use forward enum declaration for KartRenderType

NoCopy for RenderInfo
This commit is contained in:
Benau
2016-08-18 11:15:05 +08:00
parent fa39de691e
commit 6b0fe9dd89
19 changed files with 84 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
src/graphics/render_info.hpp
View File

@@ -20,6 +20,7 @@
#define HEADER_RENDER_INFO_HPP
#include "utils/leak_check.hpp"
#include "utils/no_copy.hpp"
#include <assert.h>
#include <vector>
@@ -29,20 +30,19 @@ namespace irr
namespace scene { class IMesh; }
}
enum KartRenderType: unsigned int
{
KRT_DEFAULT,
KRT_RED,
KRT_BLUE,
KRT_TRANSPARENT,
};
/**
* \ingroup graphics
*/
class RenderInfo
class RenderInfo : public NoCopy
{
public:
enum KartRenderType
{
KRT_DEFAULT,
KRT_RED,
KRT_BLUE,
KRT_TRANSPARENT,
};
private:
float m_static_hue;
@@ -67,10 +67,8 @@ public:
// ------------------------------------------------------------------------
void setKartModelRenderInfo(KartRenderType krt)
{
setHue(krt == RenderInfo::KRT_BLUE ? 0.66f :
krt == RenderInfo::KRT_RED ? 1.0f : 0.0f);
setTransparent(krt == RenderInfo::KRT_TRANSPARENT ? true : false);
setHue(krt == KRT_BLUE ? 0.66f : krt == KRT_RED ? 1.0f : 0.0f);
setTransparent(krt == KRT_TRANSPARENT ? true : false);
}
// ------------------------------------------------------------------------
/** Returns true if this render info is static. ie affect all material

12
src/guiengine/widgets/model_view_widget.cpp
View File

@@ -17,6 +17,7 @@
#include "config/user_config.hpp"
#include "graphics/central_settings.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/widgets/model_view_widget.hpp"
#include "graphics/irr_driver.hpp"
@@ -48,6 +49,7 @@ IconButtonWidget(IconButtonWidget::SCALE_MODE_KEEP_TEXTURE_ASPECT_RATIO, false,
m_rtt_provider = NULL;
m_old_rtt_provider = NULL;
m_rotation_mode = ROTATE_OFF;
m_render_info = new RenderInfo();
// so that the base class doesn't complain there is no icon defined
m_properties[PROP_ICON]="gui/main_help.png";
@@ -65,6 +67,8 @@ ModelViewWidget::~ModelViewWidget()
delete m_old_rtt_provider;
m_old_rtt_provider = NULL;
m_texture = NULL;
delete m_render_info;
}
// -----------------------------------------------------------------------------
void ModelViewWidget::add()
@@ -228,7 +232,7 @@ void ModelViewWidget::setupRTTScene()
if (m_model_frames[0] == -1)
{
scene::ISceneNode* node = irr_driver->addMesh(m_models.get(0), "rtt_mesh",
NULL, &m_render_info, m_model_render_info_affected[0]);
NULL, m_render_info, m_model_render_info_affected[0]);
node->setPosition(m_model_location[0].toIrrVector());
node->setScale(m_model_scale[0].toIrrVector());
node->setMaterialFlag(video::EMF_FOG_ENABLE, false);
@@ -238,7 +242,7 @@ void ModelViewWidget::setupRTTScene()
{
scene::IAnimatedMeshSceneNode* node =
irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)m_models.get(0), "rtt_mesh",
NULL, &m_render_info, m_model_render_info_affected[0]);
NULL, m_render_info, m_model_render_info_affected[0]);
node->setPosition(m_model_location[0].toIrrVector());
node->setFrameLoop(m_model_frames[0], m_model_frames[0]);
node->setAnimationSpeed(0);
@@ -260,7 +264,7 @@ void ModelViewWidget::setupRTTScene()
{
scene::ISceneNode* node =
irr_driver->addMesh(m_models.get(n), "rtt_node", m_rtt_main_node,
&m_render_info, m_model_render_info_affected[n]);
m_render_info, m_model_render_info_affected[n]);
node->setPosition(m_model_location[n].toIrrVector());
node->updateAbsolutePosition();
node->setScale(m_model_scale[n].toIrrVector());
@@ -269,7 +273,7 @@ void ModelViewWidget::setupRTTScene()
{
scene::IAnimatedMeshSceneNode* node =
irr_driver->addAnimatedMesh((scene::IAnimatedMesh*)m_models.get(n),
"modelviewrtt", m_rtt_main_node, &m_render_info,
"modelviewrtt", m_rtt_main_node, m_render_info,
m_model_render_info_affected[n]);
node->setPosition(m_model_location[n].toIrrVector());
node->setFrameLoop(m_model_frames[n], m_model_frames[n]);

7
src/guiengine/widgets/model_view_widget.hpp
View File

@@ -23,12 +23,13 @@
#include <IMesh.h>
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/widgets/icon_button_widget.hpp"
#include "utils/aligned_array.hpp"
#include "utils/leak_check.hpp"
#include "utils/ptr_vector.hpp"
class RenderInfo;
namespace GUIEngine
{
/** \brief A model view widget.
@@ -68,7 +69,7 @@ namespace GUIEngine
FrameBuffer *m_frame_buffer;
video::ITexture *m_texture;
RenderInfo m_render_info;
RenderInfo *m_render_info;
public:
@@ -107,7 +108,7 @@ namespace GUIEngine
FrameBuffer* getFrameBuffer() { return m_frame_buffer; }
video::ITexture* getTexture() { return m_texture; }
RenderInfo& getModelViewRenderInfo() { return m_render_info; }
RenderInfo* getModelViewRenderInfo() { return m_render_info; }
};
}

4
src/karts/abstract_kart.cpp
View File

@@ -19,6 +19,7 @@
#include "karts/abstract_kart.hpp"
#include "graphics/render_info.hpp"
#include "items/powerup.hpp"
#include "karts/abstract_kart_animation.hpp"
#include "karts/kart_properties.hpp"
@@ -34,8 +35,7 @@
AbstractKart::AbstractKart(const std::string& ident,
int world_kart_id, int position,
const btTransform& init_transform,
PerPlayerDifficulty difficulty,
RenderInfo::KartRenderType krt)
PerPlayerDifficulty difficulty, KartRenderType krt)
: Moveable()
{
m_world_kart_id = world_kart_id;

5
src/karts/abstract_kart.hpp
View File

@@ -22,7 +22,6 @@
#include <memory>
#include "items/powerup_manager.hpp"
#include "graphics/render_info.hpp"
#include "karts/moveable.hpp"
#include "karts/controller/kart_control.hpp"
#include "race/race_manager.hpp"
@@ -50,6 +49,8 @@ class Skidding;
class SlipStream;
class TerrainInfo;
enum KartRenderType: unsigned int;
/** An abstract interface for the actual karts. Some functions are actually
* implemented here in order to allow inlining.
* \ingroup karts
@@ -100,7 +101,7 @@ public:
int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
RenderInfo::KartRenderType krt);
KartRenderType krt);
virtual ~AbstractKart();
virtual core::stringw getName() const;
virtual void reset();

3
src/karts/ghost_kart.cpp
View File

@@ -20,6 +20,7 @@
#include "karts/controller/ghost_controller.hpp"
#include "karts/kart_gfx.hpp"
#include "karts/kart_model.hpp"
#include "graphics/render_info.hpp"
#include "modes/world.hpp"
#include "LinearMath/btQuaternion.h"
@@ -28,7 +29,7 @@ GhostKart::GhostKart(const std::string& ident, unsigned int world_kart_id,
int position)
: Kart(ident, world_kart_id,
position, btTransform(btQuaternion(0, 0, 0, 1)),
PLAYER_DIFFICULTY_NORMAL, RenderInfo::KRT_TRANSPARENT)
PLAYER_DIFFICULTY_NORMAL, KRT_TRANSPARENT)
{
} // GhostKart

4
src/karts/kart.cpp
View File

@@ -33,6 +33,7 @@
#include "graphics/particle_emitter.hpp"
#include "graphics/particle_kind.hpp"
#include "graphics/particle_kind_manager.hpp"
#include "graphics/render_info.hpp"
#include "graphics/shadow.hpp"
#include "graphics/skid_marks.hpp"
#include "graphics/slip_stream.hpp"
@@ -91,8 +92,7 @@
*/
Kart::Kart (const std::string& ident, unsigned int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
RenderInfo::KartRenderType krt)
PerPlayerDifficulty difficulty, KartRenderType krt)
: AbstractKart(ident, world_kart_id, position, init_transform,
difficulty, krt)

4
src/karts/kart.hpp
View File

@@ -52,6 +52,8 @@ class SlipStream;
class Stars;
class TerrainInfo;
enum KartRenderType: unsigned int;
/** The main kart class. All type of karts are of this object, but with
* different controllers. The controllers are what turn a kart into a
* player kart (i.e. the controller handle input), or an AI kart (the
@@ -232,7 +234,7 @@ public:
Kart(const std::string& ident, unsigned int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
RenderInfo::KartRenderType krt = RenderInfo::KRT_DEFAULT);
KartRenderType krt);
virtual ~Kart();
virtual void init(RaceManager::KartType type);
virtual void kartIsInRestNow();

23
src/karts/kart_model.cpp
View File

@@ -30,6 +30,7 @@
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/mesh_tools.hpp"
#include "graphics/render_info.hpp"
#include "io/file_manager.hpp"
#include "io/xml_node.hpp"
#include "karts/abstract_kart.hpp"
@@ -116,6 +117,7 @@ KartModel::KartModel(bool is_master)
m_hat_name = "";
m_hat_node = NULL;
m_hat_offset = core::vector3df(0,0,0);
m_render_info = NULL;
for(unsigned int i=0; i<4; i++)
{
@@ -141,7 +143,7 @@ KartModel::KartModel(bool is_master)
m_animation_speed = 25;
m_current_animation = AF_DEFAULT;
m_play_non_loop = false;
m_krt = RenderInfo::KRT_DEFAULT;
m_krt = KRT_DEFAULT;
m_support_colorization = false;
} // KartModel
@@ -246,7 +248,7 @@ KartModel::~KartModel()
assert(!m_is_master);
// Drop the cloned transparent model if created
if (m_krt == RenderInfo::KRT_TRANSPARENT)
if (m_krt == KRT_TRANSPARENT)
{
m_speed_weighted_objects[i].m_model->drop();
}
@@ -275,6 +277,8 @@ KartModel::~KartModel()
}
}
}
delete m_render_info;
#ifdef DEBUG
#if SKELETON_DEBUG
irr_driver->clearDebugMeshes();
@@ -289,12 +293,13 @@ KartModel::~KartModel()
* It is also marked not to be a master copy, so attachModel can be called
* for this instance.
*/
KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
KartModel* KartModel::makeCopy(KartRenderType krt)
{
// Make sure that we are copying from a master objects, and
// that there is indeed no animated node defined here ...
// just in case.
assert(m_is_master);
assert(m_render_info == NULL);
assert(!m_animated_node);
KartModel *km = new KartModel(/*is master*/ false);
km->m_kart_width = m_kart_width;
@@ -311,6 +316,8 @@ KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
km->m_hat_name = m_hat_name;
km->m_krt = krt;
km->m_support_colorization = m_support_colorization;
km->m_render_info = new RenderInfo();
km->m_render_info->setKartModelRenderInfo(krt);
km->m_nitro_emitter_position[0] = m_nitro_emitter_position[0];
km->m_nitro_emitter_position[1] = m_nitro_emitter_position[1];
@@ -335,7 +342,7 @@ KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
// Master should not have any speed weighted nodes.
assert(!m_speed_weighted_objects[i].m_node);
km->m_speed_weighted_objects[i] = m_speed_weighted_objects[i];
if (krt == RenderInfo::KRT_TRANSPARENT)
if (krt == KRT_TRANSPARENT)
{
// Only clone the mesh if transparent type is used, see #2445
km->m_speed_weighted_objects[i].m_model = irr_driver
@@ -359,7 +366,6 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
assert(!m_is_master);
scene::ISceneNode* node = NULL;
m_render_info.setKartModelRenderInfo(m_krt);
if (animated_models)
{
@@ -1031,3 +1037,10 @@ void KartModel::attachHat()
} // if bone
} // if(m_hat_name)
} // attachHat
//-----------------------------------------------------------------------------
RenderInfo* KartModel::getRenderInfo()
{
return m_support_colorization || m_krt == KRT_TRANSPARENT ?
m_render_info : NULL;
} // getRenderInfo

22
src/karts/kart_model.hpp
View File

@@ -30,14 +30,16 @@ namespace irr
}
using namespace irr;
#include "graphics/render_info.hpp"
#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"
class AbstractKart;
class KartProperties;
class RenderInfo;
class XMLNode;
enum KartRenderType: unsigned int;
/** A speed-weighted object is an object whose characteristics are influenced by the kart's speed */
struct SpeedWeightedObject
{
@@ -231,16 +233,16 @@ private:
/** Pointer to the kart object belonging to this kart model. */
AbstractKart* m_kart;
RenderInfo::KartRenderType m_krt;
KartRenderType m_krt;
RenderInfo m_render_info;
RenderInfo* m_render_info;
bool m_support_colorization;
public:
KartModel(bool is_master);
~KartModel();
KartModel* makeCopy(RenderInfo::KartRenderType krt);
KartModel* makeCopy(KartRenderType krt);
void reset();
void loadInfo(const XMLNode &node);
bool loadModels(const KartProperties &kart_properties);
@@ -338,17 +340,7 @@ public:
// ------------------------------------------------------------------------
core::vector3df getHatOffset() { return m_hat_offset; }
// ------------------------------------------------------------------------
RenderInfo* getRenderInfo()
{
return m_support_colorization || m_krt == RenderInfo::KRT_TRANSPARENT ?
&m_render_info : NULL;
}
// ------------------------------------------------------------------------
const RenderInfo* getRenderInfo() const
{
return m_support_colorization || m_krt == RenderInfo::KRT_TRANSPARENT ?
&m_render_info : NULL;
}
RenderInfo* getRenderInfo();
// ------------------------------------------------------------------------
bool supportColorization() const { return m_support_colorization; }

10
src/karts/kart_properties.hpp
View File

@@ -45,6 +45,8 @@ class CombinedCharacteristic;
class Material;
class XMLNode;
enum KartRenderType: unsigned int;
/**
* \brief This class stores the properties of a kart.
* This includes size, name, identifier, physical properties etc.
@@ -242,9 +244,11 @@ public:
video::ITexture *getMinimapIcon () const {return m_minimap_icon; }
// ------------------------------------------------------------------------
/** Returns a pointer to the KartModel object. */
KartModel* getKartModelCopy
(RenderInfo::KartRenderType krt = RenderInfo::KRT_DEFAULT) const
/** Returns a pointer to the KartModel object.
* \param krt The KartRenderType, like default, red, blue or transparent.
* see the RenderInfo include for details
*/
KartModel* getKartModelCopy(KartRenderType krt) const
{return m_kart_model->makeCopy(krt); }
// ------------------------------------------------------------------------

3
src/karts/kart_with_stats.cpp
View File

@@ -18,6 +18,7 @@
#include "karts/kart_with_stats.hpp"
#include "graphics/render_info.hpp"
#include "karts/explosion_animation.hpp"
#include "karts/rescue_animation.hpp"
#include "items/item.hpp"
@@ -28,7 +29,7 @@ KartWithStats::KartWithStats(const std::string& ident,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty)
: Kart(ident, world_kart_id, position,
init_transform, difficulty)
init_transform, difficulty, KRT_DEFAULT)
{
} // KartWithStats

3
src/modes/soccer_world.cpp
View File

@@ -396,8 +396,7 @@ AbstractKart *SoccerWorld::createKart(const std::string &kart_ident, int index,
m_kart_position_map[index] = (unsigned)(pos_index - 1);
AbstractKart *new_kart = new Kart(kart_ident, index, position, init_pos,
difficulty, team == SOCCER_TEAM_BLUE ?
RenderInfo::KRT_BLUE : RenderInfo::KRT_RED);
difficulty, team == SOCCER_TEAM_BLUE ? KRT_BLUE : KRT_RED);
new_kart->init(race_manager->getKartType(index));
Controller *controller = NULL;

3
src/modes/world.cpp
View File

@@ -27,6 +27,7 @@
#include "config/user_config.hpp"
#include "graphics/camera.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "io/file_manager.hpp"
#include "input/device_manager.hpp"
#include "input/keyboard_device.hpp"
@@ -334,7 +335,7 @@ AbstractKart *World::createKart(const std::string &kart_ident, int index,
int position = index+1;
btTransform init_pos = getStartTransform(index - gk);
AbstractKart *new_kart = new Kart(kart_ident, index, position, init_pos,
difficulty);
difficulty, KRT_DEFAULT);
new_kart->init(race_manager->getKartType(index));
Controller *controller = NULL;
switch(kart_type)

3
src/states_screens/feature_unlocked.cpp
View File

@@ -25,6 +25,7 @@
#include "challenges/unlock_manager.hpp"
#include "config/player_manager.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
#include "io/file_manager.hpp"
@@ -295,7 +296,7 @@ void FeatureUnlockedCutScene::init()
else if (m_unlocked_stuff[n].m_unlocked_kart != NULL)
{
KartModel *kart_model =
m_unlocked_stuff[n].m_unlocked_kart->getKartModelCopy();
m_unlocked_stuff[n].m_unlocked_kart->getKartModelCopy(KRT_DEFAULT);
m_all_kart_models.push_back(kart_model);
m_unlocked_stuff[n].m_root_gift_node = kart_model->attachModel(true, false);
m_unlocked_stuff[n].m_scale = 5.0f;

3
src/states_screens/grand_prix_lose.cpp
View File

@@ -23,6 +23,7 @@
#include "challenges/unlock_manager.hpp"
#include "config/player_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
#include "guiengine/widgets/button_widget.hpp"
@@ -181,7 +182,7 @@ void GrandPrixLose::setKarts(std::vector<std::string> ident_arg)
const KartProperties* kart = kart_properties_manager->getKart(ident_arg[n]);
if (kart != NULL)
{
KartModel* kart_model = kart->getKartModelCopy();
KartModel* kart_model = kart->getKartModelCopy(KRT_DEFAULT);
m_all_kart_models.push_back(kart_model);
scene::ISceneNode* kart_main_node = kart_model->attachModel(false, false);

3
src/states_screens/grand_prix_win.cpp
View File

@@ -23,6 +23,7 @@
#include "challenges/unlock_manager.hpp"
#include "config/player_manager.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/engine.hpp"
#include "guiengine/scalable_font.hpp"
#include "guiengine/widgets/button_widget.hpp"
@@ -304,7 +305,7 @@ void GrandPrixWin::setKarts(const std::string idents_arg[3])
const KartProperties* kp = kart_properties_manager->getKart(idents[i]);
if (kp == NULL) continue;
KartModel* kart_model = kp->getKartModelCopy();
KartModel* kart_model = kp->getKartModelCopy(KRT_DEFAULT);
m_all_kart_models.push_back(kart_model);
scene::ISceneNode* kart_main_node = kart_model->attachModel(false, false);

10
src/states_screens/soccer_setup_screen.cpp
View File

@@ -19,6 +19,7 @@
#include "audio/sfx_manager.hpp"
#include "config/user_config.hpp"
#include "graphics/render_info.hpp"
#include "guiengine/widgets/bubble_widget.hpp"
#include "guiengine/widgets/button_widget.hpp"
#include "guiengine/widgets/spinner_widget.hpp"
@@ -149,9 +150,8 @@ void SoccerSetupScreen::beforeAddingWidget()
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);
kart_view->getModelViewRenderInfo()->setKartModelRenderInfo
(info.team == SOCCER_TEAM_BLUE ? KRT_BLUE : KRT_RED);
}
// Add the kart model (including wheels and speed weight objects)
@@ -295,7 +295,7 @@ GUIEngine::EventPropagation SoccerSetupScreen::filterActions(PlayerAction action
if (m_kart_view_info[playerId].support_colorization)
{
m_kart_view_info[playerId].view->getModelViewRenderInfo()
.setKartModelRenderInfo(RenderInfo::KRT_RED);
->setKartModelRenderInfo(KRT_RED);
}
for(int i=0 ; i < nb_players ; i++)
@@ -315,7 +315,7 @@ GUIEngine::EventPropagation SoccerSetupScreen::filterActions(PlayerAction action
if (m_kart_view_info[playerId].support_colorization)
{
m_kart_view_info[playerId].view->getModelViewRenderInfo()
.setKartModelRenderInfo(RenderInfo::KRT_BLUE);
->setKartModelRenderInfo(KRT_BLUE);
}
for(int i=0 ; i < nb_players ; i++)

2
src/states_screens/soccer_setup_screen.hpp
View File

@@ -18,7 +18,6 @@
#ifndef HEADER_SOCCER_SETUP_SCREEN_HPP
#define HEADER_SOCCER_SETUP_SCREEN_HPP
#include "graphics/render_info.hpp"
#include "guiengine/screen.hpp"
#include "network/remote_kart_info.hpp"
@@ -41,7 +40,6 @@ class SoccerSetupScreen : public GUIEngine::Screen,
bool confirmed;
bool support_colorization;
SoccerTeam team;
RenderInfo render_info;
KartViewInfo() : view(), confirmed(false), support_colorization(false),
team(SOCCER_TEAM_NONE) {}