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

Merge branch 'NewGPCutscene'

Browse Source
This commit is contained in:
Marianne Gagnon 2014-05-03 20:22:07 -04:00
commit ceb8265203
18 changed files with 262 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/animations/animation_base.hpp
View File

@ -47,9 +47,6 @@ private:
* one time only (which might get triggered more than once). */
enum AnimTimeType { ATT_CYCLIC, ATT_CYCLIC_ONCE } m_anim_type;
/** True if the animation is currently playing. */
bool m_playing;
/** The current time used in the IPOs. */
float m_current_time;
@ -66,6 +63,9 @@ protected:
/** All IPOs for this animation. */
PtrVector<Ipo> m_all_ipos;
/** True if the animation is currently playing. */
bool m_playing;
public:
AnimationBase(const XMLNode &node);
AnimationBase(Ipo *ipo);

2
src/animations/three_d_animation.cpp
View File

@ -81,6 +81,8 @@ void ThreeDAnimation::update(float dt)
//m_node->setPosition(xyz.toIrrVector());
//m_node->setScale(scale.toIrrVector());
if (!m_playing) return;
// Note that the rotation order of irrlicht is different from the one
// in blender. So in order to reproduce the blender IPO rotations
// correctly, we have to get the rotations around each axis and combine

17
src/graphics/irr_driver.cpp
View File

@ -1811,14 +1811,21 @@ void IrrDriver::update(float dt)
World *world = World::getWorld();
if (GUIEngine::getCurrentScreen() != NULL &&
GUIEngine::getCurrentScreen()->needs3D())
GUIEngine::getCurrentScreen()->needs3D() &&
world != NULL)
{
//printf("Screen that needs 3D\n");
m_video_driver->beginScene(/*backBuffer clear*/true, /*zBuffer*/true,
video::SColor(0,0,0,255));
m_scene_manager->drawAll();
//m_video_driver->beginScene(/*backBuffer clear*/true, /*zBuffer*/true,
// video::SColor(0,0,0,255));
//m_scene_manager->drawAll();
if (m_glsl)
renderGLSL(dt);
else
renderFixed(dt);
GUIEngine::render(dt);
m_video_driver->endScene();
//m_video_driver->endScene();
return;
}
else if (!world)

4
src/graphics/material_manager.cpp
View File

