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

Moved m_track out of World into a static m_track in Track. Makes

Browse Source 
world smaller and removes a few dependencies on World.
This commit is contained in:
hiker 2016-12-13 07:53:33 +11:00
parent 8785ddf148
commit cd149ab5d7
60 changed files with 264 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/challenges/challenge_data.cpp
View File

@ -436,7 +436,7 @@ bool ChallengeData::isChallengeFulfilled() const
// Single races
// ------------
World *world = World::getWorld();
std::string track_name = world->getTrack()->getIdent();
std::string track_name = Track::getCurrentTrack()->getIdent();
int d = race_manager->getDifficulty();

4
src/graphics/callbacks.cpp
View File

@ -158,10 +158,10 @@ void DisplaceProvider::OnSetConstants(IMaterialRendererServices *srv, int)
void DisplaceProvider::update()
{
if (World::getWorld() == NULL) return;
if (!Track::getCurrentTrack()) return;
const float time = irr_driver->getDevice()->getTimer()->getTime() / 1000.0f;
const float speed = World::getWorld()->getTrack()->getDisplacementSpeed();
const float speed = Track::getCurrentTrack()->getDisplacementSpeed();
float strength = time;
strength = fabsf(noise2d(strength / 10.0f)) * 0.006f + 0.002f;

10
src/graphics/camera.cpp
View File

@ -19,9 +19,8 @@
#include "graphics/camera.hpp"
#include <cmath>
#include "audio/sfx_manager.hpp"
#include "config/stk_config.hpp"
#include "config/user_config.hpp"
#include "graphics/camera_debug.hpp"
#include "graphics/camera_end.hpp"
@ -34,7 +33,6 @@
#include "karts/kart.hpp"
#include "karts/kart_properties.hpp"
#include "karts/skidding.hpp"
#include "modes/world.hpp"
#include "physics/btKart.hpp"
#include "race/race_manager.hpp"
#include "tracks/track.hpp"
@ -44,6 +42,8 @@
#include "ISceneManager.h"
#include <cmath>
std::vector<Camera*> Camera::m_all_cameras;
Camera* Camera::s_active_camera = NULL;
Camera::CameraType Camera::m_default_type = Camera::CM_TYPE_NORMAL;
@ -125,7 +125,7 @@ Camera::Camera(CameraType type, int camera_index, AbstractKart* kart)
setupCamera();
setKart(kart);
m_ambient_light = World::getWorld()->getTrack()->getDefaultAmbientColor();
m_ambient_light = Track::getCurrentTrack()->getDefaultAmbientColor();
reset();
} // Camera
@ -229,7 +229,7 @@ void Camera::setupCamera()
} // switch
m_camera->setFOV(m_fov);
m_camera->setAspectRatio(m_aspect);
m_camera->setFarValue(World::getWorld()->getTrack()->getCameraFar());
m_camera->setFarValue(Track::getCurrentTrack()->getCameraFar());
} // setupCamera
// ----------------------------------------------------------------------------

4
src/graphics/camera_normal.cpp
View File

