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

Allow changing kart color on-the-fly

Browse Source
This commit is contained in:
Benau
2016-06-30 09:30:52 +08:00
parent 984553fd33
commit 5bb2a5cf7e
19 changed files with 211 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/graphics/irr_driver.cpp
View File

@@ -29,6 +29,7 @@
#include "graphics/per_camera_node.hpp"
#include "graphics/post_processing.hpp"
#include "graphics/referee.hpp"
#include "graphics/render_info.hpp"
#include "graphics/shaders.hpp"
#include "graphics/shadow_matrices.hpp"
#include "graphics/stk_animated_mesh.hpp"
@@ -1169,7 +1170,7 @@ scene::IParticleSystemSceneNode *IrrDriver::addParticleNode(bool default_emitter
scene::IMeshSceneNode *IrrDriver::addMesh(scene::IMesh *mesh,
const std::string& debug_name,
scene::ISceneNode *parent,
const CustomRenderInfo& cri)
RenderInfo* render_info)
{
if (!CVS->isGLSL())
return m_scene_manager->addMeshSceneNode(mesh, parent);
@@ -1183,7 +1184,7 @@ scene::IMeshSceneNode *IrrDriver::addMesh(scene::IMesh *mesh,
core::vector3df(0, 0, 0),
core::vector3df(0, 0, 0),
core::vector3df(1.0f, 1.0f, 1.0f),
true, cri);
true, render_info);
node->drop();
return node;
@@ -1366,7 +1367,7 @@ void IrrDriver::removeTexture(video::ITexture *t)
*/
scene::IAnimatedMeshSceneNode *IrrDriver::addAnimatedMesh(scene::IAnimatedMesh *mesh,
const std::string& debug_name, scene::ISceneNode* parent,
const CustomRenderInfo& cri)
RenderInfo* render_info)
{
if (!CVS->isGLSL())
{
@@ -1381,7 +1382,8 @@ scene::IAnimatedMeshSceneNode *IrrDriver::addAnimatedMesh(scene::IAnimatedMesh *
parent = m_scene_manager->getRootSceneNode();
scene::IAnimatedMeshSceneNode* node =
new STKAnimatedMesh(mesh, parent, m_scene_manager, -1, debug_name,
core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), core::vector3df(1, 1, 1), cri);
core::vector3df(0, 0, 0), core::vector3df(0, 0, 0),
core::vector3df(1, 1, 1), render_info);
node->drop();
return node;
} // addAnimatedMesh

57
src/graphics/irr_driver.hpp
View File