@ -111,9 +111,9 @@ void MaterialManager::setAllMaterialFlags(video::ITexture* t,
mb->getMaterial().ColorMaterial = video::ECM_DIFFUSE_AND_AMBIENT;
if (World::getWorld() != NULL && World::getWorld()->getTrack() != NULL)
if (World::getWorld() != NULL)
{
mb->getMaterial().FogEnable = World::getWorld()->getTrack()->isFogEnabled();
mb->getMaterial().FogEnable = World::getWorld()->isFogEnabled();
}

2
src/graphics/render.cpp
View File

@ -212,7 +212,7 @@ void IrrDriver::renderGLSL(float dt)
renderSolidSecondPass();
PROFILER_POP_CPU_MARKER();
if (UserConfigParams::m_dynamic_lights && World::getWorld()->getTrack()->isFogEnabled())
if (UserConfigParams::m_dynamic_lights && World::getWorld()->isFogEnabled())
{
PROFILER_PUSH_CPU_MARKER("- Fog", 0xFF, 0x00, 0x00);
m_post_processing->renderFog();

2
src/graphics/stkanimatedmesh.cpp
View File

@ -253,7 +253,7 @@ void STKAnimatedMesh::render()
for_in(mesh, TransparentMesh[TM_BUBBLE])
drawBubble(*mesh, ModelViewProjectionMatrix);
if (World::getWorld()->getTrack()->isFogEnabled())
if (World::getWorld()->isFogEnabled())
{
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentFogShader::Program);

2
src/graphics/stkmesh.cpp
View File

@ -858,7 +858,7 @@ void initvaostate(GLMesh &mesh, TransparentMaterial TranspMat)
break;
case TM_DEFAULT:
case TM_ADDITIVE:
if (World::getWorld()->getTrack()->isFogEnabled())
if (World::getWorld()->isFogEnabled())
mesh.vao_first_pass = createVAO(mesh.vertex_buffer, mesh.index_buffer,
MeshShader::TransparentFogShader::attrib_position, MeshShader::TransparentFogShader::attrib_texcoord, -1, -1, -1, -1, MeshShader::TransparentFogShader::attrib_color, mesh.Stride);
else

2
src/graphics/stkmeshscenenode.cpp
View File

@ -501,7 +501,7 @@ void STKMeshSceneNode::render()
for_in(mesh, TransparentMesh[TM_BUBBLE])
drawBubble(*mesh, ModelViewProjectionMatrix);
if (World::getWorld()->getTrack()->isFogEnabled())
if (World::getWorld() ->isFogEnabled())
{
if (!TransparentMesh[TM_DEFAULT].empty() || !TransparentMesh[TM_ADDITIVE].empty())
glUseProgram(MeshShader::TransparentFogShader::Program);

17
src/modes/cutscene_world.cpp
View File

@ -45,6 +45,8 @@
#include <string>
bool CutsceneWorld::s_use_duration = false;
//-----------------------------------------------------------------------------
/** Constructor. Sets up the clock mode etc.
*/
@ -152,6 +154,9 @@ void CutsceneWorld::init()
}
}
if (!s_use_duration)
m_duration = 999999.0f;
if (m_duration <= 0.0f)
{
Log::error("[CutsceneWorld]", "WARNING: cutscene has no duration");
@ -367,6 +372,7 @@ void CutsceneWorld::enterRaceOverState()
if (m_aborted || partId == -1 || partId == (int)m_parts.size() - 1)
{
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
if (m_parts.size() == 1 && m_parts[0] == "endcutscene")
{
CreditsScreen* credits = CreditsScreen::getInstance();
@ -377,6 +383,14 @@ void CutsceneWorld::enterRaceOverState()
StateManager::get()->resetAndSetStack(newStack);
StateManager::get()->pushScreen(credits);
}
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (m_parts.size() == 1 && m_parts[0] == "gpwin")
{
MainMenuScreen* mainMenu = MainMenuScreen::getInstance();
race_manager->exitRace();
StateManager::get()->resetAndGoToScreen(mainMenu);
}
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (race_manager->getTrackName() == "introcutscene" ||
race_manager->getTrackName() == "introcutscene2")
{
@ -417,6 +431,9 @@ void CutsceneWorld::enterRaceOverState()
*/
bool CutsceneWorld::isRaceOver()
{
if (!s_use_duration && !m_aborted)
return false;
return m_time > m_duration;
} // isRaceOver

17
src/modes/cutscene_world.hpp
View File

@ -45,18 +45,15 @@ class CutsceneWorld : public World
double m_duration;
bool m_aborted;
// TODO find a better way than static
static bool s_use_duration;
/** monkey tricks to get the animations in sync with irrlicht. we reset the time
* after all is loaded and it's running withotu delays
*/
bool m_second_reset;
double m_time_at_second_reset;
void abortCutscene()
{
if (m_time < m_duration - 2.0f) m_duration = m_time + 2.0f;
m_aborted = true;
}
std::vector<std::string> m_parts;
public:
@ -107,6 +104,14 @@ public:
};
// ------------------------------------------------------------------------
virtual void escapePressed() OVERRIDE { abortCutscene(); }
// ------------------------------------------------------------------------
static void setUseDuration(bool use_duration) { s_use_duration = use_duration; }
// ------------------------------------------------------------------------
void abortCutscene()
{
if (m_time < m_duration - 2.0f) m_duration = m_time + 2.0f;
m_aborted = true;
}
}; // CutsceneWorld

7
src/modes/world.cpp
View File

@ -1180,4 +1180,11 @@ void World::escapePressed()
new RacePausedDialog(0.8f, 0.6f);
}
//-----------------------------------------------------------------------------
bool World::isFogEnabled() const
{
return m_track != NULL && m_track->isFogEnabled();
}
/* EOF */

2
src/modes/world.hpp
View File

@ -302,6 +302,8 @@ public:
/** Returns a pointer to the track. */
Track *getTrack() const { return m_track; }
// ------------------------------------------------------------------------
bool isFogEnabled() const;
// ------------------------------------------------------------------------
/** The code that draws the timer should call this first to know
* whether the game mode wants a timer drawn. */
virtual bool shouldDrawTimer() const

14
src/race/race_manager.cpp
View File

@ -685,8 +685,18 @@ void RaceManager::exitRace(bool delete_world)
if (someHumanPlayerWon)
{
StateManager::get()->pushScreen( GrandPrixWin::getInstance() );
GrandPrixWin::getInstance()->setKarts(winners);
if (delete_world) World::deleteWorld();
delete_world = false;
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gpwin", 999, false);
GrandPrixWin* scene = GrandPrixWin::getInstance();
StateManager::get()->pushScreen(scene);
scene->setKarts(winners);
}
else
{

308
src/states_screens/grand_prix_win.cpp
View File

@ -33,8 +33,13 @@
#include "items/item_manager.hpp"
#include "karts/kart_properties.hpp"
#include "karts/kart_properties_manager.hpp"
#include "modes/cutscene_world.hpp"
#include "modes/world.hpp"
#include "states_screens/feature_unlocked.hpp"
#include "states_screens/state_manager.hpp"
#include "tracks/track.hpp"
#include "tracks/track_object.hpp"
#include "tracks/track_object_manager.hpp"
#include "utils/translation.hpp"
#include <IGUIEnvironment.h>
@ -48,56 +53,54 @@ using namespace irr::core;
using namespace irr::gui;
using namespace irr::video;
const float KARTS_DELTA_Y = 0.03f;
const float INITIAL_Y = -3.0f;
const float INITIAL_PODIUM_Y = -3.6f;
const float KARTS_X = -0.62f;
const float KARTS_DELTA_X = 0.815f;
const float KARTS_DELTA_Y = -0.55f;
const float KARTS_DEST_Z = 1.2f;
const float INITIAL_Y = 0.0f;
const float INITIAL_PODIUM_Y = -0.89f;
const float PODIUM_HEIGHT[3] = { 0.325f, 0.5f, 0.15f };
DEFINE_SCREEN_SINGLETON( GrandPrixWin );
// -------------------------------------------------------------------------------------
GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui")
GrandPrixWin::GrandPrixWin() : Screen("grand_prix_win.stkgui", false)
{
setNeeds3D(true);
m_throttle_FPS = false;
try
{
std::string path = file_manager->getAsset(FileManager::MUSIC,"win_theme.music");
m_music = music_manager->getMusicInformation(path);
}
catch (std::exception& e)
{
fprintf(stderr, "[GrandPrixWin] WARNING: exception caught when trying to load music: %s\n", e.what());
m_music = NULL;
}
m_kart_node[0] = NULL;
m_kart_node[1] = NULL;
m_kart_node[2] = NULL;
m_podium_steps[0] = NULL;
m_podium_steps[1] = NULL;
m_podium_steps[2] = NULL;
} // GrandPrixWin
// -------------------------------------------------------------------------------------
void GrandPrixWin::loadedFromFile()
{
m_kart_node[0] = NULL;
m_kart_node[1] = NULL;
m_kart_node[2] = NULL;
m_podium_x[0] = 1.4f;
m_podium_z[0] = 0.0f;
m_podium_x[1] = 2.2f;
m_podium_z[1] = 0.5f;
m_podium_x[2] = 3.0f;
m_podium_z[2] = 0.0f;
} // loadedFromFile
// -------------------------------------------------------------------------------------
void GrandPrixWin::init()
{
std::vector<std::string> parts;
parts.push_back("gpwin");
((CutsceneWorld*)World::getWorld())->setParts(parts);
CutsceneWorld::setUseDuration(false);
Screen::init();
World::getWorld()->setPhase(WorldStatus::RACE_PHASE);
if (PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges().size() > 0)
{
const core::dimension2d<u32>& frame_size = GUIEngine::getDriver()->getCurrentRenderTargetSize();
@ -140,8 +143,6 @@ void GrandPrixWin::init()
m_unlocked_label->m_w = message_width;
m_unlocked_label->m_h = label_height;
m_unlocked_label->setText(message, false);
//const irr::video::SColor orange(255, 255, 126, 21);
//unlocked_label->setColor(orange);
m_unlocked_label->add();
manualAddWidget(m_unlocked_label);
@ -151,77 +152,8 @@ void GrandPrixWin::init()
m_unlocked_label = NULL;
}
m_phase = 1;
m_sky_angle = 0.0f;
m_global_time = 0.0f;
video::ITexture *t = irr_driver->getTexture(FileManager::TEXTURE,
"clouds.png ");
m_sky = irr_driver->addSkyDome(t,
16 /* hori_res */, 16 /* vert_res */,
1.0f /* texture_percent */,
2.0f /* sphere_percent */);
m_camera = irr_driver->addCameraSceneNode();
m_camera_x = 3.0f;
m_camera_y = 0.0f;
m_camera_z = -5.0f;
m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
irr_driver->getSceneManager()->setActiveCamera(m_camera);
m_camera_target_x = 1.5f;
m_camera_target_z = 0.0f;
m_camera->setTarget( core::vector3df(m_camera_target_x, -2.0f, m_camera_target_z) );
m_camera->setFOV( DEGREE_TO_RAD*50.0f );
m_camera->updateAbsolutePosition();
scene::IMesh* model_village = irr_driver->getMesh( file_manager->getAsset(FileManager::MODEL,"village.b3d") );
assert(model_village != NULL);
m_village = irr_driver->addMesh(model_village);
#ifdef DEBUG
m_village->setName("village");
#endif
m_village->setPosition( core::vector3df(2, INITIAL_Y, 0) );
scene::IMesh* podium_model = irr_driver->getMesh( file_manager->getAsset(FileManager::MODEL,"wood_podium.b3d") );
assert(podium_model != NULL);
m_podium_step[0] = irr_driver->addMesh(podium_model);
#ifdef DEBUG
m_podium_step[0]->setName("Podium 0");
#endif
m_podium_step[0]->setPosition( core::vector3df(m_podium_x[0], INITIAL_PODIUM_Y, m_podium_z[0]) );
m_podium_step[1] = irr_driver->addMesh(podium_model);
#ifdef DEBUG
m_podium_step[1]->setName("Podium 1");
#endif
m_podium_step[1]->setPosition( core::vector3df(m_podium_x[1], INITIAL_PODIUM_Y, m_podium_z[1]) );
m_podium_step[2] = irr_driver->addMesh(podium_model);
#ifdef DEBUG
m_podium_step[2]->setName("Podium 2");
#endif
m_podium_step[2]->setPosition( core::vector3df(m_podium_x[2], INITIAL_PODIUM_Y, m_podium_z[2]) );
scene::ISceneManager* sceneManager = irr_driver->getSceneManager();
sceneManager->setAmbientLight(video::SColor(255, 95, 95, 95));
const core::vector3df &sun_pos = core::vector3df( 0, 200, 100.0f );
m_light = irr_driver->addLight(sun_pos, 300.0f, 0.25f, 0.25f, 0.25f);
m_finish_sound = sfx_manager->quickSound("gp_end");
if (!irr_driver->isGLSL())
{
scene::ILightSceneNode *lnode = (scene::ILightSceneNode *) m_light;
lnode->getLightData().DiffuseColor = irr::video::SColorf(0.25f, 0.25f, 0.25f, 1.0f);
lnode->getLightData().AmbientColor = irr::video::SColorf(0.25f, 0.25f, 0.25f, 1.0f);
lnode->getLightData().SpecularColor = irr::video::SColorf(0.0f, 0.0f, 0.0f, 1.0f);
}
m_phase = 1;
sfx_manager->quickSound("gp_end");
} // init
@ -231,26 +163,9 @@ void GrandPrixWin::init()
void GrandPrixWin::tearDown()
{
Screen::tearDown();
irr_driver->removeNode(m_sky);
m_sky = NULL;
((CutsceneWorld*)World::getWorld())->abortCutscene();
irr_driver->removeCameraSceneNode(m_camera);
m_camera = NULL;
irr_driver->removeNode(m_light);
m_light = NULL;
irr_driver->removeNode(m_village);
m_village = NULL;
for (int n=0; n<3; n++)
{
irr_driver->removeNode(m_podium_step[n]);
m_podium_step[n] = NULL;
if (m_kart_node[n] != NULL) irr_driver->removeNode(m_kart_node[n]);
m_kart_node[n] = NULL;
}
for(unsigned int i=0; i<m_all_kart_models.size(); i++)
for (unsigned int i = 0; i<m_all_kart_models.size(); i++)
delete m_all_kart_models[i];
m_all_kart_models.clear();
@ -260,12 +175,14 @@ void GrandPrixWin::tearDown()
delete m_unlocked_label;
m_unlocked_label = NULL;
}
if (m_finish_sound != NULL &&
m_finish_sound->getStatus() == SFXManager::SFX_PLAYING)
{
m_finish_sound->stop();
}
m_kart_node[0] = NULL;
m_kart_node[1] = NULL;
m_kart_node[2] = NULL;
m_podium_steps[0] = NULL;
m_podium_steps[1] = NULL;
m_podium_steps[2] = NULL;
} // tearDown
// -------------------------------------------------------------------------------------
@ -274,11 +191,6 @@ void GrandPrixWin::onUpdate(float dt)
{
m_global_time += dt;
m_sky_angle += dt*2;
if (m_sky_angle > 360) m_sky_angle -= 360;
m_sky->setRotation( core::vector3df(0, m_sky_angle, 0) );
// ---- karts move
if (m_phase == 1)
{
@ -290,24 +202,27 @@ void GrandPrixWin::onUpdate(float dt)
if (m_kart_node[k] != NULL)
{
if (fabsf(m_kart_z[k] - m_podium_z[k]) > dt)
if (fabsf(m_kart_z[k] - KARTS_DEST_Z) > dt)
{
if (m_kart_z[k] < m_podium_z[k] - dt)
if (m_kart_z[k] < KARTS_DEST_Z - dt)
{
m_kart_z[k] += dt;
}
else if (m_kart_z[k] > m_podium_z[k] + dt)
else if (m_kart_z[k] > KARTS_DEST_Z + dt)
{
m_kart_z[k] -= dt;
}
else
{
m_kart_z[k] = m_podium_z[k];
m_kart_z[k] = KARTS_DEST_Z;
}
karts_not_yet_done++;
}
m_kart_node[k]->setPosition( core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
core::vector3df kart_rot(0, m_kart_rotation[k], 0);
core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
}
} // end for
@ -328,8 +243,16 @@ void GrandPrixWin::onUpdate(float dt)
if (m_kart_rotation[k] < 180.f)
{
m_kart_rotation[k] += 25.0f*dt;
m_kart_node[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
m_podium_step[k]->setRotation( core::vector3df(0, m_kart_rotation[k], 0) );
core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
core::vector3df kart_rot(0, m_kart_rotation[k], 0);
core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
core::vector3df podium_pos = m_podium_steps[k]->getInitXYZ();
core::vector3df podium_rot(0, m_kart_rotation[k], 0);
m_podium_steps[k]->move(podium_pos, podium_rot, core::vector3df(1.0f, 1.0f, 1.0f), false);
karts_not_yet_done++;
}
}
@ -349,38 +272,22 @@ void GrandPrixWin::onUpdate(float dt)
if (m_kart_y[k] < y_target + KARTS_DELTA_Y)
{
m_kart_y[k] += dt*(PODIUM_HEIGHT[k]);
m_kart_node[k]->setPosition( core::vector3df(m_kart_x[k], m_kart_y[k], m_kart_z[k]) );
m_podium_step[k]->setPosition( core::vector3df(m_podium_x[k],
INITIAL_PODIUM_Y - (INITIAL_Y - m_kart_y[k]) - KARTS_DELTA_Y,
m_podium_z[k]) );
core::vector3df kart_pos(m_kart_x[k], m_kart_y[k], m_kart_z[k]);
core::vector3df kart_rot(0, m_kart_rotation[k], 0);
core::vector3df kart_scale(0.5f, 0.5f, 0.5f);
m_kart_node[k]->move(kart_pos, kart_rot, kart_scale, false);
core::vector3df podium_pos = m_podium_steps[k]->getInitXYZ();
core::vector3df podium_rot(0, m_kart_rotation[k], 0);
podium_pos.Y = INITIAL_PODIUM_Y - (INITIAL_Y - m_kart_y[k]) - KARTS_DELTA_Y;
m_podium_steps[k]->move(podium_pos, podium_rot, core::vector3df(1.0f, 1.0f, 1.0f), false);
}
}
} // end for
}
if (m_phase > 1)
{
//m_camera_x = 3.0f;
if (m_camera_z < -2.0f) m_camera_z += dt*0.2f;
if (m_camera_x < m_podium_x[1] - dt*0.1f) m_camera_x += dt*0.1f;
else if (m_camera_x > m_podium_x[1] + dt*0.1f) m_camera_x -= dt*0.1f;
else m_camera_x = m_podium_x[1];
if (m_camera_target_x < m_podium_x[1]) m_camera_target_x += dt*0.1f;
if (m_camera_y > -1.8f) m_camera_y -= dt*0.1f;
m_camera->setTarget( core::vector3df(m_camera_target_x, -2.0f, m_camera_target_z) );
m_camera->setPosition( core::vector3df(m_camera_x, m_camera_y, m_camera_z) );
m_camera->setUpVector( core::vector3df(0.0, 1.0, 0.0) );
m_camera->updateAbsolutePosition();
}
// ---- title
static const int w = irr_driver->getFrameSize().Width;
@ -413,8 +320,7 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
PlayerManager::getCurrentPlayer()->getRecentlyCompletedChallenges();
PlayerManager::getCurrentPlayer()->clearUnlocked();
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
FeatureUnlockedCutScene* scene = FeatureUnlockedCutScene::getInstance();
assert(unlocked.size() > 0);
scene->addTrophy(race_manager->getDifficulty());
@ -434,47 +340,67 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
void GrandPrixWin::setKarts(const std::string idents_arg[3])
{
TrackObjectManager* tobjman = World::getWorld()->getTrack()->getTrackObjectManager();
// 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];
idents[2] = idents_arg[2];
for (int n=0; n<3; n++)
for (int i = 0; i < 3; i++)
{
if (idents[n].size() == 0) continue;
const KartProperties* kp = kart_properties_manager->getKart(idents[i]);
if (kp == NULL) continue;
scene::ISceneNode* kart_main_node = NULL;
KartModel* kart_model = kp->getKartModelCopy();
m_all_kart_models.push_back(kart_model);
scene::ISceneNode* kart_main_node = kart_model->attachModel(false);
const KartProperties* kp = kart_properties_manager->getKart(idents[n]);
if (kp != NULL)
m_kart_x[i] = KARTS_X + i*KARTS_DELTA_X;
m_kart_y[i] = INITIAL_Y + KARTS_DELTA_Y;
m_kart_z[i] = -4; // to 1.2
m_kart_rotation[i] = 0.0f;
core::vector3df kart_pos(m_kart_x[i], m_kart_y[i], m_kart_z[i]);
core::vector3df kart_rot(0, 0, 0);
core::vector3df kart_scale(0.5, 0.5, 0.5);
//FIXME: it's not ideal that both the track object and the presentation know the initial coordinates of the object
TrackObjectPresentationSceneNode* presentation = new TrackObjectPresentationSceneNode(
kart_main_node, kart_pos, kart_rot, kart_scale);
TrackObject* tobj = new TrackObject(kart_pos, kart_rot, kart_scale,
"ghost", presentation, false /* isDynamic */, NULL /* physics settings */);
tobjman->insertObject(tobj);
m_kart_node[i] = tobj;
}
TrackObject* currObj;
PtrVector<TrackObject>& objects = tobjman->getObjects();
for_in(currObj, objects)
{
TrackObjectPresentationMesh* meshPresentation = currObj->getPresentation<TrackObjectPresentationMesh>();
if (meshPresentation != NULL)
{
KartModel *kart_model = kp->getKartModelCopy();
m_all_kart_models.push_back(kart_model);
kart_main_node = kart_model->attachModel(false);
m_kart_x[n] = m_podium_x[n];
m_kart_y[n] = INITIAL_Y + KARTS_DELTA_Y;
m_kart_z[n] = -4;
m_kart_rotation[n] = 0.0f;
assert(kart_main_node != NULL);
kart_main_node->setPosition( core::vector3df(m_kart_x[n],
m_kart_y[n],
m_kart_z[n]) );
kart_main_node->setScale( core::vector3df(0.4f, 0.4f, 0.4f) );
float susp[4]={0,0,0,0};
kart_model->update(0.0f, 0.0f, 0.0f, susp, 0.0f);
}
else
{
std::cerr << "[GrandPrixWin] WARNING : kart '" << idents[n] << "' not found!\n";
if (meshPresentation->getModelFile() == "gpwin_podium1.b3d")
{
m_podium_steps[0] = currObj;
}
else if (meshPresentation->getModelFile() == "gpwin_podium2.b3d")
{
m_podium_steps[1] = currObj;
}
else if (meshPresentation->getModelFile() == "gpwin_podium3.b3d")
{
m_podium_steps[2] = currObj;
}
}
}
m_kart_node[n] = kart_main_node;
} // end for
assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
assert(m_podium_steps[0] != NULL);
assert(m_podium_steps[1] != NULL);
assert(m_podium_steps[2] != NULL);
} // setKarts
// -------------------------------------------------------------------------------------