@ -19,12 +19,12 @@
#include "graphics/camera_normal.hpp"
#include "config/stk_config.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/explosion_animation.hpp"
#include "karts/kart.hpp"
#include "karts/kart_properties.hpp"
#include "karts/skidding.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
// ============================================================================
@ -41,7 +41,7 @@ CameraNormal::CameraNormal(Camera::CameraType type, int camera_index,
: Camera(type, camera_index, kart)
{
m_distance = kart ? kart->getKartProperties()->getCameraDistance() : 1000.0f;
m_ambient_light = World::getWorld()->getTrack()->getDefaultAmbientColor();
m_ambient_light = Track::getCurrentTrack()->getDefaultAmbientColor();
m_smooth_dt = 0.0f;
// TODO: Put these values into a config file

11
src/graphics/draw_calls.cpp
View File

@ -28,7 +28,6 @@
#include "graphics/stk_mesh.hpp"
#include "graphics/stk_mesh_scene_node.hpp"
#include "graphics/vao_manager.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
#include "utils/profiler.hpp"
@ -196,11 +195,9 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
}
// Transparent
const World *world = World::getWorld();
if (world && world->getTrack()->isFogEnabled())
const Track* const track = Track::getCurrentTrack();
if (track&& track->isFogEnabled())
{
const Track * const track = World::getWorld()->getTrack();
// Todo : put everything in a ubo
const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight();
@ -230,9 +227,9 @@ void DrawCalls::handleSTKCommon(scene::ISceneNode *Node,
// Use sun color to determine custom alpha for ghost karts
float custom_alpha = 1.0f;
if (World::getWorld())
if (track)
{
const video::SColor& c = World::getWorld()->getTrack()->getSunColor();
const video::SColor& c = track->getSunColor();
float y = 0.2126f * c.getRed() + 0.7152f * c.getGreen() + 0.0722f * c.getBlue();
custom_alpha = y > 128.0f ? 0.5f : 0.35f;
}

4
src/graphics/geometry_passes.cpp
View File

@ -261,8 +261,8 @@ void AbstractGeometryPasses::renderTransparent(const DrawCalls& draw_calls,
if (CVS->isARBBaseInstanceUsable())
glBindVertexArray(VAOManager::getInstance()->getVAO(video::EVT_STANDARD));
const World *world = World::getWorld();
if (world && world->getTrack()->isFogEnabled())
const Track* const track = Track::getCurrentTrack();
if (track && track->isFogEnabled())
{
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
renderTransparenPass<Shaders::TransparentFogShader, video::EVT_STANDARD,

7
src/graphics/lighting_passes.cpp
View File

@ -621,7 +621,8 @@ void LightingPasses::renderLights( bool has_shadow,
}
// Render sunlight if and only if track supports shadow
if (!World::getWorld() || World::getWorld()->getTrack()->hasShadows())
const Track* const track = Track::getCurrentTrack();
if (!track|| track->hasShadows())
{
ScopedGPUTimer timer(irr_driver->getGPUTimer(Q_SUN));
if (World::getWorld() && CVS->isShadowEnabled() && has_shadow)
@ -664,7 +665,7 @@ void LightingPasses::renderLights( bool has_shadow,
// ----------------------------------------------------------------------------
void LightingPasses::renderAmbientScatter(GLuint depth_stencil_texture)
{
const Track * const track = World::getWorld()->getTrack();
const Track * const track = Track::getCurrentTrack();
// This function is only called once per frame - thus no need for setters.
float start = track->getFogStart() + .001f;
@ -694,7 +695,7 @@ void LightingPasses::renderLightsScatter(GLuint depth_stencil_texture,
glClearColor(0., 0., 0., 0.);
glClear(GL_COLOR_BUFFER_BIT);
const Track * const track = World::getWorld()->getTrack();
const Track * const track = Track::getCurrentTrack();
// This function is only called once per frame - thus no need for setters.
float start = track->getFogStart() + .001f;

5
src/graphics/mesh_tools.cpp
View File

@ -464,10 +464,11 @@ scene::IMesh* MeshTools::createMeshWithTangents(scene::IMesh* mesh,
scene::SAnimatedMesh* amesh = new scene::SAnimatedMesh(clone);
clone->drop();
meshCache->addMesh(path, amesh);
if (World::getWorld())
Track* track = Track::getCurrentTrack();
if (track)
{
irr_driver->grabAllTextures(amesh);
World::getWorld()->getTrack()->addCachedMesh(amesh);
track->addCachedMesh(amesh);
return amesh;
}
amesh->drop();

7
src/graphics/post_processing.cpp
View File

@ -1300,7 +1300,7 @@ void PostProcessing::renderGodRays(scene::ICameraSceneNode * const camnode,
const FrameBuffer &quarter1_fbo,
const FrameBuffer &quarter2_fbo)
{
Track* track = World::getWorld()->getTrack();
Track* track = Track::getCurrentTrack();
glEnable(GL_DEPTH_TEST);
// Grab the sky
@ -1448,8 +1448,9 @@ FrameBuffer *PostProcessing::render(scene::ICameraSceneNode * const camnode,
}
bool hasgodrays = false;
if (World::getWorld() != NULL)
hasgodrays = World::getWorld()->getTrack()->hasGodRays();
const Track * const track = Track::getCurrentTrack();
if (track)
hasgodrays = track->hasGodRays();
if (isRace && UserConfigParams::m_light_shaft && hasgodrays)
{

8
src/graphics/shader_based_renderer.cpp
View File

@ -429,8 +429,8 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
}
// Render ambient scattering
const World *world = World::getWorld();
if (CVS->isDefferedEnabled() && world && world->getTrack()->isFogEnabled())
const Track * const track = Track::getCurrentTrack();
if (CVS->isDefferedEnabled() && track && track->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Ambient scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
@ -446,7 +446,7 @@ void ShaderBasedRenderer::renderScene(scene::ICameraSceneNode * const camnode,
}
// Render discrete lights scattering
if (CVS->isDefferedEnabled() && world && world->getTrack()->isFogEnabled())
if (CVS->isDefferedEnabled() && track && track->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- PointLight Scatter", 0xFF, 0x00, 0x00);
ScopedGPUTimer Timer(irr_driver->getGPUTimer(Q_FOG));
@ -801,7 +801,7 @@ void ShaderBasedRenderer::render(float dt)
m_post_processing->begin();
World *world = World::getWorld(); // Never NULL.
Track *track = world->getTrack();
Track *track = Track::getCurrentTrack();
RaceGUIBase *rg = world->getRaceGUI();
if (rg) rg->update(dt);

10
src/graphics/shadow_matrices.cpp
View File

@ -355,7 +355,8 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
m_sun_ortho_matrices.clear();
const core::matrix4 &sun_cam_view_matrix = m_sun_cam->getViewMatrix();
if (World::getWorld() && World::getWorld()->getTrack())
const Track* const track = Track::getCurrentTrack();
if (track)
{
float FarValues[] =
{
@ -423,13 +424,12 @@ void ShadowMatrices::computeMatrixesAndCameras(scene::ICameraSceneNode *const ca
}
// Rsm Matrix and camera
if (!m_rsm_matrix_initialized &&
World::getWorld()->getTrack()->getPtrTriangleMesh())
if (!m_rsm_matrix_initialized && track->getPtrTriangleMesh())
{
// Compute track extent
Vec3 vmin, vmax;
World::getWorld()->getTrack()->getTriangleMesh().getCollisionShape()
.getAabb(btTransform::getIdentity(), vmin, vmax);
track->getTriangleMesh().getCollisionShape()
.getAabb(btTransform::getIdentity(), vmin, vmax);
core::aabbox3df trackbox(vmin.toIrrVector(), vmax.toIrrVector() -
core::vector3df(0, 30, 0));

16
src/graphics/stk_mesh_scene_node.cpp
View File

@ -512,8 +512,8 @@ void STKMeshSceneNode::render()
else
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
const World* world = World::getWorld();
if (world && world->getTrack()->isFogEnabled())
const Track * const track = Track::getCurrentTrack();
if (track && track->isFogEnabled())
{
Shaders::TransparentFogShader::getInstance()->use();
for (unsigned i = 0; i < GLmeshes.size(); i++)
@ -524,19 +524,17 @@ void STKMeshSceneNode::render()
GLenum itype = mesh.IndexType;
size_t count = mesh.IndexCount;
const Track * const track = World::getWorld()->getTrack();
// This function is only called once per frame - thus no need for setters.
const float fogmax = track->getFogMax();
const float startH = track->getFogStartHeight();
const float endH = track->getFogEndHeight();
const float start = track->getFogStart();
const float end = track->getFogEnd();
const float endH = track->getFogEndHeight();
const float start = track->getFogStart();
const float end = track->getFogEnd();
const video::SColor tmpcol = track->getFogColor();
video::SColorf col(tmpcol.getRed() / 255.0f,
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f);
tmpcol.getGreen() / 255.0f,
tmpcol.getBlue() / 255.0f);
compressTexture(mesh.textures[0], true);
#if !defined(USE_GLES2)

8
src/items/attachment.cpp
View File

@ -573,10 +573,10 @@ void Attachment::update(float dt)
Vec3 hit_point;
Vec3 normal;
const Material* material_hit;
World* world = World::getWorld();
world->getTrack()->getTriangleMesh().castRay(m_kart->getXYZ(),
m_kart->getTrans().getBasis() * Vec3(0, -10000, 0), &hit_point,
&material_hit, &normal);
Track::getCurrentTrack()->getTriangleMesh().castRay(m_kart->getXYZ(),
m_kart->getTrans().getBasis() * Vec3(0, -10000, 0),
&hit_point,&material_hit, &normal );
// This can happen if the kart is 'over nothing' when dropping
// the bubble gum
if(material_hit)

6
src/items/flyable.cpp
View File

@ -371,7 +371,7 @@ bool Flyable::updateAndDelete(float dt)
const Vec3 &xyz=getXYZ();
// Check if the flyable is outside of the track. If so, explode it.
const Vec3 *min, *max;
World::getWorld()->getTrack()->getAABB(&min, &max);
Track::getCurrentTrack()->getAABB(&min, &max);
// I have seen that the bullet AABB can be slightly different from the
// one computed here - I assume due to minor floating point errors
@ -515,13 +515,13 @@ void Flyable::explode(AbstractKart *kart_hit, PhysicalObject *object,
// The explosion animation will register itself with the kart
// and will free it later.
ExplosionAnimation::create(kart, getXYZ(), kart==kart_hit);
if(kart==kart_hit && world->getTrack()->isArena())
if(kart==kart_hit && Track::getCurrentTrack()->isArena())
{
world->kartHit(kart->getWorldKartId());
}
}
}
world->getTrack()->handleExplosion(getXYZ(), object, secondary_hits);
Track::getCurrentTrack()->handleExplosion(getXYZ(), object,secondary_hits);
} // explode
// ----------------------------------------------------------------------------

7
src/items/item.cpp
View File

@ -76,8 +76,7 @@ Item::Item(ItemType type, const Vec3& xyz, const Vec3& normal,
debug_name += m_type;
m_node->setName(debug_name.c_str());
#endif
World::getWorld()->getTrack()->adjustForFog(m_node);
Track::getCurrentTrack()->adjustForFog(m_node);
m_node->setAutomaticCulling(scene::EAC_FRUSTUM_BOX);
m_node->setPosition(xyz.toIrrVector());
Vec3 hpr;
@ -195,7 +194,7 @@ void Item::switchTo(ItemType type, scene::IMesh *mesh, scene::IMesh *lowmesh)
irr_driver->applyObjectPassShader(m_node->getAllNodes()[0]);
World::getWorld()->getTrack()->adjustForFog(m_node);
Track::getCurrentTrack()->adjustForFog(m_node);
#endif
} // switchTo
@ -224,7 +223,7 @@ void Item::switchBack()
((scene::IMeshSceneNode*)node)->setMesh(m_original_lowmesh);
}
World::getWorld()->getTrack()->adjustForFog(m_node);
Track::getCurrentTrack()->adjustForFog(m_node);
Vec3 hpr;
hpr.setHPR(m_original_rotation);
m_node->setRotation(hpr.toIrrHPR());

4
src/items/item_manager.cpp
View File

@ -30,7 +30,6 @@
#include "io/file_manager.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/controller/spare_tire_ai.hpp"
#include "modes/linear_world.hpp"
#include "network/network_config.hpp"
#include "network/race_event_manager.hpp"
#include "physics/triangle_mesh.hpp"
@ -577,8 +576,7 @@ bool ItemManager::randomItemsForArena(const AlignedArray<btTransform>& pos)
const Material* m;
Vec3 normal;
Vec3 hit_point;
const TriangleMesh& tm =
World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh& tm = Track::getCurrentTrack()->getTriangleMesh();
bool success = tm.castRay(loc, an->getCenter() + (-10000*quad_normal),
&hit_point, &m, &normal);

6
src/items/powerup.cpp
View File

@ -279,8 +279,10 @@ void Powerup::use()
const Material* material_hit;
Vec3 pos = m_kart->getXYZ();
Vec3 to = pos+ m_kart->getTrans().getBasis() * Vec3(0, -10000, 0);
world->getTrack()->getTriangleMesh().castRay(pos, to, &hit_point,
&material_hit, &normal);
Track::getCurrentTrack()->getTriangleMesh().castRay(pos, to,
&hit_point,
&material_hit,
&normal);
// This can happen if the kart is 'over nothing' when dropping
// the bubble gum
if(!material_hit)

11
src/items/rubber_ball.cpp
View File

@ -492,7 +492,7 @@ void RubberBall::interpolate(Vec3 *next_xyz, float dt)
*/
bool RubberBall::checkTunneling()
{
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
Vec3 hit_point;
const Material *material;
@ -595,9 +595,10 @@ float RubberBall::updateHeight()
* \returns The distance to the terrain element found by raycast in the up
direction. If no terrain found, it returns 99990
*/
float RubberBall::getTunnelHeight(const Vec3 &next_xyz, const float vertical_offset) const
float RubberBall::getTunnelHeight(const Vec3 &next_xyz,
const float vertical_offset) const
{
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
Vec3 from(next_xyz + vertical_offset*getNormal());
Vec3 to(next_xyz + 10000.0f*getNormal());
Vec3 hit_point;
@ -623,7 +624,7 @@ void RubberBall::updateDistanceToTarget()
m_distance_to_target = target_distance - ball_distance;
if(m_distance_to_target < 0)
{
m_distance_to_target += world->getTrack()->getTrackLength();
m_distance_to_target += Track::getCurrentTrack()->getTrackLength();
}
if(UserConfigParams::logFlyable())
Log::debug("[RubberBall]", "ball %d: target %f %f %f distance_2_target %f",
@ -652,7 +653,7 @@ void RubberBall::updateDistanceToTarget()
// new target. If the new distance is nearly the full track
// length, assume that the rubber ball has overtaken the
// original target, and start deleting it.
if(m_distance_to_target > 0.9f * world->getTrack()->getTrackLength())
if(m_distance_to_target > 0.9f * Track::getCurrentTrack()->getTrackLength())
{
m_delete_timer = m_st_delete_time;
#ifdef PRINT_BALL_REMOVE_INFO

3
src/karts/controller/ai_base_lap_controller.cpp
View File

@ -26,6 +26,7 @@
#include "karts/controller/ai_properties.hpp"
#include "modes/linear_world.hpp"
#include "tracks/drive_graph.hpp"
#include "tracks/track.hpp"
#include "utils/constants.hpp"
@ -90,7 +91,7 @@ AIBaseLapController::AIBaseLapController(AbstractKart *kart)
race_manager->getMinorMode()!=RaceManager::MINOR_MODE_SOCCER)
{
m_world = dynamic_cast<LinearWorld*>(World::getWorld());
m_track = m_world->getTrack();
m_track = Track::getCurrentTrack();
computePath();
}
else

3
src/karts/controller/battle_ai.cpp
View File

@ -27,6 +27,7 @@
#include "karts/controller/spare_tire_ai.hpp"
#include "modes/three_strikes_battle.hpp"
#include "tracks/arena_graph.hpp"
#include "tracks/track.hpp"
#ifdef AI_DEBUG
#include "irrlicht.h"
@ -47,7 +48,7 @@ BattleAI::BattleAI(AbstractKart *kart)
m_debug_sphere_next->setVisible(true);
#endif
m_world = dynamic_cast<ThreeStrikesBattle*>(World::getWorld());
m_track = m_world->getTrack();
m_track = Track::getCurrentTrack();
// Don't call our own setControllerName, since this will add a
// billboard showing 'AIBaseController' to the kart.

2
src/karts/controller/local_player_controller.cpp
View File

@ -72,7 +72,7 @@ LocalPlayerController::LocalPlayerController(AbstractKart *kart,
m_full_sound = SFXManager::get()->createSoundSource("energy_bar_full");
// Attach Particle System
Track *track = World::getWorld()->getTrack();
Track *track = Track::getCurrentTrack();
#ifndef SERVER_ONLY
if (UserConfigParams::m_weather_effects &&
track->getSkyParticles() != NULL)

2
src/karts/controller/skidding_ai.cpp
View File

@ -1694,7 +1694,7 @@ void SkiddingAI::handleNitroAndZipper()
{
float diff = DriveGraph::get()->getDistanceFromStart(last)
- DriveGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
if(diff<0) diff += Track::getCurrentTrack()->getTrackLength();
if(diff>m_ai_properties->m_straight_length_for_zipper)
m_controls->setFire(true);
}

3
src/karts/controller/soccer_ai.cpp
View File

@ -25,6 +25,7 @@
#include "karts/kart_properties.hpp"
#include "modes/soccer_world.hpp"
#include "tracks/arena_graph.hpp"
#include "tracks/track.hpp"
#ifdef AI_DEBUG
#include "irrlicht.h"
@ -59,7 +60,7 @@ SoccerAI::SoccerAI(AbstractKart *kart)
#endif
m_world = dynamic_cast<SoccerWorld*>(World::getWorld());
m_track = m_world->getTrack();
m_track = Track::getCurrentTrack();
m_cur_team = m_world->getKartTeam(m_kart->getWorldKartId());
m_opp_team = (m_cur_team == SOCCER_TEAM_BLUE ?
SOCCER_TEAM_RED : SOCCER_TEAM_BLUE);

2
src/karts/controller/test_ai.cpp
View File

@ -1743,7 +1743,7 @@ void SkiddingAI::handleNitroAndZipper()
{
float diff = DriveGraph::get()->getDistanceFromStart(last)
- DriveGraph::get()->getDistanceFromStart(m_track_node);
if(diff<0) diff+=World::getWorld()->getTrack()->getTrackLength();
if (diff < 0) diff += Track::getCurrentTrack()->getTrackLength();
if(diff>m_ai_properties->m_straight_length_for_zipper)
m_controls->setFire(true);
}

5
src/karts/explosion_animation.cpp
View File

@ -24,7 +24,6 @@
#include "items/attachment.hpp"
#include "karts/abstract_kart.hpp"
#include "karts/kart_properties.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
/** A static create function that does only create an explosion if
@ -91,7 +90,7 @@ ExplosionAnimation::ExplosionAnimation(AbstractKart *kart,
// Since v(explosion_time*0.5) = 0, the following forumla computes
// the right initial velocity for a kart to land back after
// the specified time.
m_velocity = 0.5f * m_timer * World::getWorld()->getTrack()->getGravity();
m_velocity = 0.5f * m_timer * Track::getCurrentTrack()->getGravity();
m_curr_rotation.setHeading(m_kart->getHeading());
m_curr_rotation.setPitch(m_kart->getPitch());
@ -141,7 +140,7 @@ ExplosionAnimation::~ExplosionAnimation()
*/
void ExplosionAnimation::update(float dt)
{
m_velocity -= dt*World::getWorld()->getTrack()->getGravity();
m_velocity -= dt*Track::getCurrentTrack()->getGravity();
m_xyz = m_xyz + dt*m_velocity*m_normal;
// Make sure the kart does not end up under the track

14
src/karts/kart.cpp
View File

@ -673,7 +673,7 @@ void Kart::createPhysics()
m_vehicle_raycaster =
new btKartRaycaster(World::getWorld()->getPhysics()->getPhysicsWorld(),
stk_config->m_smooth_normals &&
World::getWorld()->getTrack()->smoothNormals());
Track::getCurrentTrack()->smoothNormals());
m_vehicle = new btKart(m_body, m_vehicle_raycaster, this);
// never deactivate the vehicle
@ -1360,7 +1360,7 @@ void Kart::update(float dt)
const float roll = quad_normal.angle
((Vec3(0, 1, 0).rotate(q.getAxis(), q.getAngle())));
if (World::getWorld()->getTrack()->isAutoRescueEnabled() &&
if (Track::getCurrentTrack()->isAutoRescueEnabled() &&
(!m_terrain_info->getMaterial() ||
!m_terrain_info->getMaterial()->hasGravity()) &&
!has_animation_before && fabs(roll) > 60 * DEGREE_TO_RAD &&
@ -1420,14 +1420,14 @@ void Kart::update(float dt)
{
if (!m_flying)
{
float g = World::getWorld()->getTrack()->getGravity();
float g = Track::getCurrentTrack()->getGravity();
Vec3 gravity(0, -g, 0);
btRigidBody *body = getVehicle()->getRigidBody();
body->setGravity(gravity);
}
// let kart fall a bit before rescuing
const Vec3 *min, *max;
World::getWorld()->getTrack()->getAABB(&min, &max);
Track::getCurrentTrack()->getAABB(&min, &max);
if((min->getY() - getXYZ().getY() > 17 || dist_to_sector > 25) && !m_flying &&
!getKartAnimation())
@ -1437,7 +1437,7 @@ void Kart::update(float dt)
{
if (!m_flying)
{
float g = World::getWorld()->getTrack()->getGravity();
float g = Track::getCurrentTrack()->getGravity();
Vec3 gravity(0.0f, -g, 0.0f);
btRigidBody *body = getVehicle()->getRigidBody();
// If the material should overwrite the gravity,
@ -1519,7 +1519,7 @@ void Kart::update(float dt)
m_kart_model->getAnimation() == KartModel::AF_DEFAULT)
{
float v = getVelocity().getY();
float force = World::getWorld()->getTrack()->getGravity();
float force = Track::getCurrentTrack()->getGravity();
// Velocity / force is the time it takes to reach the peak
// of the jump (i.e. when vertical speed becomes 0). Assuming
// that jump start height and end height are the same, it will
@ -2027,7 +2027,7 @@ void Kart::crashed(const Material *m, const Vec3 &normal)
else if(m_kart_properties->getTerrainImpulseType()
==KartProperties::IMPULSE_TO_DRIVELINE &&
lw && m_vehicle->getCentralImpulseTime()<=0 &&
World::getWorld()->getTrack()->isPushBackEnabled())
Track::getCurrentTrack()->isPushBackEnabled())
{
int sector = lw->getSectorForKart(this);
if(sector!=Graph::UNKNOWN_SECTOR)

3
src/karts/moveable.cpp
View File

@ -23,7 +23,6 @@
#include "graphics/irr_driver.hpp"
#include "graphics/material.hpp"
#include "graphics/material_manager.hpp"
#include "modes/world.hpp"
#include "tracks/track.hpp"
#include "ISceneNode.h"
@ -118,7 +117,7 @@ void Moveable::flyDown()
// ----------------------------------------------------------------------------
void Moveable::stopFlying()
{
m_body->setGravity(btVector3(0.0, -World::getWorld()->getTrack()->getGravity(), 0.0));
m_body->setGravity(btVector3(0.0, -Track::getCurrentTrack()->getGravity(), 0.0));
} // stopFlying
//-----------------------------------------------------------------------------

6
src/karts/skidding.cpp
View File

@ -287,7 +287,7 @@ void Skidding::update(float dt, bool is_on_ground,
// be displayed, update the data
if(m_remaining_jump_time>0)
{
m_jump_speed -= World::getWorld()->getTrack()->getGravity()*dt;
m_jump_speed -= Track::getCurrentTrack()->getGravity()*dt;
m_gfx_jump_offset += m_jump_speed * dt;
m_remaining_jump_time -= dt;
if(m_remaining_jump_time<0)
@ -339,13 +339,13 @@ void Skidding::update(float dt, bool is_on_ground,
// the same time to come down again), based on v = gravity * t.
// Then use this speed to determine the impulse necessary to
// reach this speed.
float v = World::getWorld()->getTrack()->getGravity()
float v = Track::getCurrentTrack()->getGravity()
* 0.5f * kp->getSkidPhysicalJumpTime();
btVector3 imp(0, v / m_kart->getBody()->getInvMass(),0);
m_kart->getVehicle()->getRigidBody()->applyCentralImpulse(imp);
// Some karts might use a graphical-only jump. Set it up:
m_jump_speed = World::getWorld()->getTrack()->getGravity()
m_jump_speed = Track::getCurrentTrack()->getGravity()
* 0.5f * kp->getSkidGraphicalJumpTime();
m_remaining_jump_time = kp->getSkidGraphicalJumpTime();

17
src/modes/cutscene_world.cpp
View File

@ -75,7 +75,7 @@ void CutsceneWorld::init()
dynamic_cast<CutsceneGUI*>(m_race_gui)->setFadeLevel(1.0f);
getTrack()->startMusic();
Track::getCurrentTrack()->startMusic();
m_duration = -1.0f;
@ -85,7 +85,8 @@ void CutsceneWorld::init()
m_camera->bindTargetAndRotation(true); // no "look-at"
// --- Build list of sounds to play at certain frames
PtrVector<TrackObject>& objects = m_track->getTrackObjectManager()->getObjects();
PtrVector<TrackObject>& objects = Track::getCurrentTrack()
->getTrackObjectManager()->getObjects();
for (TrackObject* curr : objects)
{
if (curr->getType() == "particle-emitter" &&
@ -199,7 +200,8 @@ void CutsceneWorld::update(float dt)
{
//printf("INITIAL TIME for CutsceneWorld\n");
PtrVector<TrackObject>& objects = m_track->getTrackObjectManager()->getObjects();
PtrVector<TrackObject>& objects = Track::getCurrentTrack()
->getTrackObjectManager()->getObjects();
TrackObject* curr;
for_in(curr, objects)
{
@ -213,7 +215,8 @@ void CutsceneWorld::update(float dt)
{
m_second_reset = false;
PtrVector<TrackObject>& objects = m_track->getTrackObjectManager()->getObjects();
PtrVector<TrackObject>& objects = Track::getCurrentTrack()
->getTrackObjectManager()->getObjects();
TrackObject* curr;
for_in(curr, objects)
{
@ -265,7 +268,8 @@ void CutsceneWorld::update(float dt)
//printf("Estimated current frame : %f\n", curr_frame);
const std::vector<Subtitle>& subtitles = m_track->getSubtitles();
const std::vector<Subtitle>& subtitles = Track::getCurrentTrack()
->getSubtitles();
bool foundSubtitle = false;
for (unsigned int n = 0; n < subtitles.size(); n++)
{
@ -287,7 +291,8 @@ void CutsceneWorld::update(float dt)
World::update((float)dt);
World::updateTrack((float)dt);
PtrVector<TrackObject>& objects = m_track->getTrackObjectManager()->getObjects();
PtrVector<TrackObject>& objects = Track::getCurrentTrack()
->getTrackObjectManager()->getObjects();
TrackObject* curr;
for_in(curr, objects)
{

2
src/modes/easter_egg_hunt.cpp
View File

@ -126,7 +126,7 @@ void EasterEggHunt::readData(const std::string &filename)
race_manager->getDifficultyAsString(act_difficulty).c_str());
continue;
}
World::getTrack()->itemCommand(egg);
Track::getCurrentTrack()->itemCommand(egg);
m_number_of_eggs++;
} // for i <num_nodes

4
src/modes/follow_the_leader.cpp
View File

@ -105,12 +105,12 @@ int FollowTheLeaderRace::getScoreForPosition(int p)
const btTransform &FollowTheLeaderRace::getStartTransform(int index)
{
if (index == 0) // Leader start position
return m_track->getStartTransform(index);
return Track::getCurrentTrack()->getStartTransform(index);
// Otherwise the karts will start at the rear starting positions
int start_index = stk_config->m_max_karts
- race_manager->getNumberOfKarts() + index;
return m_track->getStartTransform(start_index);
return Track::getCurrentTrack()->getStartTransform(start_index);
} // getStartTransform
//-----------------------------------------------------------------------------

19
src/modes/linear_world.cpp
View File

@ -61,8 +61,8 @@ void LinearWorld::init()
{
WorldWithRank::init();
assert(!m_track->isArena());
assert(!m_track->isSoccer());
assert(!Track::getCurrentTrack()->isArena());
assert(!Track::getCurrentTrack()->isSoccer());
m_last_lap_sfx_played = false;
m_last_lap_sfx_playing = false;
@ -102,7 +102,7 @@ void LinearWorld::reset()
// the track length must be extended (to avoid negative numbers in
// estimateFinishTimeForKart()). On the other hand future game modes
// might not follow this rule, so check the distance for all karts here:
m_distance_increase = m_track->getTrackLength();
m_distance_increase = Track::getCurrentTrack()->getTrackLength();
for(unsigned int i=0; i<kart_amount; i++)
{
m_distance_increase = std::min(m_distance_increase,
@ -112,8 +112,8 @@ void LinearWorld::reset()
// be increased to avoid negative values in estimateFinishTimeForKart
// Increase this value somewhat in case that a kart drivess/slides
// backwards a little bit at start.
m_distance_increase = m_track->getTrackLength() - m_distance_increase
+ 5.0f;
m_distance_increase = Track::getCurrentTrack()->getTrackLength()
- m_distance_increase + 5.0f;
if(m_distance_increase<0) m_distance_increase = 1.0f; // shouldn't happen
@ -187,7 +187,7 @@ void LinearWorld::update(float dt)
continue;
getTrackSector(n)->update(kart->getFrontXYZ());
kart_info.m_overall_distance = kart_info.m_race_lap
* m_track->getTrackLength()
* Track::getCurrentTrack()->getTrackLength()
+ getDistanceDownTrackForKart(kart->getWorldKartId());
} // for n
@ -277,7 +277,8 @@ void LinearWorld::newLap(unsigned int kart_index)
kart_info.m_time_at_last_lap=getTime();
kart_info.m_race_lap++;
m_kart_info[kart_index].m_overall_distance =
m_kart_info[kart_index].m_race_lap * m_track->getTrackLength()
m_kart_info[kart_index].m_race_lap
* Track::getCurrentTrack()->getTrackLength()
+ getDistanceDownTrackForKart(kart->getWorldKartId());
}
// Last lap message (kart_index's assert in previous block already)
@ -549,7 +550,7 @@ float LinearWorld::estimateFinishTimeForKart(AbstractKart* kart)
const KartInfo &kart_info = m_kart_info[kart->getWorldKartId()];
float full_distance = race_manager->getNumLaps()
* m_track->getTrackLength();
* Track::getCurrentTrack()->getTrackLength();
if(full_distance == 0)
full_distance = 1.0f; // For 0 lap races avoid warning below
@ -651,7 +652,7 @@ btTransform LinearWorld::getRescueTransform(unsigned int index) const
else q1 = btQuaternion(Vec3(0,1,0),0);
// First apply the heading change, than the 'parallelisation' to the plane
btQuaternion q2(btVector3(0,1,0), m_track->getAngle(index));
btQuaternion q2(btVector3(0,1,0), Track::getCurrentTrack()->getAngle(index));
pos.setRotation(q1*q2);
return pos;
} // getRescueTransform

4
src/modes/overworld.cpp
View File

@ -112,7 +112,7 @@ void OverWorld::update(float dt)
setPhase(RACE_PHASE);
// Normally done in WorldStatus::update(), during phase SET_PHASE,
// so we have to start music 'manually', since we skip all phases.
World::getWorld()->getTrack()->startMusic();
Track::getCurrentTrack()->startMusic();
if (UserConfigParams::m_music)
music_manager->startMusic();
@ -212,7 +212,7 @@ void OverWorld::createRaceGUI()
void OverWorld::onFirePressed(Controller* who)
{
const std::vector<OverworldChallenge>& challenges =
m_track->getChallengeList();
Track::getCurrentTrack()->getChallengeList();
AbstractKart* k = getKart(0);
Vec3 kart_xyz = k->getXYZ();

4
src/modes/profile_world.cpp
View File

@ -244,7 +244,7 @@ void ProfileWorld::enterRaceOverState()
all_groups.insert(kart->getController()->getControllerName());
float distance = (float)(m_profile_mode==PROFILE_LAPS
? race_manager->getNumLaps() : 1);
distance *= m_track->getTrackLength();
distance *= Track::getCurrentTrack()->getTrackLength();
ss << distance/kart->getFinishTime() << " " << kart->getTopSpeed() << " ";
ss << kart->getSkiddingTime() << " " << kart->getRescueTime() << " ";
ss << kart->getRescueCount() << " " << kart->getBrakeCount() << " ";
@ -300,7 +300,7 @@ void ProfileWorld::enterRaceOverState()
float distance = (float)(m_profile_mode==PROFILE_LAPS
? race_manager->getNumLaps() : 1);
distance *= m_track->getTrackLength();
distance *= Track::getCurrentTrack()->getTrackLength();
Log::verbose("profile",
"%s %4.2f %3.2f %6.2f %4.2f %3d %5d %4.2f %3d %3d %3d %3d %3d %3d %5d %4.2f",

11
src/modes/soccer_world.cpp
View File

@ -91,13 +91,14 @@ void SoccerWorld::init()
m_goal_target = race_manager->getMaxGoal();
m_goal_sound = SFXManager::get()->createSoundSource("goal_scored");
if (m_track->hasNavMesh())
Track *track = Track::getCurrentTrack();
if (track->hasNavMesh())
{
// Init track sector for ball if navmesh is found
m_ball_track_sector = new TrackSector();
}
TrackObjectManager* tom = getTrack()->getTrackObjectManager();
TrackObjectManager* tom = track->getTrackObjectManager();
assert(tom);
PtrVector<TrackObject>& objects = tom->getObjects();
for (unsigned int i = 0; i < objects.size(); i++)
@ -150,7 +151,7 @@ void SoccerWorld::reset()
m_goal_sound->stop();
}
if (m_track->hasNavMesh())
if (Track::getCurrentTrack()->hasNavMesh())
{
m_ball_track_sector->reset();
}
@ -181,7 +182,7 @@ const std::string& SoccerWorld::getIdent() const
void SoccerWorld::update(float dt)
{
updateBallPosition(dt);
if (m_track->hasNavMesh())
if (Track::getCurrentTrack()->hasNavMesh())
{
updateSectorForKarts();
updateAIData();
@ -457,7 +458,7 @@ void SoccerWorld::updateBallPosition(float dt)
m_ball_body->getLinearVelocity().getZ());
}
if (m_track->hasNavMesh())
if (Track::getCurrentTrack()->hasNavMesh())
{
m_ball_track_sector
->update(getBallPosition(), true/*ignore_vertical*/);

8
src/modes/three_strikes_battle.cpp
View File

@ -149,7 +149,7 @@ void ThreeStrikesBattle::reset()
TrackObject *obj;
for_in(obj, m_tires)
{
m_track->getTrackObjectManager()->removeObject(obj);
Track::getCurrentTrack()->getTrackObjectManager()->removeObject(obj);
}
m_tires.clearWithoutDeleting();
@ -357,7 +357,7 @@ void ThreeStrikesBattle::update(float dt)
WorldWithRank::updateTrack(dt);
spawnSpareTireKarts();
if (m_track->hasNavMesh())
if (Track::getCurrentTrack()->hasNavMesh())
updateSectorForKarts();
// insert blown away tire(s) now if was requested
@ -419,7 +419,7 @@ void ThreeStrikesBattle::update(float dt)
"movable", tire_presentation,
true /* is_dynamic */,
&physics_settings);
getTrack()->getTrackObjectManager()->insertObject(tire_obj);
Track::getCurrentTrack()->getTrackObjectManager()->insertObject(tire_obj);
// FIXME: orient the force relative to kart orientation
tire_obj->getPhysicalObject()->getBody()
@ -730,7 +730,7 @@ void ThreeStrikesBattle::loadCustomModels()
m_karts.push_back(sta);
race_manager->addSpareTireKart(sta_list[i]);
m_track->adjustForFog(sta->getNode());
Track::getCurrentTrack()->adjustForFog(sta->getNode());
// Copy STA pointer to m_spare_tire_karts array, allowing them
// to respawn easily

3
src/modes/tutorial_world.cpp
View File

@ -29,7 +29,8 @@ TutorialWorld::TutorialWorld()
unsigned int TutorialWorld::getRescuePositionIndex(AbstractKart *kart)
{
const int start_spots_amount = getTrack()->getNumberOfStartPositions();
const int start_spots_amount =
Track::getCurrentTrack()->getNumberOfStartPositions();
assert(start_spots_amount > 0);
float closest_distance = 999999.0f;

43
src/modes/world.cpp
View File

@ -125,7 +125,6 @@ World::World() : WorldStatus()
m_race_gui = NULL;
m_saved_race_gui = NULL;
m_use_highscores = true;
m_track = NULL;
m_schedule_pause = false;
m_schedule_unpause = false;
m_schedule_exit_race = false;
@ -168,9 +167,9 @@ void World::init()
RewindManager::create();
// Grab the track file
m_track = track_manager->getTrack(race_manager->getTrackName());
Track *track = track_manager->getTrack(race_manager->getTrackName());
m_script_engine = new Scripting::ScriptEngine();
if(!m_track)
if(!track)
{
std::ostringstream msg;
msg << "Track '" << race_manager->getTrackName()
@ -178,7 +177,7 @@ void World::init()
throw std::runtime_error(msg.str());
}
std::string script_path = World::getWorld()->getTrack()->getTrackFile("scripting.as");
std::string script_path = track->getTrackFile("scripting.as");
m_script_engine->loadScript(script_path, true);
// Create the physics
@ -189,7 +188,8 @@ void World::init()
// Load the track models - this must be done before the karts so that the
// karts can be positioned properly on (and not in) the tracks.
m_track->loadTrackModel(race_manager->getReverseTrack());
// This also defines the static Track::getCurrentTrack function.
track->loadTrackModel(race_manager->getReverseTrack());
if (gk > 0)
{
@ -216,7 +216,7 @@ void World::init()
race_manager->getKartType(i),
race_manager->getPlayerDifficulty(i));
m_karts.push_back(newkart);
m_track->adjustForFog(newkart->getNode());
track->adjustForFog(newkart->getNode());
} // for i
@ -235,8 +235,8 @@ void World::init()
if (UserConfigParams::m_weather_effects)
{
m_weather = new Weather(m_track->getWeatherLightning(),
m_track->getWeatherSound());
m_weather = new Weather(track->getWeatherLightning(),
track->getWeatherSound());
}
} // init
@ -282,7 +282,7 @@ void World::reset()
// Note: track reset must be called after all karts exist, since check
// objects need to allocate data structures depending on the number
// of karts.
m_track->reset();
Track::getCurrentTrack()->reset();
// Reset the race gui.
m_race_gui->reset();
@ -387,7 +387,7 @@ AbstractKart *World::createKart(const std::string &kart_ident, int index,
* \param index Index of kart ranging from 0 to kart_num-1. */
const btTransform &World::getStartTransform(int index)
{
return m_track->getStartTransform(index);
return Track::getCurrentTrack()->getStartTransform(index);
} // getStartTransform
//-----------------------------------------------------------------------------
@ -437,9 +437,9 @@ World::~World()
irr_driver->onUnloadWorld();
// In case that a race is aborted (e.g. track not found) m_track is 0.
if(m_track)
m_track->cleanup();
// In case that a race is aborted (e.g. track not found) track is 0.
if(Track::getCurrentTrack())
Track::getCurrentTrack()->cleanup();
// Delete the in-race-gui:
if(m_saved_race_gui)
@ -555,7 +555,7 @@ void World::terminateRace()
// Check achievements
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_COLUMBUS,
getTrack()->getIdent(), 1);
Track::getCurrentTrack()->getIdent(), 1);
if (raceHasLaps())
{
PlayerManager::increaseAchievement(AchievementInfo::ACHIEVE_MARATHONER,
@ -697,13 +697,14 @@ void World::resetAllKarts()
Vec3 up_offset = (*i)->getNormal() * (0.5f * ((*i)->getKartHeight()));
(*i)->setXYZ(xyz+up_offset);
bool kart_over_ground = m_track->findGround(*i);
bool kart_over_ground = Track::getCurrentTrack()->findGround(*i);
if (!kart_over_ground)
{
Log::error("World",
"No valid starting position for kart %d on track %s.",
(int)(i-m_karts.begin()), m_track->getIdent().c_str());
(int)(i - m_karts.begin()),
Track::getCurrentTrack()->getIdent().c_str());
if (UserConfigParams::m_artist_debug_mode)
{
Log::warn("World", "Activating fly mode.");
@ -719,7 +720,7 @@ void World::resetAllKarts()
// Do a longer initial simulation, which should be long enough for all
// karts to be firmly on ground.
float g = World::getWorld()->getTrack()->getGravity();
float g = Track::getCurrentTrack()->getGravity();
for (KartList::iterator i = m_karts.begin(); i != m_karts.end(); i++)
{
if ((*i)->isGhostKart()) continue;
@ -780,7 +781,7 @@ void World::moveKartTo(AbstractKart* kart, const btTransform &transform)
// Project kart to surface of track
// This will set the physics transform
m_track->findGround(kart);
Track::getCurrentTrack()->findGround(kart);
} // moveKartTo
@ -1052,7 +1053,7 @@ void World::updateTime(const float dt)
*/
void World::updateTrack(float dt)
{
m_track->update(dt);
Track::getCurrentTrack()->update(dt);
} // update Track
// ----------------------------------------------------------------------------
@ -1297,7 +1298,7 @@ void World::escapePressed()
*/
btTransform World::getRescueTransform(unsigned int rescue_pos) const
{
return m_track->getStartTransform(rescue_pos);
return Track::getCurrentTrack()->getStartTransform(rescue_pos);
} // getRescueTransform
//-----------------------------------------------------------------------------
@ -1305,7 +1306,7 @@ btTransform World::getRescueTransform(unsigned int rescue_pos) const
*/
unsigned int World::getNumberOfRescuePositions() const
{
return m_track->getNumberOfStartPositions();
return Track::getCurrentTrack()->getNumberOfStartPositions();
} // getNumberOfRescuePositions
/* EOF */

6
src/modes/world.hpp
View File

@ -42,7 +42,6 @@ class btRigidBody;
class Controller;
class PhysicalObject;
class Physics;
class Track;
namespace Scripting
{
@ -124,8 +123,6 @@ protected:
int local_player_id, int global_player_id,
RaceManager::KartType type,
PerPlayerDifficulty difficulty);
/** Pointer to the track. The track is managed by world. */
Track* m_track;
/**Pointer to scripting engine */
Scripting::ScriptEngine* m_script_engine;
@ -317,9 +314,6 @@ public:
/** Returns a pointer to the physics. */
Physics *getPhysics() const { return m_physics; }
// ------------------------------------------------------------------------
/** Returns a pointer to the track. */
Track *getTrack() const { return m_track; }
// ------------------------------------------------------------------------
/** Returns a pointer to the Scripting Engine. */
Scripting::ScriptEngine *getScriptEngine()
const { return m_script_engine; }

2
src/modes/world_status.cpp
View File

@ -92,7 +92,7 @@ void WorldStatus::reset()
device->getTimer()->start();
// Set the right music
World::getWorld()->getTrack()->startMusic();
Track::getCurrentTrack()->startMusic();
// In case of a networked race the race can only start once
// all protocols are up. This flag is used to wait for
// a confirmation before starting the actual race.

6
src/modes/world_with_rank.cpp
View File

@ -52,8 +52,9 @@ void WorldWithRank::init()
#endif
stk_config->getAllScores(&m_score_for_position, getNumKarts());
Track *track = Track::getCurrentTrack();
// Don't init track sector if navmesh is not found in arena
if ((m_track->isArena() || m_track->isSoccer()) && !m_track->hasNavMesh())
if ((track->isArena() || track->isSoccer()) && !track->hasNavMesh())
return;
for (unsigned int i = 0; i < m_karts.size(); i++)
@ -167,7 +168,8 @@ void WorldWithRank::endSetKartPositions()
unsigned int WorldWithRank::getRescuePositionIndex(AbstractKart *kart)
{
const int start_spots_amount = getTrack()->getNumberOfStartPositions();
const int start_spots_amount =
Track::getCurrentTrack()->getNumberOfStartPositions();
assert(start_spots_amount > 0);
float largest_accumulated_distance_found = -1;

3
src/physics/btKart.cpp
View File

@ -24,7 +24,6 @@
#include "graphics/material.hpp"
#include "karts/kart.hpp"
#include "modes/world.hpp"
#include "physics/triangle_mesh.hpp"
#include "tracks/terrain_info.hpp"
#include "tracks/track.hpp"
@ -1026,7 +1025,7 @@ void btKart::debugDraw(btIDebugDraw* debugDrawer)
int n = w.m_raycastInfo.m_triangle_index;
if (n > -1)
{
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
btVector3 *p1, *p2, *p3;
tm.getTriangle(n, &p1, &p2, &p3);
const btVector3 *n1, *n2, *n3;

2
src/physics/btKartRaycast.cpp
View File

@ -72,7 +72,7 @@ void* btKartRaycaster::castRay(const btVector3& from, const btVector3& to,
result.m_distFraction = rayCallback.m_closestHitFraction;
result.m_triangle_index = -1;
const TriangleMesh &tm =
World::getWorld()->getTrack()->getTriangleMesh();
Track::getCurrentTrack()->getTriangleMesh();
if(m_smooth_normals &&
rayCallback.getTriangleIndex()>-1)
{

2
src/physics/physics.cpp
View File

@ -69,7 +69,7 @@ void Physics::init(const Vec3 &world_min, const Vec3 &world_max)
m_karts_to_delete.clear();
m_dynamics_world->setGravity(
btVector3(0.0f,
-World::getWorld()->getTrack()->getGravity(),
-Track::getCurrentTrack()->getGravity(),
0.0f));
m_debug_drawer = new IrrDebugDrawer();
m_dynamics_world->setDebugDrawer(m_debug_drawer);

2
src/race/history.cpp
View File

@ -181,7 +181,7 @@ void History::Save()
fprintf(fd, "difficulty: %d\n", race_manager->getDifficulty());
fprintf(fd, "reverse: %c\n", race_manager->getReverseTrack() ? 'y' : 'n');
fprintf(fd, "track: %s\n", world->getTrack()->getIdent().c_str());
fprintf(fd, "track: %s\n", Track::getCurrentTrack()->getIdent().c_str());
assert(num_karts > 0);

4
src/replay/replay_recorder.cpp
View File

@ -203,7 +203,7 @@ void ReplayRecorder::save()
std::string time = StringUtils::toString(min_time);
std::replace(time.begin(), time.end(), '.', '_');
std::ostringstream oss;
oss << world->getTrack()->getIdent() << "_" << year << month << day
oss << Track::getCurrentTrack()->getIdent() << "_" << year << month << day
<< "_" << num_karts << "_" << time << ".replay";
m_filename = oss.str();
@ -230,7 +230,7 @@ void ReplayRecorder::save()
fprintf(fd, "kart_list_end\n");
fprintf(fd, "reverse: %d\n", (int)race_manager->getReverseTrack());
fprintf(fd, "difficulty: %d\n", race_manager->getDifficulty());
fprintf(fd, "track: %s\n", world->getTrack()->getIdent().c_str());
fprintf(fd, "track: %s\n", Track::getCurrentTrack()->getIdent().c_str());
fprintf(fd, "laps: %d\n", race_manager->getNumLaps());
fprintf(fd, "min_time: %f\n", min_time);

53
src/scriptengine/script_challenges.cpp
View File

@ -48,37 +48,41 @@ namespace Scripting
* @{
*/
// --------------------------------------------------------------------
/** Get number of challenges that were completed at any difficulty */
int getCompletedChallengesCount()
{
::Track* track = World::getWorld()->getTrack();
return track->getNumOfCompletedChallenges();
}
return ::Track::getCurrentTrack()->getNumOfCompletedChallenges();
} // getCompletedChallengesCount
// --------------------------------------------------------------------
/** Get total number of challenges */
int getChallengeCount()
{
::Track* track = World::getWorld()->getTrack();
return track->getChallengeList().size();
}
return ::Track::getCurrentTrack()->getChallengeList().size();
} // getChallengeCount
// --------------------------------------------------------------------
int getChallengeRequiredPoints(std::string* challenge_name)
{
const ChallengeData* challenge = unlock_manager->getChallengeData(*challenge_name);
const ChallengeData* challenge =
unlock_manager->getChallengeData(*challenge_name);
if (challenge == NULL)
{
if (*challenge_name != "tutorial")
Log::error("track", "Cannot find challenge named '%s'\n",
challenge_name->c_str());
challenge_name->c_str());
return false;
}
return challenge->getNumTrophies();
}
} // getChallengeRequiredPoints
// --------------------------------------------------------------------
bool isChallengeUnlocked(std::string* challenge_name)
{
const ChallengeData* challenge = unlock_manager->getChallengeData(*challenge_name);
const ChallengeData* challenge =
unlock_manager->getChallengeData(*challenge_name);
if (challenge == NULL)
{
if (*challenge_name != "tutorial")
@ -90,8 +94,9 @@ namespace Scripting
const unsigned int val = challenge->getNumTrophies();
bool shown = (PlayerManager::getCurrentPlayer()->getPoints() >= val);
return shown;
}
} // isChallengeUnlocked
// --------------------------------------------------------------------
/** @}*/
/** @}*/
@ -101,15 +106,27 @@ namespace Scripting
engine->SetDefaultNamespace("Challenges");
r = engine->RegisterGlobalFunction("int getCompletedChallengesCount()", asFUNCTION(getCompletedChallengesCount), asCALL_CDECL); assert(r >= 0);
r = engine->RegisterGlobalFunction("int getChallengeCount()", asFUNCTION(getChallengeCount), asCALL_CDECL); assert(r >= 0);
r = engine->RegisterGlobalFunction("bool isChallengeUnlocked(string &in)", asFUNCTION(isChallengeUnlocked), asCALL_CDECL); assert(r >= 0);
r = engine->RegisterGlobalFunction("int getChallengeRequiredPoints(string &in)", asFUNCTION(getChallengeRequiredPoints), asCALL_CDECL); assert(r >= 0);
}
r = engine->RegisterGlobalFunction("int getCompletedChallengesCount()",
asFUNCTION(getCompletedChallengesCount),
asCALL_CDECL);
assert(r >= 0);
r = engine->RegisterGlobalFunction("int getChallengeCount()",
asFUNCTION(getChallengeCount),
asCALL_CDECL);
assert(r >= 0);
r = engine->RegisterGlobalFunction("bool isChallengeUnlocked(string &in)",
asFUNCTION(isChallengeUnlocked),
asCALL_CDECL);
assert(r >= 0);
r = engine->RegisterGlobalFunction("int getChallengeRequiredPoints(string &in)",
asFUNCTION(getChallengeRequiredPoints),
asCALL_CDECL);
assert(r >= 0);
} // registerScriptFunctions
}
} // namespace Challenges
/** \cond DOXYGEN_IGNORE */
}
} // namespace Scripting
/** \endcond */

11
src/scriptengine/script_track.cpp
View File

@ -67,7 +67,8 @@ namespace Scripting
*/
::TrackObject* getTrackObject(std::string* libraryInstance, std::string* objID)
{
return World::getWorld()->getTrack()->getTrackObjectManager()->getTrackObject(*libraryInstance, *objID);
return ::Track::getCurrentTrack()->getTrackObjectManager()
->getTrackObject(*libraryInstance, *objID);
}
/** Creates a trigger at the specified location */
@ -84,7 +85,7 @@ namespace Scripting
::TrackObject* tobj = new ::TrackObject(posi, hpr, scale,
"none", newtrigger, false /* isDynamic */, NULL /* physics settings */);
tobj->setID(*triggerID);
World::getWorld()->getTrack()->getTrackObjectManager()->insertObject(tobj);
::Track::getCurrentTrack()->getTrackObjectManager()->insertObject(tobj);
}
void createTextBillboard(std::string* text, SimpleVec3* location)
@ -104,7 +105,7 @@ namespace Scripting
irr_driver->getSceneManager(), -1, xyz,
core::vector3df(1.5f, 1.5f, 1.5f));
World::getWorld()->getTrack()->addNode(tb);
::Track::getCurrentTrack()->addNode(tb);
tb->drop();
}
else
@ -121,7 +122,7 @@ namespace Scripting
-1, // id
GUIEngine::getSkin()->getColor("font::bottom"),
GUIEngine::getSkin()->getColor("font::top"));
World::getWorld()->getTrack()->addNode(sn);
::Track::getCurrentTrack()->addNode(sn);
}
#endif
}
@ -155,7 +156,7 @@ namespace Scripting
void setFog(float maxDensity, float start, float end, int r, int g, int b, float duration)
{
PropertyAnimator* animator = PropertyAnimator::get();
::Track* track = World::getWorld()->getTrack();
::Track* track = ::Track::getCurrentTrack();
animator->add(
new AnimatedProperty(FOG_MAX, 1,
new double[1] { track->getFogMax() },

2
src/states_screens/grand_prix_lose.cpp
View File

@ -161,7 +161,7 @@ void GrandPrixLose::onUpdate(float dt)
void GrandPrixLose::setKarts(std::vector<std::string> ident_arg)
{
TrackObjectManager* tobjman = World::getWorld()->getTrack()->getTrackObjectManager();
TrackObjectManager* tobjman = Track::getCurrentTrack()->getTrackObjectManager();
assert(ident_arg.size() > 0);
if ((int)ident_arg.size() > MAX_KART_COUNT)

5
src/states_screens/grand_prix_win.cpp
View File

@ -292,9 +292,10 @@ void GrandPrixWin::onUpdate(float dt)
void GrandPrixWin::setKarts(const std::string idents_arg[3])
{
TrackObjectManager* tobjman = World::getWorld()->getTrack()->getTrackObjectManager();
TrackObjectManager* tobjman = Track::getCurrentTrack()->getTrackObjectManager();
// reorder in "podium order" (i.e. second player to the left, first player in the middle, last at the right)
// reorder in "podium order" (i.e. second player to the left, first player
// in the middle, last at the right)
std::string idents[3];
idents[0] = idents_arg[1];
idents[1] = idents_arg[0];

14
src/states_screens/race_gui.cpp
View File

@ -216,7 +216,7 @@ void RaceGUI::renderGlobal(float dt)
drawGlobalMiniMap();
if (!m_is_tutorial) drawGlobalPlayerIcons(m_map_height);
if(world->getTrack()->isSoccer()) drawScores();
if(Track::getCurrentTrack()->isSoccer()) drawScores();
#endif
} // renderGlobal
@ -378,10 +378,9 @@ void RaceGUI::drawGlobalTimer()
void RaceGUI::drawGlobalMiniMap()
{
#ifndef SERVER_ONLY
World *world = World::getWorld();
// draw a map when arena has a navigation mesh.
if ((world->getTrack()->isArena() || world->getTrack()->isSoccer()) &&
!(world->getTrack()->hasNavMesh()))
Track *track = Track::getCurrentTrack();
if ( (track->isArena() || track->isSoccer()) && !(track->hasNavMesh()) )
return;
int upper_y = irr_driver->getActualScreenSize().Height - m_map_bottom - m_map_height;
@ -390,8 +389,9 @@ void RaceGUI::drawGlobalMiniMap()
core::rect<s32> dest(m_map_left, upper_y,
m_map_left + m_map_width, lower_y);
world->getTrack()->drawMiniMap(dest);
track->drawMiniMap(dest);
World *world = World::getWorld();
for(unsigned int i=0; i<world->getNumKarts(); i++)
{
const AbstractKart *kart = world->getKart(i);
@ -401,7 +401,7 @@ void RaceGUI::drawGlobalMiniMap()
if(kart->isEliminated() && !(sta && sta->isMoving())) continue;
const Vec3& xyz = kart->getXYZ();
Vec3 draw_at;
world->getTrack()->mapPoint2MiniMap(xyz, &draw_at);
track->mapPoint2MiniMap(xyz, &draw_at);
draw_at *= UserConfigParams::m_scale_rtts_factor;
video::ITexture* icon = sta ?
@ -424,7 +424,7 @@ void RaceGUI::drawGlobalMiniMap()
if (sw)
{
Vec3 draw_at;
world->getTrack()->mapPoint2MiniMap(sw->getBallPosition(), &draw_at);
track->mapPoint2MiniMap(sw->getBallPosition(), &draw_at);
draw_at *= UserConfigParams::m_scale_rtts_factor;
video::ITexture* icon =
irr_driver->getTexture(FileManager::GUI, "soccer_ball_normal.png");

2
src/states_screens/race_gui_base.cpp
View File

@ -740,7 +740,7 @@ void RaceGUIBase::drawGlobalPlayerIcons(int bottom_margin)
LinearWorld *linear_world = (LinearWorld*)(World::getWorld());
float distance = linear_world->getDistanceDownTrackForKart(kart_id)
+ linear_world->getTrack()->getTrackLength()*lap;
+ Track::getCurrentTrack()->getTrackLength()*lap;
if ((position>1) &&
(previous_distance-distance<m_dist_show_overlap) &&
(!kart->hasFinishedRace()) )

6
src/states_screens/race_gui_overworld.cpp
View File

@ -303,9 +303,9 @@ void RaceGUIOverworld::drawGlobalMiniMap()
#ifndef SERVER_ONLY
World *world = World::getWorld();
// arenas currently don't have a map.
if(world->getTrack()->isArena() || world->getTrack()->isSoccer()) return;
Track* track = Track::getCurrentTrack();
if(track->isArena() || track->isSoccer()) return;
Track* track = world->getTrack();
const std::vector<OverworldChallenge>& challenges =
track->getChallengeList();
@ -332,7 +332,7 @@ void RaceGUIOverworld::drawGlobalMiniMap()
core::rect<s32> dest(m_map_left, upper_y,
m_map_left + m_map_width, lower_y);
world->getTrack()->drawMiniMap(dest);
track->drawMiniMap(dest);
Vec3 kart_xyz;

4
src/tracks/ambient_light_sphere.cpp
View File

@ -24,7 +24,6 @@
#include "graphics/camera.hpp"
#include "io/xml_node.hpp"
#include "karts/abstract_kart.hpp"
#include "modes/world.hpp"
#include "race/race_manager.hpp"
#include "tracks/track.hpp"
@ -47,7 +46,6 @@ void AmbientLightSphere::update(float dt)
{
CheckStructure::update(dt);
World *world = World::getWorld();
for(unsigned int i=0; i<Camera::getNumCameras(); i++)
{
Camera *camera = Camera::getCamera(i);
@ -57,7 +55,7 @@ void AmbientLightSphere::update(float dt)
{
float d2=getDistance2ForKart(i);
video::SColor color;
Track *track=world->getTrack();
Track *track=Track::getCurrentTrack();
if(d2<m_inner_radius2)
{ // Inside inner radius --> use new ambient color
color = m_ambient_color;

2
src/tracks/check_lap.cpp
View File

@ -64,7 +64,7 @@ bool CheckLap::isTriggered(const Vec3 &old_pos, const Vec3 &new_pos,
World* w = World::getWorld();
LinearWorld* lin_world = dynamic_cast<LinearWorld*>(w);
float track_length = w->getTrack()->getTrackLength();
float track_length = Track::getCurrentTrack()->getTrackLength();
// Can happen if a non-lap based race mode is used with a scene file that
// has check defined.
if(!lin_world)

4
src/tracks/graph.cpp
View File

@ -246,7 +246,7 @@ RenderTarget* Graph::makeMiniMap(const core::dimension2du &dimension,
const video::SColor oldClearColor = irr_driver->getClearColor();
irr_driver->setClearbackBufferColor(video::SColor(0, 255, 255, 255));
World::getWorld()->getTrack()->forceFogDisabled(true);
Track::getCurrentTrack()->forceFogDisabled(true);
#ifndef SERVER_ONLY
m_render_target = irr_driver->createRenderTarget(dimension, name);
#endif
@ -331,7 +331,7 @@ RenderTarget* Graph::makeMiniMap(const core::dimension2du &dimension,
irr_driver->removeCameraSceneNode(camera);
irr_driver->setClearbackBufferColor(oldClearColor);
World::getWorld()->getTrack()->forceFogDisabled(false);
Track::getCurrentTrack()->forceFogDisabled(false);
irr_driver->getSceneManager()->clear();
VAOManager::kill();

17
src/tracks/terrain_info.cpp
View File

@ -18,7 +18,6 @@
#include "tracks/terrain_info.hpp"
#include "modes/world.hpp"
#include "physics/triangle_mesh.hpp"
#include "race/race_manager.hpp"
#include "tracks/track.hpp"
@ -58,11 +57,11 @@ void TerrainInfo::update(const Vec3 &from)
btVector3 to(from);
to.setY(-10000.0f);
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
tm.castRay(from, to, &m_hit_point, &m_material, &m_normal,
/*interpolate*/false);
// Now also raycast against all track objects (that are driveable).
World::getWorld()->getTrack()->getTrackObjectManager()
Track::getCurrentTrack()->getTrackObjectManager()
->castRay(from, to, &m_hit_point, &m_material,
&m_normal, /*interpolate*/false);
} // update
@ -83,15 +82,15 @@ void TerrainInfo::update(const btMatrix3x3 &rotation, const Vec3 &from)
btVector3 to(0, -10000.0f, 0);
to = from + rotation*to;
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
tm.castRay(from, to, &m_hit_point, &m_material, &m_normal,
/*interpolate*/true);
// Now also raycast against all track objects (that are driveable). If
// there should be a closer result (than the one against the main track
// mesh), its data will be returned.
World::getWorld()->getTrack()->getTrackObjectManager()
->castRay(from, to, &m_hit_point, &m_material,
&m_normal, /*interpolate*/true);
Track::getCurrentTrack()->getTrackObjectManager()
->castRay(from, to, &m_hit_point, &m_material,
&m_normal, /*interpolate*/true);
} // update
//-----------------------------------------------------------------------------
/** Update the terrain information based on the latest position.
@ -103,7 +102,7 @@ void TerrainInfo::update(const Vec3 &from, const Vec3 &towards)
Vec3 direction = towards.normalized();
btVector3 to = from + 10000.0f*direction;
const TriangleMesh &tm = World::getWorld()->getTrack()->getTriangleMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getTriangleMesh();
tm.castRay(from, to, &m_hit_point, &m_material, &m_normal);
} // update
@ -120,7 +119,7 @@ bool TerrainInfo::getSurfaceInfo(const Vec3 &from, Vec3 *position,
const Material **material)
{
Vec3 to=from+Vec3(0, 10000, 0);
const TriangleMesh &tm = World::getWorld()->getTrack()->getGFXEffectMesh();
const TriangleMesh &tm = Track::getCurrentTrack()->getGFXEffectMesh();
return tm.castRay(from, to, position, material);
} // getSurfaceInfo

12
src/tracks/track.cpp
View File

@ -86,6 +86,7 @@ using namespace irr;
const float Track::NOHIT = -99999.9f;
bool Track::m_dont_load_navmesh = false;
Track *Track::m_current_track = NULL;
// ----------------------------------------------------------------------------
Track::Track(const std::string &filename)
@ -460,6 +461,8 @@ void Track::cleanup()
Scripting::ScriptEngine* script_engine =
World::getWorld()->getScriptEngine();
script_engine->cleanupCache();
m_current_track = NULL;
} // cleanup
//-----------------------------------------------------------------------------
@ -1578,6 +1581,8 @@ void Track::createWater(const XMLNode &node)
*/
void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
{
assert(!m_current_track);
// Use m_filename to also get the path, not only the identifier
irr_driver->setTextureErrorMessage("While loading track '%s'",
m_filename );
@ -1670,11 +1675,14 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
throw std::runtime_error(msg.str());
}
m_current_track = this;
// Load the graph only now: this function is called from world, after
// the race gui was created. The race gui is needed since it stores
// the information about the size of the texture to render the mini
// map to.
if (!m_is_arena && !m_is_soccer && !m_is_cutscene) loadDriveGraph(mode_id, reverse_track);
if (!m_is_arena && !m_is_soccer && !m_is_cutscene)
loadDriveGraph(mode_id, reverse_track);
else if ((m_is_arena || m_is_soccer) && !m_is_cutscene && m_has_navmesh)
loadArenaGraph(*root);
@ -1738,6 +1746,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
}
loadMainTrack(*root);
unsigned int main_track_count = (unsigned int)m_all_nodes.size();
ModelDefinitionLoader model_def_loader(this);
@ -1933,6 +1942,7 @@ void Track::loadTrackModel(bool reverse_track, unsigned int mode_id)
}
irr_driver->unsetTextureErrorMessage();
} // loadTrackModel
//-----------------------------------------------------------------------------

17
src/tracks/track.hpp
View File

@ -54,7 +54,6 @@ class RenderTarget;
class TrackObject;
class TrackObjectManager;
class TriangleMesh;
class World;
class XMLNode;
const int HEIGHT_MAP_RESOLUTION = 256;
@ -97,6 +96,10 @@ class Track
{
private:
/** If a race is in progress, this stores the active track object.
* NULL otherwise. */
static Track *m_current_track;
#ifdef DEBUG
unsigned int m_magic_number;
#endif
@ -387,7 +390,10 @@ private:
public:
bool reverseAvailable() const { return m_reverse_available; }
/** Static function to get the current track. NULL if no current
* track is defined (i.e. no race is active atm) */
static Track* getCurrentTrack() { return m_current_track; }
// ------------------------------------------------------------------------
void handleAnimatedTextures(scene::ISceneNode *node, const XMLNode &xml);
/** Flag to avoid loading navmeshes (useful to speedup debugging: e.g.
@ -440,6 +446,9 @@ public:
/** Returns true if this track has easter eggs. */
bool hasEasterEggs() const { return m_has_easter_eggs; }
// ------------------------------------------------------------------------
/** Returns true if this race can be driven in reverse. */
bool reverseAvailable() const { return m_reverse_available; }
// ------------------------------------------------------------------------
/** Returns true if this track navmesh. */
bool hasNavMesh() const { return m_has_navmesh; }
// ------------------------------------------------------------------------
@ -449,10 +458,6 @@ public:
// ------------------------------------------------------------------------
bool isSoccer () const { return m_is_soccer; }
// ------------------------------------------------------------------------
void loadTrackModel (World* parent,
bool reverse_track = false,
unsigned int mode_id=0);
// ------------------------------------------------------------------------
void addMusic (MusicInformation* mi)
{m_music.push_back(mi); }
// ------------------------------------------------------------------------

31
src/tracks/track_object_presentation.cpp
View File

@ -193,10 +193,7 @@ TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode(
if (!model_def_loader.containsLibraryNode(name))
{
World* world = World::getWorld();
Track* track = NULL;
if (world != NULL)
track = world->getTrack();
Track* track = Track::getCurrentTrack();
std::string local_lib_node_path;
std::string local_script_file_path;
if (track != NULL)
@ -206,6 +203,7 @@ TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode(
}
std::string lib_node_path = lib_path + "node.xml";
std::string lib_script_file_path = lib_path + "scripting.as";
World* world = World::getWorld();
if (local_lib_node_path.size() > 0 && file_manager->fileExists(local_lib_node_path))
{
@ -267,8 +265,9 @@ TrackObjectPresentationLibraryNode::TrackObjectPresentationLibraryNode(
m_node->updateAbsolutePosition();
assert(libroot != NULL);
World::getWorld()->getTrack()->loadObjects(libroot, lib_path, model_def_loader,
create_lod_definitions, m_node, parent);
Track::getCurrentTrack()->loadObjects(libroot, lib_path, model_def_loader,
create_lod_definitions, m_node,
parent);
m_parent = parent;
} // TrackObjectPresentationLibraryNode
@ -494,9 +493,9 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node,
m_force_always_hidden = true;
m_frame_start = 0;
m_frame_end = 0;
if (World::getWorld() && World::getWorld()->getTrack() && xml_node)
World::getWorld()->getTrack()->addPhysicsOnlyNode(m_node);
Track *track = Track::getCurrentTrack();
if (track && track && xml_node)
track->addPhysicsOnlyNode(m_node);
}
}
else if (m_is_in_skybox)
@ -526,9 +525,9 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node,
if (xml_node)
xml_node->get("frame-end", &m_frame_end);
if (World::getWorld() && World::getWorld()->getTrack() && xml_node)
World::getWorld()->getTrack()
->handleAnimatedTextures(m_node, *xml_node);
Track *track = Track::getCurrentTrack();
if (track && track && xml_node)
track->handleAnimatedTextures(m_node, *xml_node);
}
else
{
@ -547,9 +546,9 @@ void TrackObjectPresentationMesh::init(const XMLNode* xml_node,
m_frame_start = 0;
m_frame_end = 0;
if (World::getWorld() && World::getWorld()->getTrack() && xml_node)
World::getWorld()->getTrack()
->handleAnimatedTextures(m_node, *xml_node);
Track *track = Track::getCurrentTrack();
if (track && xml_node)
track->handleAnimatedTextures(m_node, *xml_node);
}
if(!enabled)
@ -674,7 +673,7 @@ TrackObjectPresentationSound::TrackObjectPresentationSound(
xml_node.get("max_dist", &max_dist );
// first try track dir, then global dir
std::string soundfile = World::getWorld()->getTrack()->getTrackFile(sound);
std::string soundfile = Track::getCurrentTrack()->getTrackFile(sound);
//std::string soundfile = file_manager->getAsset(FileManager::MODEL,sound);
if (!file_manager->fileExists(soundfile))
{