@@ -37,8 +37,6 @@
#include "IrrlichtDevice.h"
#include "ISkinnedMesh.h"
#include "graphics/gl_headers.hpp"
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/skybox.hpp"
#include "graphics/sphericalHarmonics.hpp"
#include "graphics/wind.hpp"
@@ -58,6 +56,7 @@ namespace irr
using namespace irr;
class RTT;
class RenderInfo;
class FrameBuffer;
class ShadowImportanceProvider;
class AbstractKart;
@@ -179,54 +178,6 @@ enum TypeRTT
RTT_COUNT
};
struct CustomRenderInfo
{
float m_custom_hue;
float m_custom_min_saturation;
bool m_transparent;
std::vector<int> m_affected_parts;
std::vector<int> getColorizableParts(scene::IMesh* m)
{
std::vector<int> colorizable_parts;
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())
colorizable_parts.push_back(i);
}
return colorizable_parts;
}
CustomRenderInfo()
{
m_custom_hue = 0.0f;
m_custom_min_saturation = 0.0f;
m_transparent = false;
}
CustomRenderInfo(float custom_hue, float custom_min_saturation,
bool transparent, scene::IMesh* m = NULL)
{
m_custom_hue = custom_hue;
m_custom_min_saturation = custom_min_saturation;
m_transparent = transparent;
if (m)
m_affected_parts = getColorizableParts(m);
}
CustomRenderInfo(const CustomRenderInfo& cri)
{
m_custom_hue = cri.m_custom_hue;
m_custom_min_saturation = cri.m_custom_min_saturation;
m_transparent = cri.m_transparent;
}
};
/**
* \brief class that creates the irrLicht device and offers higher-level
* ways to manage the 3D scene
@@ -436,8 +387,8 @@ public:
const video::SColor &color=video::SColor(128, 255, 255, 255));
scene::IMeshSceneNode*addMesh(scene::IMesh *mesh,
const std::string& debug_name,
scene::ISceneNode *parent=NULL,
const CustomRenderInfo& cri = CustomRenderInfo());
scene::ISceneNode *parent = NULL,
RenderInfo* render_info = NULL);
PerCameraNode *addPerCameraNode(scene::ISceneNode* node,
scene::ICameraSceneNode* cam,
scene::ISceneNode *parent = NULL);
@@ -460,7 +411,7 @@ public:
*addAnimatedMesh(scene::IAnimatedMesh *mesh,
const std::string& debug_name,
scene::ISceneNode* parent = NULL,
const CustomRenderInfo& cri = CustomRenderInfo());
RenderInfo* render_info = NULL);
scene::ICameraSceneNode
*addCameraSceneNode();
Camera *addCamera(unsigned int index, AbstractKart *kart);

16
src/graphics/render_geometry.cpp
View File

@@ -23,6 +23,7 @@
#include "graphics/glwrap.hpp"
#include "graphics/post_processing.hpp"
#include "graphics/rtts.hpp"
#include "graphics/render_info.hpp"
#include "graphics/shaders.hpp"
#include "graphics/shadow_matrices.hpp"
#include "graphics/stk_scene_manager.hpp"
@@ -998,11 +999,13 @@ void draw(const T *Shader, const GLMesh *mesh, uniforms... Args)
GLenum itype = mesh->IndexType;
size_t count = mesh->IndexCount;
const bool need_change_hue = (mesh->m_custom_hue > 0.0f);
const bool support_change_hue = (mesh->m_render_info != NULL);
const bool need_change_hue = (support_change_hue &&
mesh->m_render_info->getHue() > 0.0f);
if (need_change_hue)
{
Shader->changeableColor(mesh->m_custom_hue,
mesh->m_custom_min_saturation);
Shader->changeableColor(mesh->m_render_info->getHue(),
mesh->m_render_info->getMinSaturation());
}
Shader->setUniforms(Args...);
@@ -1298,11 +1301,14 @@ void renderInstancedMeshes2ndPass(const std::vector<GLuint> &Prefilled_tex, Args
ExpandTex(*mesh, T::SecondPassTextures, Prefilled_tex[0],
Prefilled_tex[1], Prefilled_tex[2]);
const bool need_change_hue = (mesh->m_custom_hue > 0.0f);
const bool support_change_hue = (mesh->m_render_info != NULL);
const bool need_change_hue =
(support_change_hue && mesh->m_render_info->getHue() > 0.0f);
if (need_change_hue)
{
T::InstancedSecondPassShader::getInstance()->changeableColor
(mesh->m_custom_hue, mesh->m_custom_min_saturation);
(mesh->m_render_info->getHue(),
mesh->m_render_info->getMinSaturation());
}
T::InstancedSecondPassShader::getInstance()->setUniforms(args...);

97
src/graphics/render_info.hpp Normal file
View File

@@ -0,0 +1,97 @@
//
// SuperTuxKart - a fun racing game with go-kart
// Copyright (C) 2016 SuperTuxKart-Team
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 3
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#ifndef HEADER_RENDER_INFO_HPP
#define HEADER_RENDER_INFO_HPP
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include <ISceneManager.h>
#include <algorithm>
#include <vector>
/**
* \ingroup graphics
*/
class RenderInfo
{
public:
enum KartRenderType
{
KRT_DEFAULT,
KRT_RED,
KRT_BLUE,
KRT_TRANSPARENT,
};
private:
float m_hue;
float m_min_saturation;
bool m_transparent;
std::vector<int> m_colorizable_parts;
public:
RenderInfo(float hue = 0.0f, float min_saturation = 0.0f,
bool transparent = false)
{
m_hue = hue;
m_min_saturation = min_saturation;
m_transparent = transparent;
}
// ------------------------------------------------------------------------
void 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);
}
}
// ------------------------------------------------------------------------
void setHue(float hue) { m_hue = hue; }
// ------------------------------------------------------------------------
void setMinSaturation(float min_saturation)
{ m_min_saturation = min_saturation; }
// ------------------------------------------------------------------------
void setTransparent(bool transparent) { m_transparent = transparent; }
// ------------------------------------------------------------------------
float getHue() const { return m_hue; }
// ------------------------------------------------------------------------
float getMinSaturation() const { return m_min_saturation; }
// ------------------------------------------------------------------------
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();
}
}; // RenderInfo
#endif
/* EOF */