29
src/states_screens/grand_prix_win.hpp
View File

@ -26,6 +26,7 @@
namespace irr { namespace scene { class ISceneNode; class ICameraSceneNode; class ILightSceneNode; class IMeshSceneNode; } }
namespace GUIEngine { class LabelWidget; }
class KartProperties;
class TrackObject;
/**
* \brief Screen shown at the end of a Grand Prix
@ -37,39 +38,27 @@ class GrandPrixWin : public GUIEngine::Screen, public GUIEngine::ScreenSingleton
GrandPrixWin();
/** sky angle, 0-360 */
float m_sky_angle;
/** Global evolution of time */
double m_global_time;
irr::scene::IMeshSceneNode* m_village;
TrackObject* m_podium_steps[3];
irr::scene::IMeshSceneNode* m_podium_step[3];
irr::scene::ISceneNode* m_kart_node[3];
TrackObject* m_kart_node[3];
//irr::scene::IMeshSceneNode* m_podium_step[3];
//irr::scene::ISceneNode* m_kart_node[3];
/** A copy of the kart model for each kart used. */
std::vector<KartModel*> m_all_kart_models;
irr::scene::ISceneNode* m_sky;
irr::scene::ICameraSceneNode* m_camera;
irr::scene::ISceneNode* m_light;
GUIEngine::LabelWidget* m_unlocked_label;
int m_phase;
float m_kart_x[3], m_kart_y[3], m_kart_z[3];
float m_podium_x[3], m_podium_z[3];
//float m_podium_x[3], m_podium_z[3];
float m_kart_rotation[3];
float m_camera_x, m_camera_y, m_camera_z;
float m_camera_target_x, m_camera_target_z;
MusicInformation* m_music;
SFXBase* m_finish_sound;
public:
/** \brief implement callback from parent class GUIEngine::Screen */
@ -90,8 +79,6 @@ public:
/** \pre must be called after pushing the screen, but before onUpdate had the chance to be invoked */
void setKarts(const std::string idents[3]);
virtual MusicInformation* getMusic() const OVERRIDE { return m_music; }
};
#endif

