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

Initial work to port GP win/lose cutscenes to new system

Browse Source
This commit is contained in:
Marianne Gagnon
2014-05-02 18:47:43 -04:00
parent 3ce6dde466
commit 1b7c9ee1e2
7 changed files with 121 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
src/graphics/irr_driver.cpp
View File

@@ -1813,11 +1813,17 @@ void IrrDriver::update(float dt)
GUIEngine::getCurrentScreen()->needs3D())
{
//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)

10
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,7 @@ void CutsceneWorld::enterRaceOverState()
StateManager::get()->resetAndSetStack(newStack);
StateManager::get()->pushScreen(credits);
}
// TODO: remove hardcoded knowledge of cutscenes, replace with scripting probably
else if (race_manager->getTrackName() == "introcutscene" ||
race_manager->getTrackName() == "introcutscene2")
{
@@ -417,6 +424,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

179
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>
@@ -57,40 +62,52 @@ 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;
}
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);
std::vector<std::string> parts;
parts.push_back("gpwin");
((CutsceneWorld*)World::getWorld())->setParts(parts);
CutsceneWorld::setUseDuration(false);
TrackObjectManager* tom = World::getWorld()->getTrack()->getTrackObjectManager();
const KartProperties* kp = kart_properties_manager->getKart("tux");
KartModel *kart_model = kp->getKartModelCopy();
m_all_kart_models.push_back(kart_model);
scene::ISceneNode* kart_main_node = kart_model->attachModel(false);
TrackObjectPresentationSceneNode* presentation = new TrackObjectPresentationSceneNode(kart_main_node, core::vector3df(0, -0.6, 0), core::vector3df(0, 0, 0), core::vector3df(0.5, 0.5, 0.5));
TrackObject* to = new TrackObject(core::vector3df(0, 0, 0), core::vector3df(0, 0, 0), core::vector3df(1, 1, 1),
"ghost", presentation, false /* isDynamic */, NULL /* physics settings */);
tom->insertObject(to);
World::getWorld()->setPhase(WorldStatus::RACE_PHASE);
} // 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;
// TODO
//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
// -------------------------------------------------------------------------------------
@@ -151,45 +168,15 @@ 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) );
// TODO
/*
m_phase = 1;
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");
@@ -207,21 +194,7 @@ void GrandPrixWin::init()
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);
}
*/
sfx_manager->quickSound("gp_end");
} // init
@@ -231,26 +204,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 +216,6 @@ 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();
}
} // tearDown
// -------------------------------------------------------------------------------------
@@ -274,12 +224,9 @@ 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
// TODO
/*
if (m_phase == 1)
{
assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
@@ -359,28 +306,7 @@ void GrandPrixWin::onUpdate(float dt)
} // 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 +339,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,6 +359,9 @@ void GrandPrixWin::eventCallback(GUIEngine::Widget* widget,
void GrandPrixWin::setKarts(const std::string idents_arg[3])
{
// TODO
/*
// 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];
@@ -475,6 +403,7 @@ void GrandPrixWin::setKarts(const std::string idents_arg[3])
} // end for
assert(m_kart_node[0] != NULL || m_kart_node[1] != NULL || m_kart_node[2] != NULL);
*/
} // setKarts
// -------------------------------------------------------------------------------------

32
src/states_screens/grand_prix_win.hpp
View File

@@ -37,38 +37,22 @@ 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;
irr::scene::IMeshSceneNode* m_podium_step[3];
irr::scene::ISceneNode* 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_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;
//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_kart_rotation[3];
public:
@@ -90,8 +74,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

16
src/tracks/track_object_presentation.cpp
View File

@@ -250,6 +250,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) :

13
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;
@@ -201,6 +211,9 @@ 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();