27
src/graphics/stk_animated_mesh.cpp
View File

@@ -21,8 +21,9 @@
#include "central_settings.hpp"
#include "graphics/camera.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/stk_animated_mesh.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/render_info.hpp"
#include "graphics/stk_animated_mesh.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
#include "utils/profiler.hpp"
@@ -31,7 +32,6 @@
#include <IMaterialRenderer.h>
#include <ISceneManager.h>
#include <ISkinnedMesh.h>
#include <algorithm>
using namespace irr;
@@ -39,12 +39,12 @@ STKAnimatedMesh::STKAnimatedMesh(irr::scene::IAnimatedMesh* mesh, irr::scene::IS
irr::scene::ISceneManager* mgr, s32 id, const std::string& debug_name,
const core::vector3df& position,
const core::vector3df& rotation,
const core::vector3df& scale, const CustomRenderInfo& cri) :
const core::vector3df& scale, RenderInfo* render_info) :
CAnimatedMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale)
{
isGLInitialized = false;
isMaterialInitialized = false;
m_cri = cri;
m_mesh_render_info = render_info;
#ifdef DEBUG
m_debug_name = debug_name;
#endif
@@ -102,13 +102,15 @@ void STKAnimatedMesh::updateNoGL()
for (u32 i = 0; i < m->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
const bool affected = m_cri.m_affected_parts.empty() ||
std::find(m_cri.m_affected_parts.begin(),
m_cri.m_affected_parts.end(), i) != m_cri.m_affected_parts.end();
bool affected = false;
if (mb && m_mesh_render_info)
{
// Test if material is affected by hue change
affected = m_mesh_render_info->isColorizable(i);
}
GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name,
affected ? m_cri : CustomRenderInfo()/*default info if not affected*/));
affected ? m_mesh_render_info : NULL));
}
for (u32 i = 0; i < m->getMeshBufferCount(); ++i)
@@ -134,12 +136,15 @@ void STKAnimatedMesh::updateNoGL()
TransparentMaterial TranspMat = getTransparentMaterialFromType(type, MaterialTypeParam, material);
TransparentMesh[TranspMat].push_back(&mesh);
}
else if (mesh.m_transparent)
else if (mesh.m_render_info != NULL && mesh.m_render_info->isTransparent())
{
TransparentMesh[TM_ADDITIVE].push_back(&mesh);
}
else if (mesh.m_custom_hue > 0.0f)
else if (mesh.m_render_info != NULL)
{
// For now, put all meshes that support custom render info into
// solid (default) material first, this allowing changing fewer
// shaders
MeshSolidMaterial[Material::SHADERTYPE_SOLID].push_back(&mesh);
}
else

6
src/graphics/stk_animated_mesh.hpp
View File

@@ -25,6 +25,8 @@
#include <IAnimatedMesh.h>
#include <irrTypes.h>
class RenderInfo;
class STKAnimatedMesh : public irr::scene::CAnimatedMeshSceneNode, public STKMeshCommon
{
protected:
@@ -41,14 +43,14 @@ public:
const irr::core::vector3df& position = irr::core::vector3df(0,0,0),
const irr::core::vector3df& rotation = irr::core::vector3df(0,0,0),
const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f),
const CustomRenderInfo& cri = CustomRenderInfo());
RenderInfo* render_info = NULL);
~STKAnimatedMesh();
virtual void render();
virtual void setMesh(irr::scene::IAnimatedMesh* mesh);
virtual bool glow() const { return false; }
private:
CustomRenderInfo m_cri;
RenderInfo* m_mesh_render_info;
};
#endif // STKANIMATEDMESH_HPP

7
src/graphics/stk_mesh.cpp
View File