50
src/states_screens/main_menu_screen.cpp
View File

@ -233,17 +233,42 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
if (selection == "options")
{
// The DEBUG item
// GP WIN
StateManager::get()->enterGameState();
race_manager->setMinorMode(RaceManager::MINOR_MODE_CUTSCENE);
race_manager->setNumKarts(0);
race_manager->setNumPlayers(0);
race_manager->setNumLocalPlayers(0);
race_manager->startSingleRace("gpwin", 999, false);
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
scene->setKarts(winners);
// GP Lose
/*
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("elephpant");
losers.push_back("wilber");
scene->setKarts( losers );
*/
/*
// FEATURE UNLOCKED
FeatureUnlockedCutScene* scene =
FeatureUnlockedCutScene::getInstance();
FeatureUnlockedCutScene::getInstance();
scene->addTrophy(RaceManager::DIFFICULTY_EASY);
StateManager::get()->pushScreen(scene);
/*
static int i = 1;
i++;
if (i % 4 == 0)
if (i % 2 == 0)
{
// the passed kart will not be modified, that's why I allow myself
// to use const_cast
@ -255,7 +280,7 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
);
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 1)
else if (i % 2 == 1)
{
std::vector<video::ITexture*> textures;
textures.push_back(irr_driver->getTexture(
@ -274,23 +299,6 @@ void MainMenuScreen::eventCallback(Widget* widget, const std::string& name,
scene->addUnlockedPictures(textures, 1.0, 0.75, L"You did it");
StateManager::get()->pushScreen(scene);
}
else if (i % 4 == 2)
{
GrandPrixWin* scene = GrandPrixWin::getInstance();
const std::string winners[] = { "elephpant", "nolok", "pidgin" };
StateManager::get()->pushScreen(scene);
scene->setKarts( winners );
}
else
{
GrandPrixLose* scene = GrandPrixLose::getInstance();
StateManager::get()->pushScreen(scene);
std::vector<std::string> losers;
losers.push_back("nolok");
losers.push_back("elephpant");
losers.push_back("wilber");
scene->setKarts( losers );
}
*/
}