@@ -23,6 +23,7 @@
#include "graphics/camera.hpp"
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "graphics/shaders.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
@@ -164,12 +165,10 @@ GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type)
// ----------------------------------------------------------------------------
GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb, const std::string& debug_name,
const CustomRenderInfo& cri)
RenderInfo* render_info)
{
GLMesh result = {};
result.m_custom_hue = cri.m_custom_hue;
result.m_custom_min_saturation = cri.m_custom_min_saturation;
result.m_transparent = cri.m_transparent;
result.m_render_info = render_info;
if (!mb)
return result;
result.mb = mb;

7
src/graphics/stk_mesh.hpp
View File

@@ -31,6 +31,7 @@
#include <vector>
class Material;
class RenderInfo;
enum TransparentMaterial
{
@@ -56,9 +57,7 @@ struct GLMesh
video::E_VERTEX_TYPE VAOType;
uint64_t TextureHandles[6];
scene::IMeshBuffer *mb;
float m_custom_hue;
float m_custom_min_saturation;
bool m_transparent;
RenderInfo* m_render_info;
#ifdef DEBUG
std::string debug_name;
#endif
@@ -67,7 +66,7 @@ struct GLMesh
// ----------------------------------------------------------------------------
GLMesh allocateMeshBuffer(scene::IMeshBuffer* mb,
const std::string& debug_name,
const CustomRenderInfo& cri);
RenderInfo* render_info);
void fillLocalBuffer(GLMesh &, scene::IMeshBuffer* mb);
video::E_VERTEX_TYPE getVTXTYPEFromStride(size_t stride);
GLuint createVAO(GLuint vbo, GLuint idx, video::E_VERTEX_TYPE type);

27
src/graphics/stk_mesh_scene_node.cpp
View File

@@ -24,6 +24,7 @@
#include "graphics/glwrap.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/material_manager.hpp"
#include "graphics/render_info.hpp"
#include "graphics/stk_mesh.hpp"
#include "tracks/track.hpp"
#include "modes/world.hpp"
@@ -33,7 +34,6 @@
#include <ISceneManager.h>
#include <IMaterialRenderer.h>
#include <algorithm>
// ============================================================================
class ColorizeShader : public Shader<ColorizeShader, core::matrix4,
@@ -54,7 +54,7 @@ STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent,
irr::s32 id, const std::string& debug_name,
const irr::core::vector3df& position,
const irr::core::vector3df& rotation,
const irr::core::vector3df& scale, bool createGLMeshes, const CustomRenderInfo& cri) :
const irr::core::vector3df& scale, bool createGLMeshes, RenderInfo* render_info) :
CMeshSceneNode(mesh, parent, mgr, id, position, rotation, scale)
{
isDisplacement = false;
@@ -65,7 +65,7 @@ STKMeshSceneNode::STKMeshSceneNode(irr::scene::IMesh* mesh, ISceneNode* parent,
m_debug_name = debug_name;
if (createGLMeshes)
this->createGLMeshes(cri);
this->createGLMeshes(render_info);
}
void STKMeshSceneNode::setReloadEachFrame(bool val)
@@ -75,18 +75,20 @@ void STKMeshSceneNode::setReloadEachFrame(bool val)
immediate_draw = true;
}
void STKMeshSceneNode::createGLMeshes(const CustomRenderInfo& cri)
void STKMeshSceneNode::createGLMeshes(RenderInfo* render_info)
{
for (u32 i = 0; i<Mesh->getMeshBufferCount(); ++i)
{
scene::IMeshBuffer* mb = Mesh->getMeshBuffer(i);
const bool affected = cri.m_affected_parts.empty() ||
std::find(cri.m_affected_parts.begin(),
cri.m_affected_parts.end(), i) != cri.m_affected_parts.end();
bool affected = false;
if (mb && render_info)
{
// Test if material is affected by hue change
affected = render_info->isColorizable(i);
}
GLmeshes.push_back(allocateMeshBuffer(mb, m_debug_name,
affected ? cri : CustomRenderInfo()/*default info if not affected*/));
affected ? render_info : NULL));
}
isMaterialInitialized = false;
isGLInitialized = false;
@@ -179,7 +181,7 @@ void STKMeshSceneNode::updateNoGL()
GLMesh &mesh = GLmeshes[i];
Material* material = material_manager->getMaterialFor(mb->getMaterial().getTexture(0), mb);
if (mesh.m_transparent)
if (mesh.m_render_info != NULL && mesh.m_render_info->isTransparent())
{
if (!immediate_draw)
TransparentMesh[TM_ADDITIVE].push_back(&mesh);
@@ -194,8 +196,11 @@ void STKMeshSceneNode::updateNoGL()
else
additive = (TranspMat == TM_ADDITIVE);
}
else if (mesh.m_custom_hue > 0.0f)
else if (mesh.m_render_info != NULL)
{
// For now, put all meshes that support custom render info into
// solid (default) material first, this allowing changing fewer
// shaders
if (!immediate_draw)
MeshSolidMaterial[Material::SHADERTYPE_SOLID].push_back(&mesh);
}

6
src/graphics/stk_mesh_scene_node.hpp
View File

@@ -23,6 +23,8 @@
#include "graphics/shaders.hpp"
#include "utils/ptr_vector.hpp"
class RenderInfo;
class STKMeshSceneNode : public irr::scene::CMeshSceneNode, public STKMeshCommon
{
protected:
@@ -33,7 +35,7 @@ protected:
// Misc passes shaders (glow, displace...)
void drawGlow(const GLMesh &mesh);
void createGLMeshes(const CustomRenderInfo& cri = CustomRenderInfo());
void createGLMeshes(RenderInfo* render_info = NULL);
void cleanGLMeshes();
void setFirstTimeMaterial();
void updatevbo();
@@ -55,7 +57,7 @@ public:
const irr::core::vector3df& rotation = irr::core::vector3df(0, 0, 0),
const irr::core::vector3df& scale = irr::core::vector3df(1.0f, 1.0f, 1.0f),
bool createGLMeshes = true,
const CustomRenderInfo& cri = CustomRenderInfo());
RenderInfo* render_info = NULL);
virtual void render();
virtual void setMesh(irr::scene::IMesh* mesh);
virtual void OnRegisterSceneNode();

2
src/karts/abstract_kart.cpp
View File

@@ -35,7 +35,7 @@ AbstractKart::AbstractKart(const std::string& ident,
int world_kart_id, int position,
const btTransform& init_transform,
PerPlayerDifficulty difficulty,
KartModel::KartRenderType krt)
RenderInfo::KartRenderType krt)
: Moveable()
{
m_world_kart_id = world_kart_id;

4
src/karts/abstract_kart.hpp
View File

@@ -22,7 +22,7 @@
#include <memory>
#include "items/powerup_manager.hpp"
#include "karts/kart_model.hpp"
#include "graphics/render_info.hpp"
#include "karts/moveable.hpp"
#include "karts/controller/kart_control.hpp"
#include "race/race_manager.hpp"
@@ -100,7 +100,7 @@ public:
int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
KartModel::KartRenderType krt);
RenderInfo::KartRenderType krt);
virtual ~AbstractKart();
virtual core::stringw getName() const;
virtual void reset();

3
src/karts/ghost_kart.cpp
View File

@@ -19,6 +19,7 @@
#include "karts/ghost_kart.hpp"
#include "karts/controller/ghost_controller.hpp"
#include "karts/kart_gfx.hpp"
#include "karts/kart_model.hpp"
#include "modes/world.hpp"
#include "LinearMath/btQuaternion.h"
@@ -27,7 +28,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, KartModel::KRT_TRANSPARENT)
PLAYER_DIFFICULTY_NORMAL, RenderInfo::KRT_TRANSPARENT)
{
} // GhostKart

3
src/karts/kart.cpp
View File

@@ -52,6 +52,7 @@
#include "items/projectile_manager.hpp"
#include "karts/controller/end_controller.hpp"
#include "karts/abstract_kart_animation.hpp"
#include "karts/kart_model.hpp"
#include "karts/kart_properties_manager.hpp"
#include "karts/max_speed.hpp"
#include "karts/skidding.hpp"
@@ -92,7 +93,7 @@
Kart::Kart (const std::string& ident, unsigned int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
KartModel::KartRenderType krt)
RenderInfo::KartRenderType krt)
: AbstractKart(ident, world_kart_id, position, init_transform,
difficulty, krt)

2
src/karts/kart.hpp
View File

@@ -232,7 +232,7 @@ public:
Kart(const std::string& ident, unsigned int world_kart_id,
int position, const btTransform& init_transform,
PerPlayerDifficulty difficulty,
KartModel::KartRenderType krt = KartModel::KRT_DEFAULT);
RenderInfo::KartRenderType krt = RenderInfo::KRT_DEFAULT);
virtual ~Kart();
virtual void init(RaceManager::KartType type);
virtual void kartIsInRestNow();