19
src/tracks/track_object_presentation.cpp
View File

@ -202,6 +202,7 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
std::string model_name;
xml_node.get("model", &model_name );
m_model_file = model_name;
m_is_in_skybox = false;
std::string render_pass;
xml_node.get("renderpass", &render_pass);
@ -250,6 +251,22 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(const XMLNode& xml_node
init(&xml_node, parent, enabled);
}
TrackObjectPresentationMesh::TrackObjectPresentationMesh(
scene::IAnimatedMesh* model, const core::vector3df& xyz,
const core::vector3df& hpr, const core::vector3df& scale) :
TrackObjectPresentationSceneNode(xyz, hpr, scale)
{
m_is_looped = false;
m_mesh = NULL;
m_node = NULL;
bool animated = (UserConfigParams::m_graphical_effects ||
World::getWorld()->getIdent() == IDENT_CUTSCENE);
m_mesh = model;
init(NULL, NULL, true);
}
TrackObjectPresentationMesh::TrackObjectPresentationMesh(
const std::string& model_file, const core::vector3df& xyz,
const core::vector3df& hpr, const core::vector3df& scale) :
@ -262,6 +279,8 @@ TrackObjectPresentationMesh::TrackObjectPresentationMesh(
bool animated = (UserConfigParams::m_graphical_effects ||
World::getWorld()->getIdent() == IDENT_CUTSCENE);
m_model_file = model_file;
if (file_manager->fileExists(model_file))
{
if (animated)

17
src/tracks/track_object_presentation.hpp
View File

@ -116,6 +116,16 @@ public:
m_node = NULL;
}
TrackObjectPresentationSceneNode(
scene::ISceneNode* node,
const core::vector3df& xyz,
const core::vector3df& hpr,
const core::vector3df& scale) :
TrackObjectPresentation(xyz, hpr, scale)
{
m_node = node;
}
virtual const core::vector3df& getPosition() const OVERRIDE;
virtual const core::vector3df getAbsolutePosition() const OVERRIDE;
virtual const core::vector3df& getRotation() const OVERRIDE;
@ -193,6 +203,8 @@ private:
/** End frame of the animation to be played. */
unsigned int m_frame_end;
std::string m_model_file;
void init(const XMLNode* xml_node, scene::ISceneNode* parent, bool enabled);
public:
@ -201,10 +213,15 @@ public:
TrackObjectPresentationMesh(
const std::string& model_file, const core::vector3df& xyz,
const core::vector3df& hpr, const core::vector3df& scale);
TrackObjectPresentationMesh(
scene::IAnimatedMesh* mesh, const core::vector3df& xyz,
const core::vector3df& hpr, const core::vector3df& scale);
virtual ~TrackObjectPresentationMesh();
virtual void reset() OVERRIDE;
const std::string& getModelFile() const { return m_model_file; }
};
/**