36
src/karts/kart_model.cpp
View File

@@ -136,13 +136,13 @@ KartModel::KartModel(bool is_master)
m_wheel_filename[3] = "";
m_speed_weighted_objects.clear();
m_animated_node = NULL;
m_mesh = NULL;
for(unsigned int i=AF_BEGIN; i<=AF_END; i++)
m_animation_frame[i]=-1;
m_animation_speed = 25;
m_current_animation = AF_DEFAULT;
m_play_non_loop = false;
m_krt = KRT_DEFAULT;
m_krt = RenderInfo::KRT_DEFAULT;
m_render_info = RenderInfo();
} // KartModel
// ----------------------------------------------------------------------------
@@ -246,7 +246,7 @@ KartModel::~KartModel()
assert(!m_is_master);
// Drop the cloned transparent model if created
if (m_krt == KRT_TRANSPARENT)
if (m_krt == RenderInfo::KRT_TRANSPARENT)
{
m_speed_weighted_objects[i].m_model->drop();
}
@@ -289,7 +289,7 @@ KartModel::~KartModel()
* It is also marked not to be a master copy, so attachModel can be called
* for this instance.
*/
KartModel* KartModel::makeCopy(KartModel::KartRenderType krt)
KartModel* KartModel::makeCopy(RenderInfo::KartRenderType krt)
{
// Make sure that we are copying from a master objects, and
// that there is indeed no animated node defined here ...
@@ -310,6 +310,7 @@ KartModel* KartModel::makeCopy(KartModel::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_nitro_emitter_position[0] = m_nitro_emitter_position[0];
km->m_nitro_emitter_position[1] = m_nitro_emitter_position[1];
@@ -334,7 +335,7 @@ KartModel* KartModel::makeCopy(KartModel::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 == KRT_TRANSPARENT)
if (krt == RenderInfo::KRT_TRANSPARENT)
{
// Only clone the mesh if transparent type is used, see #2445
km->m_speed_weighted_objects[i].m_model = irr_driver
@@ -358,11 +359,7 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
assert(!m_is_master);
scene::ISceneNode* node = NULL;
CustomRenderInfo kart_cri = CustomRenderInfo
(m_krt == KRT_BLUE ? 0.66f : m_krt == KRT_RED ? 1.0f : 0.0f, /*m_custom_hue*/
m_krt == KRT_BLUE || m_krt == KRT_RED ? 0.93f : 0, /*m_custom_min_saturation*/
m_krt == KRT_TRANSPARENT ? true : false, /*m_transparent*/
m_krt == KRT_BLUE || m_krt == KRT_RED ? m_mesh : NULL); /*To get m_affected_parts*/
setKartModelRenderInfo(m_krt);
if (animated_models)
{
@@ -371,7 +368,8 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
irr_driver->getSceneManager() );
node = irr_driver->addAnimatedMesh(m_mesh, "kartmesh", NULL/*parent*/, kart_cri);
node = irr_driver->addAnimatedMesh(m_mesh, "kartmesh",
NULL/*parent*/, getRenderInfo());
// as animated mesh are not cheap to render use frustum box culling
if (CVS->isGLSL())
node->setAutomaticCulling(scene::EAC_OFF);
@@ -448,7 +446,8 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
debug_name = m_model_filename + " (kart-model)";
#endif
node = irr_driver->addMesh(main_frame, debug_name, NULL /*parent*/, kart_cri);
node = irr_driver->addMesh(main_frame, debug_name,
NULL /*parent*/, getRenderInfo());
#ifdef DEBUG
node->setName(debug_name.c_str());
@@ -458,11 +457,9 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
// Attach the wheels
for(unsigned int i=0; i<4; i++)
{
// Use the kart custom render info, but discard affected parts
// So all wheels are affected by the info
CustomRenderInfo wheel_cri = CustomRenderInfo(kart_cri);
if(!m_wheel_model[i]) continue;
m_wheel_node[i] = irr_driver->addMesh(m_wheel_model[i], "wheel", node, wheel_cri);
m_wheel_node[i] = irr_driver->addMesh(m_wheel_model[i], "wheel",
node, getRenderInfo());
Vec3 wheel_min, wheel_max;
MeshTools::minMax3D(m_wheel_model[i], &wheel_min, &wheel_max);
m_wheel_graphics_radius[i] = 0.5f*(wheel_max.getY() - wheel_min.getY());
@@ -483,10 +480,8 @@ scene::ISceneNode* KartModel::attachModel(bool animated_models, bool always_anim
obj.m_node = NULL;
if(obj.m_model)
{
// Same for wheels above
CustomRenderInfo swo_cri = CustomRenderInfo(kart_cri);
obj.m_node = irr_driver->addAnimatedMesh(obj.m_model,
"speedweighted", node, swo_cri);
"speedweighted", node, getRenderInfo());
obj.m_node->grab();
obj.m_node->setFrameLoop(m_animation_frame[AF_SPEED_WEIGHTED_START],
@@ -526,6 +521,9 @@ 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);
#undef MOVE_KART_MESHES
#ifdef MOVE_KART_MESHES
// Kart models are not exactly centered. The following code would

29
src/karts/kart_model.hpp
View File

@@ -30,6 +30,7 @@ namespace irr
}
using namespace irr;
#include "graphics/render_info.hpp"
#include "utils/no_copy.hpp"
#include "utils/vec3.hpp"
@@ -116,14 +117,6 @@ public:
AF_END=AF_SPEED_WEIGHTED_END, // Last animation frame
AF_COUNT}; // Number of entries here
enum KartRenderType
{
KRT_DEFAULT,
KRT_RED,
KRT_BLUE,
KRT_TRANSPARENT,
};
private:
/** Which frame number starts/end which animation. */
int m_animation_frame[AF_COUNT];
@@ -238,12 +231,14 @@ private:
/** Pointer to the kart object belonging to this kart model. */
AbstractKart* m_kart;
KartRenderType m_krt;
RenderInfo::KartRenderType m_krt;
RenderInfo m_render_info;
public:
KartModel(bool is_master);
~KartModel();
KartModel* makeCopy(KartRenderType krt);
KartModel* makeCopy(RenderInfo::KartRenderType krt);
void reset();
void loadInfo(const XMLNode &node);
bool loadModels(const KartProperties &kart_properties);
@@ -339,6 +334,20 @@ public:
scene::IAnimatedMeshSceneNode* getAnimatedNode(){ return m_animated_node; }
// ------------------------------------------------------------------------
core::vector3df getHatOffset() { return m_hat_offset; }
// ------------------------------------------------------------------------
void setKartModelRenderInfo(RenderInfo::KartRenderType krt)
{
m_render_info.setHue
(krt == RenderInfo::KRT_BLUE ? 0.66f :
m_krt == RenderInfo::KRT_RED ? 1.0f : 0.0f);
m_render_info.setMinSaturation
(krt == RenderInfo::KRT_BLUE ||
m_krt == RenderInfo::KRT_RED ? 0.93f : 0.0f);
m_render_info.setTransparent
(krt == RenderInfo::KRT_TRANSPARENT ? true : false);
}
// ------------------------------------------------------------------------
RenderInfo* getRenderInfo() { return &m_render_info; }
}; // KartModel
#endif

2
src/karts/kart_properties.hpp
View File

@@ -244,7 +244,7 @@ public:
// ------------------------------------------------------------------------
/** Returns a pointer to the KartModel object. */
KartModel* getKartModelCopy
(KartModel::KartRenderType krt = KartModel::KRT_DEFAULT) const
(RenderInfo::KartRenderType krt = RenderInfo::KRT_DEFAULT) const
{return m_kart_model->makeCopy(krt); }
// ------------------------------------------------------------------------

3
src/modes/soccer_world.cpp
View File

@@ -24,6 +24,7 @@
#include "io/file_manager.hpp"
#include "graphics/central_settings.hpp"
#include "graphics/irr_driver.hpp"
#include "graphics/render_info.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart.hpp"
#include "karts/kart_model.hpp"
@@ -393,7 +394,7 @@ AbstractKart *SoccerWorld::createKart(const std::string &kart_ident, int index,
AbstractKart *new_kart = new Kart(kart_ident, index, position, init_pos,
difficulty, team == SOCCER_TEAM_BLUE ?
KartModel::KRT_BLUE : KartModel::KRT_RED);
RenderInfo::KRT_BLUE : RenderInfo::KRT_RED);
new_kart->init(race_manager->getKartType(index));
Controller *controller = NULL;