Ticket #3301: cinematic_camera_core_v1.4.patch

binaries/data/mods/public/simulation/components/Trigger.js

@@ -19 +19 @@
     "Interval",
     "Range",
     "TreasureCollected",
+    "CinemaPathEnded"
 ]; 
 
 Trigger.prototype.Init = function()
@@ -234 +235 @@
     // See function "SpawnUnits" in ProductionQueue for more details
 };
 
-// Handles "OnTrainingFinished" event.
+// Handles "OnResearchFinished" event.
 Trigger.prototype.OnGlobalResearchFinished = function(msg)
 {
     this.CallEvent("ResearchFinished", msg);
@@ -242 +243 @@
     //                           "tech": tech}
 };
 
+// Handles "OnCinemaPathEnded" event.
+Trigger.prototype.OnGlobalCinemaPathEnded = function(msg)
+{
+    this.CallEvent("CinemaPathEnded", msg);
+}
+
 Trigger.prototype.OnGlobalOwnershipChanged = function(msg)
 {
     this.CallEvent("OwnershipChanged", msg);

source/graphics/CinemaManager.cpp

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "precompiled.h"
+
+#include "Camera.h"
+#include "CinemaManager.h"
+#include "GameView.h"
+#include "gui/CGUI.h"
+#include "gui/GUIManager.h"
+#include "gui/IGUIObject.h"
+#include "lib/ogl.h"
+#include "maths/MathUtil.h"
+#include "maths/Quaternion.h"
+#include "maths/Vector3D.h"
+#include "maths/Vector4D.h"
+#include "ps/CLogger.h"
+#include "ps/CStr.h"
+#include "ps/Game.h"
+#include "ps/Hotkey.h"
+#include "simulation2/components/ICmpOverlayRenderer.h"
+#include "simulation2/components/ICmpRangeManager.h"
+#include "simulation2/components/ICmpSelectable.h"
+#include "simulation2/components/ICmpTerritoryManager.h"
+#include "simulation2/MessageTypes.h"
+#include "simulation2/system/ComponentManager.h"
+#include "simulation2/Simulation2.h"
+#include <sstream>
+#include <string>
+#include "renderer/Renderer.h"
+
+
+CCinemaManager::CCinemaManager()
+    : m_DrawPaths(false)
+{
+}
+
+void CCinemaManager::AddPath(const CStrW& name, CCinemaPath path)
+{
+    if (m_CinematicSimulationData.m_Paths.find(name) != m_CinematicSimulationData.m_Paths.end())
+    {
+        LOGWARNING("Path with name '%s' already exists", name.ToUTF8());
+        return;
+    }
+    m_CinematicSimulationData.m_Paths[name] = path;
+}
+
+void CCinemaManager::AddPathToQueue(const CStrW& name)
+{
+    if (!HasPath(name))
+    {
+        LOGWARNING("Path with name '%s' doesn't exist", name.ToUTF8());
+        return;
+    }
+    m_CinematicSimulationData.m_PathQueue.push_back(m_CinematicSimulationData.m_Paths[name]);
+}
+
+void CCinemaManager::ClearQueue()
+{
+    m_CinematicSimulationData.m_PathQueue.clear();
+}
+
+void CCinemaManager::SetAllPaths(const std::map<CStrW, CCinemaPath>& paths)
+{
+    m_CinematicSimulationData.m_Paths = paths;
+}
+
+void CCinemaManager::SetCurrentPath(const CStrW& name, bool current)
+{
+    // ...
+}
+
+bool CCinemaManager::HasPath(const CStrW& name) const
+{
+    return m_CinematicSimulationData.m_Paths.find(name) != m_CinematicSimulationData.m_Paths.end();
+}
+
+void CCinemaManager::SetEnabled(bool enabled)
+{
+    // TODO: maybe assert?
+    if (m_CinematicSimulationData.m_PathQueue.empty() && enabled)
+    {
+        enabled = false;
+        m_CinematicSimulationData.m_Paused = true;
+    }
+
+    if (m_CinematicSimulationData.m_Enabled == enabled)
+        return;
+
+    // sn - session gui object
+    IGUIObject *sn = g_GUI->FindObjectByName("sn");
+    CmpPtr<ICmpRangeManager> cmpRangeManager(g_Game->GetSimulation2()->GetSimContext().GetSystemEntity());
+    CmpPtr<ICmpTerritoryManager> cmpTerritoryManager(g_Game->GetSimulation2()->GetSimContext().GetSystemEntity());
+
+    // GUI visibility
+    if (sn)
+    {
+        if (enabled)
+            sn->SetSetting("hidden", L"true");
+        else
+            sn->SetSetting("hidden", L"false");
+    }
+
+    // Overlay visibility
+    g_Renderer.SetOptionBool(CRenderer::Option::OPT_SILHOUETTES, !enabled);
+    if (cmpRangeManager)
+    {
+        if (enabled)
+            m_CinematicSimulationData.m_MapRevealed = cmpRangeManager->GetLosRevealAll(-1);
+        // TODO: improve m_MapRevealed state and without fade in
+        cmpRangeManager->SetLosRevealAll(-1, enabled);
+    }
+    if (cmpTerritoryManager)
+        cmpTerritoryManager->SetVisibility(!enabled);
+    ICmpSelectable::SetOverrideVisibility(!enabled);
+    ICmpOverlayRenderer::SetOverrideVisibility(!enabled);
+
+    m_CinematicSimulationData.m_Enabled = enabled;
+}
+
+void CCinemaManager::MoveToPointAt(float time)
+{
+    // TODO: Update after Atlas UI patch
+    /*ENSURE(m_CurrentPath != m_Paths.end());
+    ClearQueue();
+
+    m_CurrentPath->second.m_TimeElapsed = time;
+    if (!m_CurrentPath->second.Validate())
+        return;
+
+    m_CurrentPath->second.MoveToPointAt(m_CurrentPath->second.m_TimeElapsed / 
+                m_CurrentPath->second.GetDuration(), m_CurrentPath->second.GetNodeFraction(), 
+                m_CurrentPath->second.m_PreviousRotation );*/
+}
+
+void CCinemaManager::Play()
+{
+    SetEnabled(true);
+    m_CinematicSimulationData.m_Paused = false;
+}
+
+void CCinemaManager::Pause()
+{
+    m_CinematicSimulationData.m_Paused = true;
+}
+
+void CCinemaManager::Stop()
+{
+    m_CinematicSimulationData.m_Paused = true;
+    SetEnabled(false);
+    m_CinematicSimulationData.m_PathQueue.clear();
+}
+
+void CCinemaManager::Skip()
+{
+    Next(true);
+}
+
+void CCinemaManager::Next(bool skipped)
+{
+    CMessageCinemaPathEnded msg(m_CinematicSimulationData.m_PathQueue.back().GetName(), skipped);
+    g_Game->GetSimulation2()->PostMessage(SYSTEM_ENTITY, msg);
+
+    m_CinematicSimulationData.m_PathQueue.pop_front();
+    if (m_CinematicSimulationData.m_PathQueue.empty())
+    {
+        SetEnabled(false);
+        m_CinematicSimulationData.m_Paused = true;
+    }
+}
+
+void CCinemaManager::Update(const float deltaRealTime)
+{
+    if (g_Game->m_Paused != m_CinematicSimulationData.m_Paused)
+    {
+        m_CinematicSimulationData.m_Paused = g_Game->m_Paused;
+
+        // sn - session gui object
+        IGUIObject *sn = g_GUI->FindObjectByName("sn");
+
+        // GUI visibility
+        if (sn)
+        {
+            if (m_CinematicSimulationData.m_Paused)
+                sn->SetSetting("hidden", L"false");
+            else
+                sn->SetSetting("hidden", L"true");
+        }
+    }
+
+    if (!m_CinematicSimulationData.m_Enabled || m_CinematicSimulationData.m_Paused)
+        return;
+    
+    if (HotkeyIsPressed("leave"))
+    {
+        Skip();
+        return;
+    }
+
+    ENSURE(m_CinematicSimulationData.m_PathQueue.size() > 0);
+    if (m_CinematicSimulationData.m_PathQueue.front().Play(deltaRealTime))
+        return;
+
+    Next();
+    return;
+}
+
+void CCinemaManager::Render()
+{
+    if (GetEnabled())
+    {
+        DrawBars();
+        return;
+    }
+    
+    if (!m_DrawPaths)
+        return;
+
+    // draw all paths
+    for (auto it : m_CinematicSimulationData.m_Paths)
+        it.second.Draw();
+}
+
+void CCinemaManager::DrawBars() const
+{
+    int height = (float)g_xres / 2.39f;
+    int shift = (g_yres - height) / 2;
+    if (shift <= 0)
+        return;
+
+#if CONFIG2_GLES
+    #warning TODO : implement bars for GLES
+#else
+    // Set up transform for GL bars
+    glMatrixMode(GL_PROJECTION);
+    glPushMatrix();
+    glLoadIdentity();
+    glMatrixMode(GL_MODELVIEW);
+    glPushMatrix();
+    glLoadIdentity();
+    CMatrix3D transform;
+    transform.SetOrtho(0.f, (float)g_xres, 0.f, (float)g_yres, -1.f, 1000.f);
+    glLoadMatrixf(&transform._11);
+
+    glColor4f(0.0f, 0.0f, 0.0f, 1.0f);
+
+    glEnable(GL_BLEND);
+    glDisable(GL_DEPTH_TEST);
+
+    glBegin(GL_QUADS);
+    glVertex2i(0, 0);
+    glVertex2i(g_xres, 0);
+    glVertex2i(g_xres, shift);
+    glVertex2i(0, shift);
+    glEnd();
+
+    glBegin(GL_QUADS);
+    glVertex2i(0, g_yres - shift);
+    glVertex2i(g_xres, g_yres - shift);
+    glVertex2i(g_xres, g_yres);
+    glVertex2i(0, g_yres);
+    glEnd();
+
+    glDisable(GL_BLEND);
+    glEnable(GL_DEPTH_TEST);
+
+    // Restore transform
+    glMatrixMode(GL_PROJECTION);
+    glPopMatrix();
+    glMatrixMode(GL_MODELVIEW);
+    glPopMatrix();
+#endif
+}
+
+InReaction cinema_manager_handler(const SDL_Event_* ev)
+{
+    // put any events that must be processed even if inactive here
+    if (!g_Game || !g_Game->IsGameStarted())
+        return IN_PASS;
+
+    CCinemaManager* pCinemaManager = g_Game->GetView()->GetCinema();
+
+    return pCinemaManager->HandleEvent(ev);
+}
+
+InReaction CCinemaManager::HandleEvent(const SDL_Event_* ev)
+{
+    switch (ev->ev.type)
+    {
+    case SDL_MOUSEBUTTONDOWN:
+    case SDL_MOUSEBUTTONUP:
+        if (GetEnabled() && !m_CinematicSimulationData.m_Paused)
+            return IN_HANDLED;
+    default:
+        return IN_PASS;
+    }
+}
+
+bool CCinemaManager::GetEnabled() const
+{
+    return m_CinematicSimulationData.m_Enabled;
+}
+
+bool CCinemaManager::IsPlaying() const
+{
+    return !m_CinematicSimulationData.m_Paused;
+}
+
+const std::map<CStrW, CCinemaPath>& CCinemaManager::GetAllPaths()
+{
+    return m_CinematicSimulationData.m_Paths;
+}
+
+CinematicSimulationData* CCinemaManager::GetCinematicSimulationData()
+{
+    return &m_CinematicSimulationData;
+}
+ No newline at end of file

source/graphics/CinemaManager.h

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#ifndef INCLUDED_CINEMAMANAGER
+#define INCLUDED_CINEMAMANAGER
+
+#include <list>
+#include <map>
+
+#include "lib/input.h" // InReaction - can't forward-declare enum
+
+#include "graphics/CinemaPath.h"
+#include "ps/CStr.h"
+
+/*
+    desc: contains various functions used for cinematic camera paths
+    See also: CinemaHandler.cpp, CinemaPath.cpp
+*/
+
+// Cinematic structure for data accessable from the simulation
+struct CinematicSimulationData
+{
+    bool m_Enabled;
+    bool m_Paused;
+    std::map<CStrW, CCinemaPath> m_Paths;
+    std::list<CCinemaPath> m_PathQueue;
+
+    // States before playing
+    bool m_MapRevealed;
+
+    CinematicSimulationData()
+        : m_Enabled(false), m_Paused(true) {}
+};
+
+/**
+ * Class for in game playing of cinematics. Should only be instantiated in CGameView. 
+ */
+
+class CCinemaManager
+{
+public:
+    CCinemaManager();
+    ~CCinemaManager() {}
+
+    /**
+     * Adds the path to the path list
+     * @param name path name
+     * @param CCinemaPath path data
+     */
+    void AddPath(const CStrW& name, CCinemaPath path);
+
+    /**
+     * Adds the path to the playlist 
+     * @param name path name 
+     */
+    void AddPathToQueue(const CStrW& name);
+
+    /**
+     * Clears the playlist
+     */
+    void ClearQueue();
+
+    /**
+     * Checks the path name in the path list
+     * @param name path name
+     * @return true if path with that name exists, else false
+     */
+    bool HasPath(const CStrW& name) const;
+    
+    /**
+     * These stop track play, and accept time, not ratio of time
+     * @time point in the timeline
+     */
+    void MoveToPointAt(float time);
+
+    // TODO: remove legacy methods after Atlas UI patch
+    const std::map<CStrW, CCinemaPath>& GetAllPaths();
+    void SetAllPaths( const std::map<CStrW, CCinemaPath>& tracks);
+    void SetCurrentPath(const CStrW& name, bool current);
+
+    /**
+     * Starts play paths
+     */
+    void Play();
+    void Pause();
+    void Next(bool skipped = false);
+    void Stop();
+    void Skip();
+    bool IsPlaying() const;
+
+    /**
+     * Renders black bars and paths (if enabled)
+     */
+    void Render();
+    void DrawBars() const;
+
+    /**
+     * Get current enable state of the cinema manager
+     */
+    bool GetEnabled() const;
+
+    /**
+     * Sets enable state of the cinema manager (shows/hide gui, show/hide rings, etc)
+     * @enable new state
+     */
+    void SetEnabled(bool enabled);
+
+    /**
+     * Updates CCinemManager and current path
+     * @param deltaRealTime Elapsed real time since the last frame.
+     */
+    void Update(const float deltaRealTime);
+
+    InReaction HandleEvent(const SDL_Event_* ev);
+
+    CinematicSimulationData* GetCinematicSimulationData();
+
+private:    
+    bool m_DrawPaths;
+
+    // Cinematic data is accessed from the simulation
+    CinematicSimulationData m_CinematicSimulationData;
+};
+
+extern InReaction cinema_manager_handler(const SDL_Event_* ev);
+
+#endif

source/graphics/CinemaPath.cpp

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "CinemaPath.h"
+
+#include <sstream>
+#include <string>
+
+#include "Camera.h"
+#include "CinemaManager.h"
+#include "GameView.h"
+#include "gui/CGUI.h"
+#include "gui/GUIManager.h"
+#include "gui/IGUIObject.h"
+#include "lib/ogl.h"
+#include "maths/MathUtil.h"
+#include "maths/Quaternion.h"
+#include "maths/Vector3D.h"
+#include "maths/Vector4D.h"
+#include "ps/CLogger.h"
+#include "ps/CStr.h"
+#include "ps/Game.h"
+#include "renderer/Renderer.h"
+
+CCinemaPath::CCinemaPath(const CCinemaData& data, const TNSpline& spline, const TNSpline& targetSpline)
+    : CCinemaData(data), TNSpline(spline), m_TargetSpline(targetSpline), m_TimeElapsed(0.f)
+{
+    BuildSpline();
+
+    if (m_Orientation == L"target")
+    {
+        m_LookAtTarget = true;
+        ENSURE(m_TargetSpline.GetAllNodes().size() > 0);
+    }
+
+    // Set distortion mode and style
+    if (data.m_Mode == L"ease_in")
+        DistModePtr = &CCinemaPath::EaseIn;
+    else if (data.m_Mode == L"ease_out")
+        DistModePtr = &CCinemaPath::EaseOut;
+    else if (data.m_Mode == L"ease_inout")
+        DistModePtr = &CCinemaPath::EaseInOut;
+    else if (data.m_Mode == L"ease_outin")
+        DistModePtr = &CCinemaPath::EaseOutIn;
+    else
+    {
+        LOGWARNING("Cinematic mode not found for '%s'\n", data.m_Mode.ToUTF8().c_str());
+        DistModePtr = &CCinemaPath::EaseInOut;
+    }
+
+    if (data.m_Style == L"default")
+        DistStylePtr = &CCinemaPath::EaseDefault;
+    else if (data.m_Style == L"growth")
+        DistStylePtr = &CCinemaPath::EaseGrowth;
+    else if (data.m_Style == L"expo")
+        DistStylePtr = &CCinemaPath::EaseExpo;
+    else if (data.m_Style == L"circle")
+        DistStylePtr = &CCinemaPath::EaseCircle;
+    else if (data.m_Style == L"sine")
+        DistStylePtr = &CCinemaPath::EaseSine;
+    else
+    {
+        LOGWARNING("Cinematic style not found for '%s'\n", data.m_Style.ToUTF8().c_str());
+        DistStylePtr = &CCinemaPath::EaseDefault;
+    }
+}
+
+void CCinemaPath::Draw() const
+{
+    DrawSpline(*this, CVector4D(0.2f, 0.2f, 1.f, 0.5f), 100, true);
+    DrawSpline(m_TargetSpline, CVector4D(1.0f, 0.2f, 0.2f, 0.5f), 100, true);
+    DrawNodes(CVector4D(0.5f, 1.0f, 0.f, 0.5f));
+}
+
+void CCinemaPath::DrawSpline(const RNSpline& spline, const CVector4D& RGBA, int smoothness, bool lines) const
+{
+    if (spline.NodeCount < 2 || DistModePtr == NULL)
+        return;
+    if (spline.NodeCount == 2 && lines)
+        smoothness = 2;
+
+    float start = spline.MaxDistance / smoothness;
+    float time = 0;
+
+#if CONFIG2_GLES
+    #warning TODO : do something about CCinemaPath on GLES
+#else
+
+    glColor4f(RGBA.X, RGBA.Y, RGBA.Z, RGBA.W);
+    if (lines)
+    {
+        glLineWidth(1.8f);
+        glEnable(GL_LINE_SMOOTH);
+        glBegin(GL_LINE_STRIP);
+
+        for (int i = 0; i <= smoothness; ++i)
+        {
+            // Find distorted time
+            time = start*i / spline.MaxDistance;
+            CVector3D tmp = spline.GetPosition(time);
+            glVertex3f(tmp.X, tmp.Y, tmp.Z);
+        }
+        glEnd();
+        glDisable(GL_LINE_SMOOTH);
+        glLineWidth(1.0f);
+    }
+    else
+    {
+        smoothness /= 2;
+        start = spline.MaxDistance / smoothness;
+        glEnable(GL_POINT_SMOOTH);
+        glPointSize(3.0f);
+        glBegin(GL_POINTS);
+
+        for (int i = 0; i <= smoothness; ++i)
+        {
+            // Find distorted time
+            time = (this->*DistModePtr)(start*i / spline.MaxDistance);
+            CVector3D tmp = spline.GetPosition(time);
+            glVertex3f(tmp.X, tmp.Y, tmp.Z);
+        }
+        glColor3f(1.0f, 1.0f, 0.0f);    // yellow
+
+        for (size_t i = 0; i < spline.GetAllNodes().size(); ++i)
+            glVertex3f(
+                spline.GetAllNodes()[i].Position.X.ToFloat(),
+                spline.GetAllNodes()[i].Position.Y.ToFloat(),
+                spline.GetAllNodes()[i].Position.Z.ToFloat()
+            );
+
+        glEnd();
+        glPointSize(1.0f);
+        glDisable(GL_POINT_SMOOTH);
+    }
+
+#endif
+}
+
+void CCinemaPath::DrawNodes(const CVector4D& RGBA) const
+{
+#if CONFIG2_GLES
+    #warning TODO : do something about CCinemaPath on GLES
+#else
+    glEnable(GL_POINT_SMOOTH);
+    glPointSize(5.0f);
+
+    glColor4f(RGBA.X, RGBA.Y, RGBA.Z, RGBA.W);
+    glBegin(GL_POINTS);
+    for (size_t i = 0; i < Node.size(); ++i)
+        glVertex3f(Node[i].Position.X.ToFloat(), Node[i].Position.Y.ToFloat(), Node[i].Position.Z.ToFloat());
+    glEnd();
+
+    if (!m_LookAtTarget)
+    {
+        glPointSize(1.0f);
+        glDisable(GL_POINT_SMOOTH);
+        return;
+    }
+
+    // draw target nodes
+    glColor4f(RGBA.Y, RGBA.X, RGBA.Z, RGBA.W);
+    glBegin(GL_POINTS);
+    for (size_t i = 0; i < m_TargetSpline.GetAllNodes().size(); ++i)
+        glVertex3f(
+            m_TargetSpline.GetAllNodes()[i].Position.X.ToFloat(),
+            m_TargetSpline.GetAllNodes()[i].Position.Y.ToFloat(),
+            m_TargetSpline.GetAllNodes()[i].Position.Z.ToFloat()
+        );
+    glEnd();
+
+    glPointSize(1.0f);
+    glDisable(GL_POINT_SMOOTH);
+#endif
+}
+
+void CCinemaPath::MoveToPointAt(float t, float nodet, const CVector3D& startRotation)
+{
+    CCamera *camera = g_Game->GetView()->GetCamera();
+    t = (this->*DistModePtr)(t);
+    CVector3D pos = GetPosition(t);
+    
+    if (m_LookAtTarget)
+    {
+        if (m_TimeElapsed <= m_TargetSpline.MaxDistance)
+            camera->LookAt(pos, m_TargetSpline.GetPosition(m_TimeElapsed / m_TargetSpline.MaxDistance), CVector3D(0, 1, 0));
+        else
+            camera->LookAt(pos, m_TargetSpline.GetAllNodes().back().Position, CVector3D(0, 1, 0));
+    }
+    else
+    {
+        CVector3D nodeRotation = Node[m_CurrentNode + 1].Rotation;
+        CQuaternion start, end;
+        start.FromEulerAngles(DEGTORAD(startRotation.X), DEGTORAD(startRotation.Y), DEGTORAD(startRotation.Z));
+        end.FromEulerAngles(DEGTORAD(nodeRotation.X), DEGTORAD(nodeRotation.Y), DEGTORAD(nodeRotation.Z));
+        start.Slerp(start, end, nodet);
+
+        camera->m_Orientation.SetIdentity();
+        camera->m_Orientation.Rotate(start);
+        camera->m_Orientation.Translate(pos);
+    }
+    camera->UpdateFrustum();
+}
+
+// Distortion mode functions
+float CCinemaPath::EaseIn(float t) const
+{
+    return (this->*DistStylePtr)(t);
+}
+
+float CCinemaPath::EaseOut(float t) const
+{
+    return 1.0f - EaseIn(1.0f - t);
+}
+
+float CCinemaPath::EaseInOut(float t) const
+{
+    if (t < m_Switch)
+        return EaseIn(1.0f / m_Switch * t) * m_Switch;
+    return EaseOut(1.0f / m_Switch * (t - m_Switch)) * m_Switch + m_Switch;
+}
+
+float CCinemaPath::EaseOutIn(float t) const
+{
+    if (t < m_Switch)
+        return EaseOut(1.0f / m_Switch * t) * m_Switch;
+    return EaseIn(1.0f / m_Switch * (t - m_Switch)) * m_Switch + m_Switch;
+}
+
+// Distortion style functions
+float CCinemaPath::EaseDefault(float t) const
+{
+    return t;
+}
+
+float CCinemaPath::EaseGrowth(float t) const
+{
+    return pow(t, m_Growth);
+}
+
+
+float CCinemaPath::EaseExpo(float t) const
+{
+    if (t == 0)
+        return t;
+    return powf(m_Growth, 10 * (t - 1.0f));
+}
+
+float CCinemaPath::EaseCircle(float t) const
+{
+    t = -(sqrt(1.0f - t*t) - 1.0f);
+    if (m_GrowthCount > 1.0f)
+    {
+        --m_GrowthCount;
+        return (this->*DistStylePtr)(t);
+    }
+    return t;
+}
+
+float CCinemaPath::EaseSine(float t) const
+{
+    t = 1.0f - cos(t * (float)M_PI / 2);
+    if (m_GrowthCount > 1.0f)
+    {
+        --m_GrowthCount;
+        return (this->*DistStylePtr)(t);
+    }
+    return t;
+}
+
+bool CCinemaPath::Validate()
+{
+    if (m_TimeElapsed > GetDuration() || m_TimeElapsed < 0.0f)
+        return false;
+
+    // Find current node and past "node time"
+    float previousTime = 0.0f, cumulation = 0.0f;
+
+    // Ignore the last node, since it is a blank (node time values are shifted down one from interface)
+    for (size_t i = 0; i < Node.size() - 1; ++i)
+    {
+        cumulation += Node[i].Distance.ToFloat();
+        if (m_TimeElapsed <= cumulation)
+        {
+            m_PreviousNodeTime = previousTime;
+            m_PreviousRotation = Node[i].Rotation;
+            m_CurrentNode = i;  // We're moving toward this next node, so use its rotation
+            break;
+        }
+        previousTime += Node[i].Distance.ToFloat();
+    }
+    return true;
+}
+
+bool CCinemaPath::Play(const float deltaRealTime)
+{
+    m_TimeElapsed += m_Timescale.ToFloat() * deltaRealTime;
+    if (!Validate())
+    {
+        m_TimeElapsed = 0.0f;
+        return false;
+    }
+    MoveToPointAt(m_TimeElapsed / GetDuration(), GetNodeFraction(), m_PreviousRotation);
+    return true;
+}

source/graphics/CinemaPath.h

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_CINEMAPATH
+#define INCLUDED_CINEMAPATH
+
+#include "maths/NUSpline.h"
+#include "ps/CStr.h"
+
+class CVector3D;
+class CVector4D;
+class CCamera;
+
+// For loading data
+class CCinemaData
+{
+public:
+    CCinemaData() : m_LookAtTarget(false), m_GrowthCount(0), m_Growth(1), m_Switch(1), m_Timescale(fixed::FromInt(1)) {}
+    virtual ~CCinemaData() {}
+
+    const CCinemaData* GetData() const { return this; }
+
+    CStrW m_Name;
+    CStrW m_Orientation;
+    CStrW m_Mode;
+    CStrW m_Style;
+
+    bool m_LookAtTarget;
+
+    fixed m_Timescale; // a negative timescale results in backwards play
+
+    // Distortion variables
+    mutable float m_GrowthCount;
+    float m_Growth;
+    float m_Switch;
+};
+
+
+// Once the data is part of the path, it shouldn't be changeable, so use private inheritance.
+// This class encompasses the spline and the information which determines how the path will operate
+// and also provides the functionality for doing so
+
+class CCinemaPath : private CCinemaData, public TNSpline
+{
+public:
+    CCinemaPath() : m_TimeElapsed(0), m_PreviousNodeTime(0) {}
+    CCinemaPath(const CCinemaData& data, const TNSpline& spline, const TNSpline& targetSpline);
+    ~CCinemaPath() { DistStylePtr = NULL;  DistModePtr = NULL; }
+
+    // Sets camera position to calculated point on spline
+    void MoveToPointAt(float t, float nodet, const CVector3D&);
+
+    // Distortion mode functions-change how ratio is passed to distortion style functions
+    float EaseIn(float t) const;
+    float EaseOut(float t) const;
+    float EaseInOut(float t) const;
+    float EaseOutIn(float t) const;
+
+    // Distortion style functions
+    float EaseDefault(float t) const;
+    float EaseGrowth(float t) const;
+    float EaseExpo(float t) const;
+    float EaseCircle(float t) const;
+    float EaseSine(float t) const;
+
+    float (CCinemaPath::*DistStylePtr)(float ratio) const;
+    float (CCinemaPath::*DistModePtr)(float ratio) const;
+
+    const CCinemaData* GetData() const { return CCinemaData::GetData(); }
+
+public:
+
+    void Draw() const;
+    void DrawSpline(const RNSpline& spline, const CVector4D& RGBA, int smoothness, bool lines) const;
+    void DrawNodes(const CVector4D& RGBA) const;
+
+    inline CVector3D GetNodePosition(const int index) const { return Node[index].Position; }
+    inline fixed GetNodeDuration(const int index) const { return Node[index].Distance; }
+    inline float GetDuration() const { return MaxDistance; }
+
+    inline float GetNodeFraction() const { return (m_TimeElapsed - m_PreviousNodeTime) / Node[m_CurrentNode].Distance.ToFloat(); }
+    inline float GetElapsedTime() const { return m_TimeElapsed; }
+
+    CStrW GetName() const { return m_Name; }
+
+    inline void SetTimescale(fixed scale) { m_Timescale = scale; }
+
+    float m_TimeElapsed;
+    float m_PreviousNodeTime;   //How much time has passed before the current node
+
+    size_t m_CurrentNode;
+    CVector3D m_PreviousRotation;
+
+public:
+
+    /**
+     * Returns false if finished.
+     * @param deltaRealTime Elapsed real time since the last frame.
+     */
+    bool Play(const float deltaRealTime);
+
+    /**
+     * Validate the path
+     * @return true if the path is valid
+     */
+    bool Validate();
+
+    /**
+     * Returns true if path doesn't contain nodes
+     */
+    bool Empty() { return Node.empty(); }
+
+    fixed GetTimescale() const { return m_Timescale; }
+
+    TNSpline* getTargetSpline() { return &m_TargetSpline; }
+
+private:
+
+    TNSpline m_TargetSpline;
+};
+
+#endif // INCLUDED_CINEMAPATH

source/graphics/CinemaTrack.cpp

@@ -1 @@
-/* Copyright (C) 2015 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#include "precompiled.h"
-#include <string>
-#include <sstream>
-#include "lib/ogl.h"
-#include "CinemaTrack.h"
-#include "ps/Game.h"
-#include "GameView.h"
-#include "maths/MathUtil.h"
-#include "Camera.h"
-#include "ps/CStr.h"
-#include "maths/Vector3D.h"
-#include "maths/Vector4D.h"
-#include "maths/Quaternion.h"
-
-CCinemaPath::CCinemaPath(const CCinemaData& data, const TNSpline& spline)
-    : CCinemaData(data), TNSpline(spline), m_TimeElapsed(0.f)
-{ 
-    m_TimeElapsed = 0;
-    BuildSpline();
-
-    //Set distortion mode and style
-    switch(data.m_Mode)
-    {
-    case CCinemaPath::EM_IN:
-        DistModePtr = &CCinemaPath::EaseIn;
-        break;
-    case CCinemaPath::EM_OUT:
-        DistModePtr = &CCinemaPath::EaseOut;
-        break;
-    case CCinemaPath::EM_INOUT:
-        DistModePtr = &CCinemaPath::EaseInOut;
-        break;
-    case CCinemaPath::EM_OUTIN:
-        DistModePtr = &CCinemaPath::EaseOutIn;
-        break;
-    default:
-        debug_printf("Cinematic mode not found for %d\n", data.m_Mode);
-        break;
-    }
-
-    switch (data.m_Style)
-    {
-    case CCinemaPath::ES_DEFAULT:
-        DistStylePtr = &CCinemaPath::EaseDefault;
-        break;
-    case CCinemaPath::ES_GROWTH:
-        DistStylePtr = &CCinemaPath::EaseGrowth;
-        break;
-    case CCinemaPath::ES_EXPO:
-        DistStylePtr = &CCinemaPath::EaseExpo;
-        break;
-    case CCinemaPath::ES_CIRCLE:
-        DistStylePtr = &CCinemaPath::EaseCircle;
-        break;
-    case CCinemaPath::ES_SINE:
-        DistStylePtr = &CCinemaPath::EaseSine;
-        break;
-    default:
-        debug_printf("Cinematic mode not found for %d\n", data.m_Style);
-        break;
-    }
-    //UpdateDuration();
-
-}
-
-void CCinemaPath::DrawSpline(const CVector4D& RGBA, int smoothness, bool lines) const
-{
-    if (NodeCount < 2 || DistModePtr == NULL)
-        return;
-    if ( NodeCount == 2 && lines )
-        smoothness = 2;
-
-    float start = MaxDistance / smoothness;
-    float time=0;
-    
-#if CONFIG2_GLES
-#warning TODO: do something about CCinemaPath on GLES
-#else
-
-    glColor4f( RGBA.X, RGBA.Y, RGBA.Z, RGBA.W );
-    if ( lines )
-    {   
-        glLineWidth(1.8f);
-        glEnable(GL_LINE_SMOOTH);
-        glBegin(GL_LINE_STRIP);
-
-        for (int i=0; i<=smoothness; ++i)
-        {
-            //Find distorted time
-            time = start*i / MaxDistance;
-            CVector3D tmp = GetPosition(time);
-            glVertex3f( tmp.X, tmp.Y, tmp.Z );
-        }
-        glEnd();
-        glDisable(GL_LINE_SMOOTH);
-        glLineWidth(1.0f);
-    }
-    else
-    {
-        smoothness /= 2;
-        start = MaxDistance / smoothness;
-        glEnable(GL_POINT_SMOOTH);
-        glPointSize(3.0f);
-        glBegin(GL_POINTS);
-
-        for (int i=0; i<=smoothness; ++i)
-        {
-            //Find distorted time
-            time = (this->*DistModePtr)(start*i / MaxDistance);
-            CVector3D tmp = GetPosition(time);
-            glVertex3f( tmp.X, tmp.Y, tmp.Z );
-        }
-        glColor3f(1.0f, 1.0f, 0.0f);    //yellow
-
-        for ( size_t i=0; i<Node.size(); ++i )
-            glVertex3f(Node[i].Position.X, Node[i].Position.Y, Node[i].Position.Z);
-
-        glEnd();
-        glPointSize(1.0f);
-        glDisable(GL_POINT_SMOOTH);
-    }
-
-#endif
-}
-
-void CCinemaPath::MoveToPointAt(float t, float nodet, const CVector3D& startRotation)
-{
-    CCamera *Cam = g_Game->GetView()->GetCamera();
-    t = (this->*DistModePtr)(t);
-    
-    CVector3D nodeRotation = Node[m_CurrentNode + 1].Rotation;
-    CQuaternion start, end;
-    start.FromEulerAngles(DEGTORAD(startRotation.X), DEGTORAD(startRotation.Y), DEGTORAD(startRotation.Z));
-    end.FromEulerAngles(DEGTORAD(nodeRotation.X), DEGTORAD(nodeRotation.Y), DEGTORAD(nodeRotation.Z));
-    start.Slerp(start, end, nodet);
-    CVector3D pos = GetPosition(t);
-    CQuaternion quat;
-    
-    Cam->m_Orientation.SetIdentity();
-    Cam->m_Orientation.Rotate(start);
-    Cam->m_Orientation.Translate(pos);
-    Cam->UpdateFrustum();
-}
-
-//Distortion mode functions
-float CCinemaPath::EaseIn(float t) const
-{
-    return (this->*DistStylePtr)(t);
-}
-float CCinemaPath::EaseOut(float t) const
-{
-    return 1.0f - EaseIn(1.0f-t);
-}
-float CCinemaPath::EaseInOut(float t) const
-{
-    if (t < m_Switch)
-        return EaseIn(1.0f/m_Switch * t) * m_Switch;
-    return EaseOut(1.0f/m_Switch * (t-m_Switch)) * m_Switch + m_Switch;
-}
-float CCinemaPath::EaseOutIn(float t) const
-{
-    if (t < m_Switch)
-        return EaseOut(1.0f/m_Switch * t) * m_Switch;
-    return EaseIn(1.0f/m_Switch * (t-m_Switch)) * m_Switch + m_Switch;
-}
-
-
-//Distortion style functions
-float CCinemaPath::EaseDefault(float t) const
-{
-    return t;
-}
-float CCinemaPath::EaseGrowth(float t) const
-{
-    return pow(t, m_Growth);
-}
-
-float CCinemaPath::EaseExpo(float t) const
-{
-    if(t == 0)
-        return t;
-    return powf(m_Growth, 10*(t-1.0f));
-}
-float CCinemaPath::EaseCircle(float t) const
-{
-     t = -(sqrt(1.0f - t*t) - 1.0f);
-     if(m_GrowthCount > 1.0f)
-     {
-         m_GrowthCount--;
-         return (this->*DistStylePtr)(t);
-     }
-     return t;
-}
-
-float CCinemaPath::EaseSine(float t) const
-{
-     t = 1.0f - cos(t * (float)M_PI/2);
-     if(m_GrowthCount > 1.0f)
-     {
-         m_GrowthCount--;
-         return (this->*DistStylePtr)(t);
-     }
-     return t;
-}
-
-bool CCinemaPath::Validate()
-{
-    if ( m_TimeElapsed <= GetDuration() && m_TimeElapsed >= 0.0f )
-    {
-        //Find current node and past "node time"
-        float previousTime = 0.0f, cumulation = 0.0f;
-        //Ignore the last node, since it is a blank (node time values are shifted down one from interface)
-        for ( size_t i = 0; i < Node.size() - 1; ++i )
-        {
-            cumulation += Node[i].Distance;
-            if ( m_TimeElapsed <= cumulation )
-            {
-                m_PreviousNodeTime = previousTime;
-                m_PreviousRotation = Node[i].Rotation;
-                m_CurrentNode = i;  //We're moving toward this next node, so use its rotation
-                return true;
-            }
-            else
-                previousTime += Node[i].Distance;
-        }
-    }
-    return false;
-}
-
-bool CCinemaPath::Play(const float deltaRealTime)
-{
-    m_TimeElapsed += m_Timescale * deltaRealTime;
-
-    if (!Validate())
-    {
-        m_TimeElapsed = 0.0f;
-        return false;
-    }
-    
-    MoveToPointAt( m_TimeElapsed / GetDuration(), GetNodeFraction(), m_PreviousRotation );
-    return true;
-}
-
-
-CCinemaManager::CCinemaManager() : m_DrawCurrentSpline(false), m_Active(true), m_ValidCurrent(false)
-{
-    m_CurrentPath = m_Paths.end();
-}
-
-void CCinemaManager::AddPath(CCinemaPath path, const CStrW& name)
-{
-    ENSURE( m_Paths.find( name ) == m_Paths.end() );
-    m_Paths[name] = path;
-}
-
-void CCinemaManager::QueuePath(const CStrW& name, bool queue )
-{
-    if (!m_PathQueue.empty() && queue == false)
-    {
-        return;
-    }
-    else
-    {
-        ENSURE(HasTrack(name));
-        m_PathQueue.push_back(m_Paths[name]);
-    }
-}
-
-void CCinemaManager::OverridePath(const CStrW& name)
-{
-    m_PathQueue.clear();
-    ENSURE(HasTrack(name));
-    m_PathQueue.push_back( m_Paths[name] );
-}
-
-void CCinemaManager::SetAllPaths( const std::map<CStrW, CCinemaPath>& paths)
-{
-    CStrW name;
-    m_Paths = paths;
-}
-void CCinemaManager::SetCurrentPath(const CStrW& name, bool current, bool drawLines)
-{
-    if ( !HasTrack(name) )
-        m_ValidCurrent = false;
-    else
-        m_ValidCurrent = true;
-
-    m_CurrentPath = m_Paths.find(name);
-    m_DrawCurrentSpline = current;
-    m_DrawLines = drawLines;
-    DrawSpline();
-}
-
-bool CCinemaManager::HasTrack(const CStrW& name) const
-{ 
-    return m_Paths.find(name) != m_Paths.end();
-}
-
-void CCinemaManager::DrawSpline() const
-{
-    if ( !(m_DrawCurrentSpline && m_ValidCurrent) )
-        return;
-    static const int smoothness = 200;
-
-    m_CurrentPath->second.DrawSpline(CVector4D(0.f, 0.f, 1.f, 1.f), smoothness, m_DrawLines);
-}
-
-void CCinemaManager::MoveToPointAt(float time)
-{
-    ENSURE(m_CurrentPath != m_Paths.end());
-    StopPlaying();
-
-    m_CurrentPath->second.m_TimeElapsed = time;
-    if ( !m_CurrentPath->second.Validate() )
-        return;
-
-    m_CurrentPath->second.MoveToPointAt(m_CurrentPath->second.m_TimeElapsed / 
-                m_CurrentPath->second.GetDuration(), m_CurrentPath->second.GetNodeFraction(), 
-                m_CurrentPath->second.m_PreviousRotation );
-}
-
-bool CCinemaManager::Update(const float deltaRealTime)
-{
-    if (!m_PathQueue.front().Play(deltaRealTime))
-    {
-        m_PathQueue.pop_front();
-        return false;
-    }
-    return true;
-}

source/graphics/CinemaTrack.h

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
- * This file is part of 0 A.D.
- *
- * 0 A.D. is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 2 of the License, or
- * (at your option) any later version.
- *
- * 0 A.D. is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-
-#ifndef INCLUDED_CINEMATRACK
-#define INCLUDED_CINEMATRACK
-
-#include <list>
-#include <map>
-#include "ps/CStr.h"
-#include "maths/NUSpline.h"
-
-/*
-    desc: contains various functions used for cinematic camera paths
-    See also: CinemaHandler.cpp, Cinematic.h/.cpp
-*/
-
-class CVector3D;
-class CVector4D;
-class CCamera;
-
-//For loading data
-class CCinemaData
-{
-public:
-    CCinemaData() : m_GrowthCount(0), m_Growth(0), m_Switch(0), 
-                    m_Mode(0), m_Style(0), m_Timescale(1) {}
-    virtual ~CCinemaData() {}
-    
-    const CCinemaData* GetData() const { return this; }
-    
-    //Distortion variables
-    mutable float m_GrowthCount;
-    float m_Growth;
-    float m_Switch;
-    int m_Mode;
-    int m_Style;
-    float m_Timescale;  //a negative timescale results in backwards play
-
-};
-
-
-//Once the data is part of the path, it shouldn't be changeable, so use private inheritance.
-//This class encompasses the spline and the information which determines how the path will operate
-//and also provides the functionality for doing so
-
-class CCinemaPath : private CCinemaData, public TNSpline
-{
-public:
-    CCinemaPath() { m_TimeElapsed = 0.0f; m_PreviousNodeTime = 0.0f; }
-    CCinemaPath(const CCinemaData& data, const TNSpline& spline);
-    ~CCinemaPath() { DistStylePtr = NULL;  DistModePtr = NULL; }
-    
-    enum { EM_IN, EM_OUT, EM_INOUT, EM_OUTIN };
-    enum { ES_DEFAULT, ES_GROWTH, ES_EXPO, ES_CIRCLE, ES_SINE };
-    
-    //sets camera position to calculated point on spline
-    void MoveToPointAt(float t, float nodet, const CVector3D& );
-    
-    //Distortion mode functions-change how ratio is passed to distortion style functions
-    float EaseIn(float t) const;
-    float EaseOut(float t) const;
-    float EaseInOut(float t) const;
-    float EaseOutIn(float t) const;
-
-    //Distortion style functions
-    float EaseDefault(float t) const;
-    float EaseGrowth(float t) const;
-    float EaseExpo(float t) const;
-    float EaseCircle(float t) const;
-    float EaseSine(float t) const;
-    
-    float (CCinemaPath::*DistStylePtr)(float ratio) const;
-    float (CCinemaPath::*DistModePtr)(float ratio) const;
-
-    const CCinemaData* GetData() const { return CCinemaData::GetData(); }
-
-public:
-
-    void DrawSpline(const CVector4D& RGBA, int smoothness, bool lines) const;
-
-    inline CVector3D GetNodePosition(const int index) const { return Node[index].Position; }
-    inline float GetNodeDuration(const int index) const { return Node[index].Distance; }
-    inline float GetDuration() const { return MaxDistance; }
-    
-    inline float GetNodeFraction() const { return (m_TimeElapsed - m_PreviousNodeTime) / Node[m_CurrentNode].Distance; }
-    inline float GetElapsedTime() const { return m_TimeElapsed; }
-
-    inline void SetTimescale(float scale) { m_Timescale = scale; }
-    
-    float m_TimeElapsed;
-    float m_PreviousNodeTime;   //How much time has passed before the current node
-    
-    size_t m_CurrentNode;
-    CVector3D m_PreviousRotation;
-
-public: 
-
-    /**
-     * Returns false if finished.
-     * 
-     * @param deltaRealTime Elapsed real time since the last frame.
-     */
-    bool Play(const float deltaRealTime);
-    bool Validate();
-
-    inline float GetTimescale() const { return m_Timescale; }   
-};
-
-//Class for in game playing of cinematics. Should only be instantiated in CGameView. 
-class CCinemaManager
-{
-public:
-    CCinemaManager();
-    ~CCinemaManager() {}
-
-    void AddPath(CCinemaPath path, const CStrW& name);
-
-    //Adds track to list of being played. 
-    void QueuePath(const CStrW& name, bool queue);
-    void OverridePath(const CStrW& name);   //clears track queue and replaces with 'name'
-
-    /**
-     * @param deltaRealTime Elapsed real time since the last frame.
-     */
-    bool Update(const float deltaRealTime);
-    
-    //These stop track play, and accept time, not ratio of time
-    void MoveToPointAt(float time);
-
-    inline void StopPlaying() { m_PathQueue.clear(); }
-    void DrawSpline() const;
-    
-    inline bool IsPlaying() const { return !m_PathQueue.empty(); }
-    bool HasTrack(const CStrW& name) const; 
-    inline bool IsActive() const { return m_Active; }
-    inline void SetActive(bool active) { m_Active=active; }
-
-    inline const std::map<CStrW, CCinemaPath>& GetAllPaths() { return m_Paths; }
-    void SetAllPaths( const std::map<CStrW, CCinemaPath>& tracks);
-    void SetCurrentPath(const CStrW& name, bool current, bool lines);
-
-private:
-    
-    bool m_Active, m_DrawCurrentSpline, m_DrawLines, m_ValidCurrent;
-    std::map<CStrW, CCinemaPath>::iterator m_CurrentPath;
-    std::map<CStrW, CCinemaPath> m_Paths;
-    std::list<CCinemaPath> m_PathQueue;
-};
-
-#endif

source/graphics/GameView.cpp

@@ -20 +20 @@
 #include "GameView.h"
 
 #include "graphics/Camera.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/ColladaManager.h"
 #include "graphics/HFTracer.h"
 #include "graphics/LOSTexture.h"
@@ -258 +258 @@
      */
     CLightEnv CachedLightEnv;
 
-    CCinemaManager TrackManager;
+    CCinemaManager CinemaManager;
 
     /**
      * Entity for the camera to follow, or INVALID_ENTITY if none.
@@ -395 +395 @@
 
 CCinemaManager* CGameView::GetCinema()
 {
-    return &m->TrackManager;
+    return &m->CinemaManager;
 };
 
 CLOSTexture& CGameView::GetLOSTexture()
@@ -626 +626 @@
     if (!g_app_has_focus)
         return;
 
-    if (m->TrackManager.IsActive() && m->TrackManager.IsPlaying())
+    if (m->CinemaManager.GetEnabled())
     {
-        if (! m->TrackManager.Update(deltaRealTime))
-        {
-//          ResetCamera();
-        }
+        m->CinemaManager.Update(deltaRealTime);
         return;
     }
 

source/graphics/MapReader.cpp

@@ -20 +20 @@
 #include "MapReader.h"
 
 #include "graphics/Camera.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/Entity.h"
 #include "graphics/GameView.h"
 #include "graphics/MapGenerator.h"
@@ -456 +456 @@
     void ReadTerrain(XMBElement parent);
     void ReadEnvironment(XMBElement parent);
     void ReadCamera(XMBElement parent);
-    void ReadCinema(XMBElement parent);
+    void ReadPaths(XMBElement parent);
     void ReadTriggers(XMBElement parent);
     int ReadEntities(XMBElement parent, double end_time);
 };
@@ -839 +839 @@
     }
 }
 
-void CXMLReader::ReadCinema(XMBElement parent)
+void CXMLReader::ReadPaths(XMBElement parent)
 {
     #define EL(x) int el_##x = xmb_file.GetElementID(#x)
     #define AT(x) int at_##x = xmb_file.GetAttributeID(#x)
@@ -849 +849 @@
     EL(distortion);
     EL(node);
     EL(position);
-    EL(time);
+    EL(target);
     AT(name);
     AT(timescale);
+    AT(orientation);
     AT(mode);
     AT(style);
     AT(growth);
@@ -859 +860 @@
     AT(x);
     AT(y);
     AT(z);
+    AT(deltatime);
 
 #undef EL
 #undef AT
-    
-    std::map<CStrW, CCinemaPath> pathList;
+
     XERO_ITER_EL(parent, element)
     {
         int elementName = element.GetNodeName();
-            
-        if ( elementName == el_path )
+        if (elementName == el_path)
         {
+            CCinemaData pathData;
             XMBAttributeList attrs = element.GetAttributes();
-            CStrW name(attrs.GetNamedItem(at_name).FromUTF8());
-            float timescale = attrs.GetNamedItem(at_timescale).ToFloat();
-            CCinemaData pathData;
-            pathData.m_Timescale = timescale;
-            TNSpline spline, backwardSpline;
+            CStrW pathName(attrs.GetNamedItem(at_name).FromUTF8());
+            pathData.m_Timescale = fixed::FromFloat(attrs.GetNamedItem(at_timescale).ToFloat());
+            TNSpline pathSpline, targetSpline;
+            fixed lastTargetTime = fixed::Zero();
+            
+            pathData.m_Name = pathName;
+            pathData.m_Orientation = attrs.GetNamedItem(at_orientation).FromUTF8();
+            pathData.m_Mode = attrs.GetNamedItem(at_mode).FromUTF8();
+            pathData.m_Style = attrs.GetNamedItem(at_style).FromUTF8();
 
             XERO_ITER_EL(element, pathChild)
             {
                 elementName = pathChild.GetNodeName();
                 attrs = pathChild.GetAttributes();
-
-                //Load distortion attributes
-                if ( elementName == el_distortion )
-                {
-                        pathData.m_Mode = attrs.GetNamedItem(at_mode).ToInt();
-                        pathData.m_Style = attrs.GetNamedItem(at_style).ToInt();
-                        pathData.m_Growth = attrs.GetNamedItem(at_growth).ToInt();
-                        pathData.m_Switch = attrs.GetNamedItem(at_switch).ToInt();
-                }
                 
-                //Load node data used for spline
-                else if ( elementName == el_node )
+                // Load node data used for spline
+                if (elementName == el_node)
                 {
+                    bool positionDeclared = false;
                     SplineData data;
+                    data.Distance = fixed::FromFloat(pathChild.GetAttributes().GetNamedItem(at_deltatime).ToFloat());
+                    lastTargetTime += fixed::FromFloat(pathChild.GetAttributes().GetNamedItem(at_deltatime).ToFloat());
                     XERO_ITER_EL(pathChild, nodeChild)
                     {
                         elementName = nodeChild.GetNodeName();
                         attrs = nodeChild.GetAttributes();
-                        
-                        //Fix?:  assumes that time is last element
-                        if ( elementName == el_position )
+                        if (elementName == el_position)
                         {
-                            data.Position.X = attrs.GetNamedItem(at_x).ToFloat();
-                            data.Position.Y = attrs.GetNamedItem(at_y).ToFloat();
-                            data.Position.Z = attrs.GetNamedItem(at_z).ToFloat();
-                            continue;
+                            data.Position.X = fixed::FromFloat(attrs.GetNamedItem(at_x).ToFloat());
+                            data.Position.Y = fixed::FromFloat(attrs.GetNamedItem(at_y).ToFloat());
+                            data.Position.Z = fixed::FromFloat(attrs.GetNamedItem(at_z).ToFloat());
+                            positionDeclared = true;
                         }
-                        else if ( elementName == el_rotation )
+                        else if (elementName == el_rotation)
                         {
-                            data.Rotation.X = attrs.GetNamedItem(at_x).ToFloat();
-                            data.Rotation.Y = attrs.GetNamedItem(at_y).ToFloat();
-                            data.Rotation.Z = attrs.GetNamedItem(at_z).ToFloat();
-                            continue;
+                            data.Rotation.X = fixed::FromFloat(attrs.GetNamedItem(at_x).ToFloat());
+                            data.Rotation.Y = fixed::FromFloat(attrs.GetNamedItem(at_y).ToFloat());
+                            data.Rotation.Z = fixed::FromFloat(attrs.GetNamedItem(at_z).ToFloat());
                         }
-                        else if ( elementName == el_time )
-                            data.Distance = nodeChild.GetText().ToFloat();
+                        else if (elementName == el_target)
+                        {
+                            CFixedVector3D targetPosition;
+                            targetPosition.X = fixed::FromFloat(attrs.GetNamedItem(at_x).ToFloat());
+                            targetPosition.Y = fixed::FromFloat(attrs.GetNamedItem(at_y).ToFloat());
+                            targetPosition.Z = fixed::FromFloat(attrs.GetNamedItem(at_z).ToFloat());
+
+                            targetSpline.AddNode(targetPosition, CFixedVector3D(), lastTargetTime);
+                            lastTargetTime = fixed::Zero();
+                        }
                         else 
-                            debug_warn(L"Invalid cinematic element for node child");
-                    
-                        backwardSpline.AddNode(data.Position, data.Rotation, data.Distance);
+                            LOGWARNING("Invalid cinematic element for node child");
                     }
+
+                    // skip the node if no position
+                    if (positionDeclared)
+                        pathSpline.AddNode(data.Position, data.Rotation, data.Distance);
                 }
                 else
-                    debug_warn(L"Invalid cinematic element for path child");
-                
-                
+                    LOGWARNING("Invalid cinematic element for path child");
             }
 
-            //Construct cinema path with data gathered
-            CCinemaPath temp(pathData, backwardSpline);
-            const std::vector<SplineData>& nodes = temp.GetAllNodes();
-            if ( nodes.empty() )
+            // Construct cinema path with data gathered
+            CCinemaPath path(pathData, pathSpline, targetSpline);
+            if (path.Empty())
             {
-                debug_warn(L"Failure loading cinematics");
+                LOGWARNING("Path with name '%s' is empty", pathName.ToUTF8());
                 return;
             }
-                    
-            for ( std::vector<SplineData>::const_reverse_iterator it = nodes.rbegin(); 
-                                                            it != nodes.rend(); ++it )
-            {
-                spline.AddNode(it->Position, it->Rotation, it->Distance);
-            }
-                
-            CCinemaPath path(pathData, spline);
-            pathList[name] = path;  
+
+            if (!m_MapReader.pCinema->HasPath(pathName))
+                m_MapReader.pCinema->AddPath(pathName, path);
+            else
+                LOGWARNING("Path with name '%s' already exists", pathName.ToUTF8());
         }
         else
-            ENSURE("Invalid cinema child");
+            LOGWARNING("Invalid path child with name '%s'", element.GetText());
     }
-
-    if (m_MapReader.pCinema)
-        m_MapReader.pCinema->SetAllPaths(pathList);
 }
 
 void CXMLReader::ReadTriggers(XMBElement UNUSED(parent))
@@ -1125 +1121 @@
         }
         else if (name == "Paths")
         {
-            ReadCinema(node);
+            ReadPaths(node);
         }
         else if (name == "Triggers")
         {

source/graphics/MapReader.h

@@ -70 +70 @@
 
     // UnpackTerrain: unpack the terrain from the input stream
     int UnpackTerrain();
-    //UnpackCinema: unpack the cinematic tracks from the input stream
+    // UnpackCinema: unpack the cinematic tracks from the input stream
     int UnpackCinema();
 
     // UnpackMap: unpack the given data from the raw data stream into local variables

source/graphics/MapWriter.cpp

@@ -18 +18 @@
 #include "precompiled.h"
 
 #include "Camera.h"
-#include "CinemaTrack.h"
+#include "CinemaManager.h"
 #include "GameView.h"
 #include "LightEnv.h"
 #include "MapReader.h"
@@ -408 +408 @@
 
             for ( ; it != paths.end(); ++it )
             {
-                CStrW name = it->first;
-                float timescale = it->second.GetTimescale();
+                fixed timescale = it->second.GetTimescale();
+                const std::vector<SplineData>& nodes = it->second.GetAllNodes();
+                const CCinemaData* data = it->second.GetData();
                 
                 XML_Element("Path");
-                XML_Attribute("name", name);
+                XML_Attribute("name", data->m_Name);
                 XML_Attribute("timescale", timescale);
+                XML_Attribute("orientation", data->m_Orientation);
+                XML_Attribute("mode", data->m_Mode);
+                XML_Attribute("style", data->m_Style);
 
-                const std::vector<SplineData>& nodes = it->second.GetAllNodes();
-                const CCinemaData* data = it->second.GetData();
-                
+                // TODO: write target nodes
+                for (size_t j = 0; j < nodes.size(); ++j)
                 {
-                    XML_Element("Distortion");
-                    XML_Attribute("mode", data->m_Mode);
-                    XML_Attribute("style", data->m_Style);
-                    XML_Attribute("growth", data->m_Growth);
-                    XML_Attribute("switch", data->m_Switch);
-                }
-
-                for ( ssize_t j=nodes.size()-1; j >= 0; --j )
-                {
                     XML_Element("Node");
+                    if (j > 0)
+                        XML_Attribute("deltatime", nodes[j - 1].Distance);
+                    else
+                        XML_Attribute("deltatime", 0.0f);
                     
                     {
                         XML_Element("Position");
@@ -443 +441 @@
                         XML_Attribute("y", nodes[j].Rotation.Y);
                         XML_Attribute("z", nodes[j].Rotation.Z);
                     }
-
-                    XML_Setting("Time", nodes[j].Distance);
                 }
             }
         }

source/lib/input.cpp

@@ -32 +32 @@
 
 #include "lib/external_libraries/libsdl.h"
 
-const size_t MAX_HANDLERS = 8;
+const size_t MAX_HANDLERS = 9;
 static InHandler handler_stack[MAX_HANDLERS];
 static size_t handler_stack_top = 0;
 

source/maths/NUSpline.cpp

@@ -1 @@
-/* Copyright (C) 2009 Wildfire Games.
+/* Copyright (C) 2015 Wildfire Games.
  * This file is part of 0 A.D.
  *
  * 0 A.D. is free software: you can redistribute it and/or modify
@@ -46 +46 @@
 /*********************************** R N S **************************************************/
 
 // adds node and updates segment length
-void RNSpline::AddNode(const CVector3D &pos)
+void RNSpline::AddNode(const CFixedVector3D &pos)
 {
-  if ( NodeCount >= MAX_SPLINE_NODES )
-      return;
-  if (NodeCount == 0)
-    MaxDistance = 0.f;
-  else
-  {
-    Node[NodeCount-1].Distance = (Node[NodeCount-1].Position - pos).Length();
-    MaxDistance += Node[NodeCount-1].Distance;
-  }
-  SplineData temp;
-  temp.Position = pos;
-  Node.push_back(temp);
-  NodeCount++;
+    if (NodeCount >= MAX_SPLINE_NODES)
+        return;
+    if (NodeCount == 0)
+        MaxDistance = 0.f;
+    else
+    {
+        Node[NodeCount - 1].Distance = (Node[NodeCount - 1].Position - pos).Length();
+        MaxDistance += Node[NodeCount - 1].Distance.ToFloat();
+    }
+    SplineData temp;
+    temp.Position = pos;
+    Node.push_back(temp);
+    NodeCount++;
 }
 
 
@@ -67 +67 @@
 // called after all nodes added. This function calculates the node velocities
 void RNSpline::BuildSpline()
 {
-  if ( NodeCount == 2 )
-  {
-      Node[0].Velocity = GetStartVelocity(0);
-      Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
-      return;
-  }
-  else if ( NodeCount < 2 )
-      return;
-  
-  for (int i = 1; i<NodeCount-1; i++)
-  {
-    CVector3D Next = Node[i+1].Position - Node[i].Position;
-    CVector3D Previous = Node[i-1].Position - Node[i].Position;
-    Next.Normalize();
-    Previous.Normalize();
-     
-    // split the angle (figure 4)
-    Node[i].Velocity = Next - Previous;
-    Node[i].Velocity.Normalize();
-  }
-  // calculate start and end velocities
-  Node[0].Velocity = GetStartVelocity(0);
-  Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
+    if (NodeCount == 2)
+    {
+        Node[0].Velocity = GetStartVelocity(0);
+        Node[NodeCount - 1].Velocity = GetEndVelocity(NodeCount - 1);
+        return;
+    }
+    else if (NodeCount < 2)
+        return;
+
+    for (int i = 1; i < NodeCount - 1; ++i)
+    {
+        CVector3D Next = Node[i + 1].Position - Node[i].Position;
+        CVector3D Previous = Node[i - 1].Position - Node[i].Position;
+        Next.Normalize();
+        Previous.Normalize();
+
+        // split the angle (figure 4)
+        Node[i].Velocity = Next - Previous;
+        Node[i].Velocity.Normalize();
+    }
+    // calculate start and end velocities
+    Node[0].Velocity = GetStartVelocity(0);
+    Node[NodeCount - 1].Velocity = GetEndVelocity(NodeCount - 1);
 }
 
 // spline access function. time is 0 -> 1
 CVector3D RNSpline::GetPosition(float time) const
 {
-  if ( NodeCount < 2 )
-      return CVector3D(0.0f, 0.0f, 0.0f);
-  if ( time > 1.0f )
+    if (NodeCount < 2)
+        return CVector3D(0.0f, 0.0f, 0.0f);
+    if (time < 0.0f)
+        time = 0.0f;
+    if (time > 1.0f)
         time = 1.0f;
-  float Distance = time * MaxDistance;
-  float CurrentDistance = 0.f;
-  int i = 0;
-  
-  //Find which node we're on
-  while (CurrentDistance + Node[i].Distance < Distance
-    && i < NodeCount - 2)
-  {
-    CurrentDistance += Node[i].Distance;
-    i++;
-  }
-  ENSURE( i < NodeCount - 1 ); 
-  float t = Distance - CurrentDistance;
-  t /= Node[i].Distance; // scale t in range 0 - 1
-  CVector3D startVel = Node[i].Velocity * Node[i].Distance;
-  CVector3D endVel = Node[i+1].Velocity * Node[i].Distance;   
-  return GetPositionOnCubic(Node[i].Position, startVel,
-                         Node[i+1].Position, endVel, t);
+    float Distance = time * MaxDistance;
+    float CurrentDistance = 0.f;
+    int i = 0;
+
+    // Find which node we're on
+    while (CurrentDistance + Node[i].Distance.ToFloat() < Distance
+        && i < NodeCount - 2)
+    {
+        CurrentDistance += Node[i].Distance.ToFloat();
+        ++i;
+    }
+    ENSURE(i < NodeCount - 1);
+    float t = Distance - CurrentDistance;
+    // TODO: reimplement CVector3D comparator (float comparing is bad without EPS)
+    if (Node[i].Position == Node[i + 1].Position || Node[i].Distance.ToFloat() < 1e-7) // distance too small or zero
+    {
+        return Node[i + 1].Position;
+    }
+    t /= Node[i].Distance.ToFloat(); // scale t in range 0 - 1
+    CVector3D startVel = Node[i].Velocity * Node[i].Distance.ToFloat();
+    CVector3D endVel = Node[i + 1].Velocity * Node[i].Distance.ToFloat();
+    return GetPositionOnCubic(Node[i].Position, startVel,
+        Node[i + 1].Position, endVel, t);
 }
 
 // internal. Based on Equation 14 
 CVector3D RNSpline::GetStartVelocity(int index)
 {
-  if ( index >= NodeCount - 1 || index < 0)
-      return CVector3D(0.0f, 0.0f, 0.0f);
-  CVector3D temp = (Node[index+1].Position - Node[index].Position) * 3.0f * ( 1.0f / Node[index].Distance) ;
-  return (temp - Node[index+1].Velocity)*0.5f;
+    if (index >= NodeCount - 1 || index < 0)
+        return CVector3D(0.0f, 0.0f, 0.0f);
+    CVector3D temp = CVector3D(Node[index + 1].Position - Node[index].Position) * 3.0f * (1.0f / Node[index].Distance.ToFloat());
+    return (temp - Node[index + 1].Velocity)*0.5f;
 }
 
 // internal. Based on Equation 15 
 CVector3D RNSpline::GetEndVelocity(int index)
 {
-  if ( index >= NodeCount || index < 1)
-      return CVector3D(0.0f, 0.0f, 0.0f);
-  CVector3D temp = (Node[index].Position - Node[index-1].Position) * 3.0f * (1.0f / Node[index-1].Distance);
-  return (temp - Node[index-1].Velocity) * 0.5f;
+    if (index >= NodeCount || index < 1)
+        return CVector3D(0.0f, 0.0f, 0.0f);
+    CVector3D temp = CVector3D(Node[index].Position - Node[index - 1].Position) * 3.0f * (1.0f / Node[index - 1].Distance.ToFloat());
+    return (temp - Node[index - 1].Velocity) * 0.5f;
 }
 
 /*********************************** S N S **************************************************/
@@ -142 +149 @@
 // smoothing filter.
 void SNSpline::Smooth()
 {
-  if ( NodeCount < 3 )
-      return;
-  CVector3D newVel;
-  CVector3D oldVel = GetStartVelocity(0);
-  for (int i = 1; i<NodeCount-1; i++)
-  {
-    // Equation 12
-    newVel = GetEndVelocity(i) * Node[i].Distance +
-             GetStartVelocity(i) * Node[i-1].Distance;
-    newVel = newVel * ( 1 / (Node[i-1].Distance + Node[i].Distance) );
-    Node[i-1].Velocity = oldVel;
-    oldVel = newVel;
-  }
-  Node[NodeCount-1].Velocity = GetEndVelocity(NodeCount-1);
-  Node[NodeCount-2].Velocity = oldVel;
+    if (NodeCount < 3)
+        return;
+    CVector3D newVel;
+    CVector3D oldVel = GetStartVelocity(0);
+    for (int i = 1; i < NodeCount - 1; ++i)
+    {
+        // Equation 12
+        newVel = GetEndVelocity(i) * Node[i].Distance.ToFloat() +
+            GetStartVelocity(i) * Node[i - 1].Distance.ToFloat();
+        newVel = newVel * (1 / (Node[i - 1].Distance + Node[i].Distance).ToFloat());
+        Node[i - 1].Velocity = oldVel;
+        oldVel = newVel;
+    }
+    Node[NodeCount - 1].Velocity = GetEndVelocity(NodeCount - 1);
+    Node[NodeCount - 2].Velocity = oldVel;
 }
 
 /*********************************** T N S **************************************************/
@@ -163 +170 @@
 
 // as with RNSpline but use timePeriod in place of actual node spacing
 // ie time period is time from last node to this node
-void TNSpline::AddNode(const CVector3D &pos, const CVector3D& rotation, float timePeriod)
+void TNSpline::AddNode(const CFixedVector3D &pos, const CFixedVector3D& rotation, fixed timePeriod)
 {
-  if ( NodeCount >= MAX_SPLINE_NODES )
-      return;
-  if (NodeCount == 0)
-     MaxDistance = 0.f;
-  else
-  {
-    Node[NodeCount-1].Distance = timePeriod;
-    MaxDistance += Node[NodeCount-1].Distance;
-  }
+    if (NodeCount >= MAX_SPLINE_NODES)
+        return;
+    if (NodeCount == 0)
+        MaxDistance = 0.f;
+    else
+    {
+        Node[NodeCount - 1].Distance = timePeriod;
+        MaxDistance += Node[NodeCount - 1].Distance.ToFloat();
+    }
 
-  SplineData temp;
-  temp.Position = pos;
+    SplineData temp;
+    temp.Position = pos;
 
-  //make sure we don't end up using undefined numbers...
-  temp.Distance = 0.0f;
-  temp.Velocity = CVector3D( 0.0f, 0.0f, 0.0f );
-  temp.Rotation = rotation;
-  Node.push_back(temp);
-  NodeCount++;
+    //make sure we don't end up using undefined numbers...
+    temp.Distance = fixed::FromFloat(0.0f);
+    temp.Velocity = CVector3D(0.0f, 0.0f, 0.0f);
+    temp.Rotation = rotation;
+    Node.push_back(temp);
+    NodeCount++;
 }
 
 //Inserts node before position
-void TNSpline::InsertNode(const int index, const CVector3D &pos, const CVector3D& rotation, float timePeriod)
+void TNSpline::InsertNode(const int index, const CFixedVector3D &pos, const CFixedVector3D& rotation, fixed timePeriod)
 {
-  if ( NodeCount >= MAX_SPLINE_NODES || index < NodeCount - 1  )
-      return;
-  if (NodeCount == 0)
-      MaxDistance = 0.f;
-  else
-  {
-    Node[NodeCount-1].Distance = timePeriod;
-    Node[NodeCount-1].Rotation = rotation;
-    MaxDistance += Node[NodeCount-1].Distance;
-  }
-  SplineData temp;
-  temp.Position = pos;
-  Node.insert(Node.begin() + index, temp);
-  NodeCount++;
+    if (NodeCount >= MAX_SPLINE_NODES || index < NodeCount - 1)
+        return;
+    if (NodeCount == 0)
+        MaxDistance = 0.f;
+    else
+    {
+        Node[NodeCount - 1].Distance = timePeriod;
+        Node[NodeCount - 1].Rotation = rotation;
+        MaxDistance += Node[NodeCount - 1].Distance.ToFloat();
+    }
+    SplineData temp;
+    temp.Position = pos;
+    Node.insert(Node.begin() + index, temp);
+    NodeCount++;
 }
 //Removes node at index
 void TNSpline::RemoveNode(const int index)
 {
-  if (NodeCount == 0 || index > NodeCount - 1 )
-  {
-     return;
-  }
-  else
-  {
-      MaxDistance -= Node[index].Distance;
-      MaxDistance -= Node[index-1].Distance;
-      Node[index-1].Distance = 0.0f;
-      Node.erase( Node.begin() + index, Node.begin() + index + 1 );
-  }
-  NodeCount--;
+    if (NodeCount == 0 || index > NodeCount - 1)
+    {
+        return;
+    }
+    else
+    {
+        MaxDistance -= Node[index].Distance.ToFloat();
+        MaxDistance -= Node[index - 1].Distance.ToFloat();
+        Node[index - 1].Distance = fixed::FromFloat(0.0f);
+        Node.erase(Node.begin() + index, Node.begin() + index + 1);
+    }
+    NodeCount--;
 }
-void TNSpline::UpdateNodeTime(const int index, float time)
+void TNSpline::UpdateNodeTime(const int index, fixed time)
 { 
     if (NodeCount == 0 || index > NodeCount - 1 )
     {
@@ -228 +235 @@
     }
     Node[index].Distance = time; 
 }
-void TNSpline::UpdateNodePos(const int index, const CVector3D &pos)
+void TNSpline::UpdateNodePos(const int index, const CFixedVector3D &pos)
 { 
     if (NodeCount == 0 || index > NodeCount - 1 )
     {
@@ -238 +245 @@
 }
 void TNSpline::Constrain()
 {
-  if ( NodeCount < 3 )
-      return;
-  for (int i = 1; i<NodeCount-1; i++)
-  {
-    // Equation 13
-    float r0 = (Node[i].Position-Node[i-1].Position).Length() / Node[i-1].Distance;
-    float r1 = (Node[i+1].Position - Node[i].Position).Length() / Node[i].Distance;
-    Node[i].Velocity *= 4.0f*r0*r1/((r0+r1)*(r0+r1));
-  }
+    if (NodeCount < 3)
+        return;
+    for (int i = 1; i < NodeCount - 1; ++i)
+    {
+        // Equation 13
+        float r0 = (Node[i].Position - Node[i - 1].Position).Length().ToFloat() / Node[i - 1].Distance.ToFloat();
+        float r1 = (Node[i + 1].Position - Node[i].Position).Length().ToFloat() / Node[i].Distance.ToFloat();
+        Node[i].Velocity *= 4.0f*r0*r1 / ((r0 + r1)*(r0 + r1));
+    }
 }
 

source/maths/NUSpline.h

@@ -22 +22 @@
 #ifndef INCLUDED_NUSPLINE
 #define INCLUDED_NUSPLINE
 
+// TODO: why not bigger?
 #define MAX_SPLINE_NODES 40
 #include <stdlib.h>
+
+#include "FixedVector3D.h"
 #include "Vector3D.h"
 
+// TODO: make template (ie, for non-fixed data)
 struct SplineData
 {
-    CVector3D Position;
+    // Should be fixed, because used in the simulation
+    CFixedVector3D Position;
     CVector3D Velocity;
-    CVector3D Rotation;
-    float Distance/*, DistanceOffset*/; //DistanceOffset is to keep track of how far into the spline this node is
+    // TODO: make rotation as other spline
+    CFixedVector3D Rotation;
+    fixed Distance/*, DistanceOffset*/; //DistanceOffset is to keep track of how far into the spline this node is
 };
 
 class RNSpline
 {
 public:
-    
+
     RNSpline() { NodeCount = 0; }
     virtual ~RNSpline() {}
-  
-  void AddNode(const CVector3D &pos);
-  void BuildSpline();
-  CVector3D GetPosition(float time) const;
-  CVector3D GetRotation(float time) const;
-  const std::vector<SplineData>& GetAllNodes() const { return Node; }
-  
-  float MaxDistance;
-  int NodeCount;
 
+    void AddNode(const CFixedVector3D &pos);
+    void BuildSpline();
+    CVector3D GetPosition(float time) const;
+    CVector3D GetRotation(float time) const;
+    const std::vector<SplineData>& GetAllNodes() const { return Node; }
+
+    float MaxDistance;
+    int NodeCount;
+
 protected:
-  std::vector<SplineData> Node;
-  CVector3D GetStartVelocity(int index);
-  CVector3D GetEndVelocity(int index);
+    std::vector<SplineData> Node;
+    CVector3D GetStartVelocity(int index);
+    CVector3D GetEndVelocity(int index);
 };
 
 class SNSpline : public RNSpline
@@ -60 +66 @@
 {
 public:
     virtual ~SNSpline() {}
-  void BuildSpline(){ RNSpline::BuildSpline(); Smooth(); Smooth(); Smooth(); }
-  void Smooth();
+    void BuildSpline(){ RNSpline::BuildSpline(); Smooth(); Smooth(); Smooth(); }
+    void Smooth();
 };
 
 class TNSpline : public SNSpline
@@ -69 +75 @@
 public:
     virtual ~TNSpline() {}
 
-  void AddNode(const CVector3D& pos, const CVector3D& rotation, float timePeriod);
-  void PushNode() { Node.push_back( SplineData() ); }
-  void InsertNode(const int index, const CVector3D &pos, const CVector3D& rotation, float timePeriod);
-  void RemoveNode(const int index);
-  void UpdateNodeTime(const int index, float time);
-  void UpdateNodePos(const int index, const CVector3D &pos);
-  
-  void BuildSpline(){ RNSpline::BuildSpline();  Smooth(); Smooth(); Smooth(); }
-  void Smooth(){ for( int x=0; x<3; x++ ) { SNSpline::Smooth(); Constrain(); }  }
-  void Constrain(); 
+    void AddNode(const CFixedVector3D& pos, const CFixedVector3D& rotation, fixed timePeriod);
+    void PushNode() { Node.push_back(SplineData()); }
+    void InsertNode(const int index, const CFixedVector3D &pos, const CFixedVector3D& rotation, fixed timePeriod);
+    void RemoveNode(const int index);
+    void UpdateNodeTime(const int index, fixed time);
+    void UpdateNodePos(const int index, const CFixedVector3D &pos);
+
+    void BuildSpline(){ RNSpline::BuildSpline();  Smooth(); Smooth(); Smooth(); }
+    void Smooth(){ for (int x = 0; x < 3; x++) { SNSpline::Smooth(); Constrain(); } }
+    void Constrain();
 };
 
 #endif // INCLUDED_NUSPLINE

source/ps/GameSetup/GameSetup.cpp

@@ -35 +35 @@
 #include "lib/sysdep/os/win/wversion.h"
 #endif
 
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/FontMetrics.h"
 #include "graphics/GameView.h"
 #include "graphics/LightEnv.h"
@@ -226 +226 @@
 
     ogl_WarnIfError();
 
+    if (g_Game && g_Game->IsGameStarted())
+        g_Game->GetView()->GetCinema()->Render();
+
+    ogl_WarnIfError();
+
     g_Renderer.RenderTextOverlays();
 
     if (g_DoRenderGui)
@@ -573 +578 @@
 
     in_add_handler(touch_input_handler);
 
+    in_add_handler(cinema_manager_handler);
+
     // must be registered after (called before) the GUI which relies on these globals
     in_add_handler(GlobalsInputHandler);
 }

source/ps/Globals.cpp

@@ -20 +20 @@
 
 #include "lib/external_libraries/libsdl.h"
 #include "network/NetClient.h"
+
+#include "graphics/CinemaManager.h"
+#include "graphics/GameView.h"
+#include "ps/Game.h"
 #include "ps/GameSetup/Config.h"
 #include "soundmanager/ISoundManager.h"
 

source/simulation2/components/CCmpCinemaManager.cpp

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "simulation2/system/Component.h"
+#include "ICmpCinemaManager.h"
+
+#include "graphics/GameView.h"
+#include "graphics/CinemaManager.h"
+#include "ps/CLogger.h"
+#include "ps/Game.h"
+#include "simulation2/MessageTypes.h"
+
+
+class CCmpCinemaManager : public ICmpCinemaManager
+{
+public:
+    static void ClassInit(CComponentManager& componentManager)
+    {
+        componentManager.SubscribeToMessageType(MT_CinemaPathEnded);
+    }
+
+    DEFAULT_COMPONENT_ALLOCATOR(CinemaManager)
+
+    static std::string GetSchema()
+    {
+        return "<a:component type='system'/>"
+            "<empty/>"
+            ;
+    }
+
+    virtual void Init(const CParamNode& UNUSED(paramNode))
+    {
+        // ...
+    }
+
+    virtual void Deinit()
+    {
+        // ...
+    }
+
+    virtual void Serialize(ISerializer& serialize)
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        CinematicSimulationData* p_CinematicSimulationData = g_Game->GetView()->GetCinema()->GetCinematicSimulationData();
+        serialize.Bool("Enabled", p_CinematicSimulationData->m_Enabled);
+        serialize.Bool("MapRevealed", p_CinematicSimulationData->m_MapRevealed);
+        serialize.Bool("Paused", p_CinematicSimulationData->m_Paused);
+        serialize.NumberU32_Unbounded("NumberOfPaths", p_CinematicSimulationData->m_Paths.size());
+        for (auto it : p_CinematicSimulationData->m_Paths)
+        {
+            CCinemaPath& path = it.second;
+            const CCinemaData* data = path.GetData();
+
+            // TODO: maybe implement String_Unbounded
+            serialize.String("PathName", data->m_Name, 1, 2048);
+            serialize.String("PathOrientation", data->m_Orientation, 1, 2048);
+            serialize.String("PathMode", data->m_Mode, 1, 2048);
+            serialize.String("PathStyle", data->m_Style, 1, 2048);
+            serialize.NumberFixed_Unbounded("PathTimescale", data->m_Timescale);
+            serialize.Bool("LookAtTarget", data->m_LookAtTarget);
+
+            serialize.NumberU32("NumberOfNodes", path.GetAllNodes().size(), 1, MAX_SPLINE_NODES);
+            const std::vector<SplineData>& nodes = path.GetAllNodes();
+            for (size_t i = 0; i < nodes.size(); ++i)
+            {
+                if (i > 0)
+                    serialize.NumberFixed_Unbounded("NodeDeltaTime", nodes[i - 1].Distance);
+                else
+                    serialize.NumberFixed_Unbounded("NodeDeltaTime", fixed::Zero());
+                serialize.NumberFixed_Unbounded("PositionX", nodes[i].Position.X);
+                serialize.NumberFixed_Unbounded("PositionY", nodes[i].Position.Y);
+                serialize.NumberFixed_Unbounded("PositionZ", nodes[i].Position.Z);
+
+                serialize.NumberFixed_Unbounded("RotationX", nodes[i].Rotation.X);
+                serialize.NumberFixed_Unbounded("RotationY", nodes[i].Rotation.Y);
+                serialize.NumberFixed_Unbounded("RotationZ", nodes[i].Rotation.Z);
+            }
+
+            if (!data->m_LookAtTarget)
+                continue;
+
+            const std::vector<SplineData>& targetNodes = path.getTargetSpline()->GetAllNodes();
+            serialize.NumberU32("NumberOfTargetNodes", targetNodes.size(), 1, MAX_SPLINE_NODES);
+            for (size_t i = 0; i < targetNodes.size(); ++i)
+            {
+                if (i > 0)
+                    serialize.NumberFixed_Unbounded("NodeDeltaTime", nodes[i - 1].Distance);
+                else
+                    serialize.NumberFloat_Unbounded("NodeDeltaTime", 0);
+                serialize.NumberFixed_Unbounded("PositionX", nodes[i].Position.X);
+                serialize.NumberFixed_Unbounded("PositionY", nodes[i].Position.Y);
+                serialize.NumberFixed_Unbounded("PositionZ", nodes[i].Position.Z);
+            }
+        }
+    }
+
+    virtual void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserialize)
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        CinematicSimulationData* p_CinematicSimulationData = g_Game->GetView()->GetCinema()->GetCinematicSimulationData();
+        deserialize.Bool("Enabled", p_CinematicSimulationData->m_Enabled);
+        deserialize.Bool("MapRevealed", p_CinematicSimulationData->m_MapRevealed);
+        deserialize.Bool("Paused", p_CinematicSimulationData->m_Paused);
+        size_t numberOfPaths = 0;
+        deserialize.NumberU32_Unbounded("NumberOfPaths", numberOfPaths);
+        for (size_t i = 0; i < numberOfPaths; ++i)
+        {
+            CCinemaData data;
+
+            deserialize.String("PathName", data.m_Name, 1, 2048);
+            deserialize.String("PathOrientation", data.m_Orientation, 1, 2048);
+            deserialize.String("PathMode", data.m_Mode, 1, 2048);
+            deserialize.String("PathStyle", data.m_Style, 1, 2048);
+            deserialize.NumberFixed_Unbounded("PathTimescale", data.m_Timescale);
+            deserialize.Bool("LookAtTarget", data.m_LookAtTarget);
+
+            TNSpline pathSpline, targetSpline;
+            size_t numberOfNodes = 0;
+            deserialize.NumberU32("NumberOfNodes", numberOfNodes, 1, MAX_SPLINE_NODES);
+            for (size_t j = 0; j < numberOfNodes; ++j)
+            {
+                SplineData node;
+                deserialize.NumberFixed_Unbounded("NodeDeltaTime", node.Distance);
+
+                deserialize.NumberFixed_Unbounded("PositionX", node.Position.X);
+                deserialize.NumberFixed_Unbounded("PositionY", node.Position.Y);
+                deserialize.NumberFixed_Unbounded("PositionZ", node.Position.Z);
+
+                deserialize.NumberFixed_Unbounded("RotationX", node.Rotation.X);
+                deserialize.NumberFixed_Unbounded("RotationY", node.Rotation.Y);
+                deserialize.NumberFixed_Unbounded("RotationZ", node.Rotation.Z);
+
+                pathSpline.AddNode(node.Position, node.Rotation, node.Distance);
+            }
+
+            if (data.m_LookAtTarget)
+            {
+                size_t numberOfTargetNodes = 0;
+                deserialize.NumberU32("NumberOfTargetNodes", numberOfTargetNodes, 1, MAX_SPLINE_NODES);
+                for (size_t j = 0; j < numberOfTargetNodes; ++j)
+                {
+                    SplineData node;
+                    deserialize.NumberFixed_Unbounded("NodeDeltaTime", node.Distance);
+
+                    deserialize.NumberFixed_Unbounded("PositionX", node.Position.X);
+                    deserialize.NumberFixed_Unbounded("PositionY", node.Position.Y);
+                    deserialize.NumberFixed_Unbounded("PositionZ", node.Position.Z);
+
+                    targetSpline.AddNode(node.Position, CFixedVector3D(), node.Distance);
+                }
+            }
+
+            // Construct cinema path with data gathered
+            CCinemaPath path(data, pathSpline, targetSpline);
+            p_CinematicSimulationData->m_Paths[data.m_Name] = path;
+        }
+        g_Game->GetView()->GetCinema()->SetEnabled(p_CinematicSimulationData->m_Enabled);
+    }
+
+    virtual void HandleMessage(const CMessage& msg, bool UNUSED(global))
+    {
+        switch (msg.GetType())
+        {
+        case MT_CinemaPathEnded:
+        {
+            const CMessageCinemaPathEnded& msgData = static_cast<const CMessageCinemaPathEnded&> (msg);
+            // TODO: send more msg to trigger
+            break;
+        }
+        }
+    }
+
+    virtual void AddCinemaPathToQueue(CStrW name)
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        g_Game->GetView()->GetCinema()->AddPathToQueue(name);
+    }
+
+    virtual void Play()
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        g_Game->GetView()->GetCinema()->Play();
+    }
+
+    virtual void Pause()
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        g_Game->GetView()->GetCinema()->Pause();
+    }
+
+    virtual void Stop()
+    {
+        if (!g_Game || !g_Game->GetView())
+        {
+            LOGERROR("Trying to add cinema path when GameView isn't initialized!");
+            return;
+        }
+        g_Game->GetView()->GetCinema()->Stop();
+    }
+
+};
+
+REGISTER_COMPONENT_TYPE(CinemaManager)

source/simulation2/components/CCmpOverlayRenderer.cpp

@@ -166 +166 @@
 
     void RenderSubmit(SceneCollector& collector)
     {
-        if (!m_Enabled)
+        if (!m_Enabled || !ICmpOverlayRenderer::m_OverrideVisible)
             return;
 
         for (size_t i = 0; i < m_Sprites.size(); ++i)

source/simulation2/components/CCmpSelectable.cpp

@@ -587 +587 @@
 void CCmpSelectable::RenderSubmit(SceneCollector& collector)
 {
     // don't render selection overlay if it's not gonna be visible
+    if (!ICmpSelectable::m_OverrideVisible)
+        return;
+
     if (m_Visible && m_Color.a > 0)
     {
         if (!m_Cached)

source/simulation2/components/CCmpTerritoryManager.cpp

@@ -124 +124 @@
         m_TriggerEvent = true;
         m_EnableLineDebugOverlays = false;
         m_DirtyID = 1;
+        m_Visible = true;
 
         m_AnimTime = 0.0;
 
@@ -276 +277 @@
     void Interpolate(float frameTime, float frameOffset);
 
     void RenderSubmit(SceneCollector& collector);
+
+    void SetVisibility(bool visible)
+    {
+        m_Visible = visible;
+    }
+
+private:
+
+    bool m_Visible;
 };
 
 REGISTER_COMPONENT_TYPE(TerritoryManager)
@@ -645 +655 @@
 
 void CCmpTerritoryManager::RenderSubmit(SceneCollector& collector)
 {
+    if (!m_Visible)
+        return;
+
     for (size_t i = 0; i < m_BoundaryLines.size(); ++i)
         collector.Submit(&m_BoundaryLines[i].overlay);
     

source/simulation2/components/ICmpCinemaManager.cpp

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "precompiled.h"
+
+#include "ICmpCinemaManager.h"
+
+#include "simulation2/system/InterfaceScripted.h"
+
+BEGIN_INTERFACE_WRAPPER(CinemaManager)
+DEFINE_INTERFACE_METHOD_1("AddCinemaPathToQueue", void, ICmpCinemaManager, AddCinemaPathToQueue, CStrW)
+DEFINE_INTERFACE_METHOD_0("Play", void, ICmpCinemaManager, Play)
+DEFINE_INTERFACE_METHOD_0("Pause", void, ICmpCinemaManager, Pause)
+DEFINE_INTERFACE_METHOD_0("Stop", void, ICmpCinemaManager, Stop)
+END_INTERFACE_WRAPPER(CinemaManager)

source/simulation2/components/ICmpCinemaManager.h

@@ +1 @@
+/* Copyright (C) 2015 Wildfire Games.
+ * This file is part of 0 A.D.
+ *
+ * 0 A.D. is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * 0 A.D. is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef INCLUDED_ICMPCINEMAMANAGER
+#define INCLUDED_ICMPCINEMAMANAGER
+
+#include "simulation2/system/Interface.h"
+
+#include "ps/CStr.h"
+
+/**
+ * Component for CCinemaManager class
+ * TODO: write description
+ */
+
+class ICmpCinemaManager : public IComponent
+{
+public:
+    // TODO: add path name and description
+    virtual void AddCinemaPathToQueue(CStrW name) = 0;
+    
+    virtual void Play() = 0;
+    virtual void Pause() = 0;
+    virtual void Stop() = 0;
+
+    DECLARE_INTERFACE_TYPE(CinemaManager)
+};
+
+#endif // INCLUDED_ICMPCINEMAMANAGER
+ No newline at end of file

source/simulation2/components/ICmpOverlayRenderer.cpp

@@ -25 +25 @@
 DEFINE_INTERFACE_METHOD_0("Reset", void, ICmpOverlayRenderer, Reset)
 DEFINE_INTERFACE_METHOD_5("AddSprite", void, ICmpOverlayRenderer, AddSprite, VfsPath, CFixedVector2D, CFixedVector2D, CFixedVector3D, std::string)
 END_INTERFACE_WRAPPER(OverlayRenderer)
+
+bool ICmpOverlayRenderer::m_OverrideVisible = true;
+ No newline at end of file

source/simulation2/components/ICmpOverlayRenderer.h

@@ -52 +52 @@
      */
     virtual void AddSprite(VfsPath textureName, CFixedVector2D corner0, CFixedVector2D corner1, CFixedVector3D offset, std::string color = "255 255 255 255") = 0;
 
+    /**
+    * Enables or disables rendering of all sprites.
+    * @param visible Whether the selectable should be visible.
+    */
+    static void SetOverrideVisibility(bool visible)
+    {
+        ICmpOverlayRenderer::m_OverrideVisible = visible;
+    }
+
     DECLARE_INTERFACE_TYPE(OverlayRenderer)
+
+protected:
+    static bool m_OverrideVisible;
 };
 
 #endif // INCLUDED_ICMPOVERLAYRENDERER

source/simulation2/components/ICmpSelectable.cpp

@@ -28 +28 @@
 END_INTERFACE_WRAPPER(Selectable)
 
 bool ICmpSelectable::ms_EnableDebugOverlays = false;
+bool ICmpSelectable::m_OverrideVisible = true;

source/simulation2/components/ICmpSelectable.h

@@ -67 +67 @@
     virtual void SetVisibility(bool visible) = 0;
 
     /**
+    * Enables or disables rendering of all entities selectable.
+    * @param visible Whether the selectable should be visible.
+    */
+    static void SetOverrideVisibility(bool visible)
+    {
+        ICmpSelectable::m_OverrideVisible = visible;
+    }
+
+    /**
      * Set the alpha of the selection highlight. Set to 0 to hide the highlight.
      */
     virtual void SetSelectionHighlightAlpha(float alpha) = 0;
@@ -77 +86 @@
     // and methods, where we can keep settings like these. Note that any such data store would need to be per-component-manager
     // and not entirely global, to support multiple simulation instances.
     static bool ms_EnableDebugOverlays; // ms for member static
+
+protected:
+    static bool m_OverrideVisible;
 };
 
 #endif // INCLUDED_ICMPSELECTABLE

source/simulation2/components/ICmpTerritoryManager.h

@@ -78 +78 @@
      */
      virtual u8 GetTerritoryPercentage(player_id_t player) = 0;
 
+    /**
+     * Enables or disables rendering of an territory borders.
+     */
+    virtual void SetVisibility(bool visible) = 0;
+
     DECLARE_INTERFACE_TYPE(TerritoryManager)
 };
 

source/simulation2/MessageTypes.h

@@ -29 +29 @@
 
 #include "maths/Vector3D.h"
 
+#include "ps/CStr.h"
+
 #define DEFAULT_MESSAGE_IMPL(name) \
     virtual int GetType() const { return MT_##name; } \
     virtual const char* GetScriptHandlerName() const { return "On" #name; } \
@@ -538 +540 @@
     }
 };
 
+/**
+* Send when an path has ended
+*/
+
+class CMessageCinemaPathEnded : public CMessage
+{
+public:
+    DEFAULT_MESSAGE_IMPL(CinemaPathEnded)
+
+    CMessageCinemaPathEnded(CStrW name, bool skipped) :
+    name(name), skipped(skipped)
+    {
+    }
+
+    CStrW name;
+    bool skipped;
+};
+
 #endif // INCLUDED_MESSAGETYPES

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -470 +470 @@
     return new CMessageMinimapPing();
 }
 
+////////////////////////////////
+
+JS::Value CMessageCinemaPathEnded::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(name);
+    SET_MSG_PROPERTY(skipped);
+    return JS::ObjectValue(*obj);
+}
+
+CMessage* CMessageCinemaPathEnded::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
+{
+    FROMJSVAL_SETUP();
+    GET_MSG_PROPERTY(CStrW, name);
+    GET_MSG_PROPERTY(bool, skipped);
+    return new CMessageCinemaPathEnded(name, skipped);
+}
+
 ////////////////////////////////////////////////////////////////
 
 CMessage* CMessageFromJSVal(int mtid, ScriptInterface& scriptingInterface, JS::HandleValue val)

source/simulation2/system/ComponentManager.cpp

@@ -711 +711 @@
 {
     CParamNode noParam;
     AddComponent(m_SystemEntity, CID_TemplateManager, noParam);
+    AddComponent(m_SystemEntity, CID_CinemaManager, noParam);
     AddComponent(m_SystemEntity, CID_CommandQueue, noParam);
     AddComponent(m_SystemEntity, CID_ObstructionManager, noParam);
     AddComponent(m_SystemEntity, CID_ParticleManager, noParam);

source/simulation2/TypeList.h

@@ -57 +57 @@
 MESSAGE(TemplateModification)
 MESSAGE(VisionRangeChanged)
 MESSAGE(MinimapPing)
+MESSAGE(CinemaPathEnded)
 
 // TemplateManager must come before all other (non-test) components,
 // so that it is the first to be (de)serialized
@@ -75 +76 @@
 INTERFACE(AIManager)
 COMPONENT(AIManager)
 
+INTERFACE(CinemaManager)
+COMPONENT(CinemaManager)
+
 INTERFACE(CommandQueue)
 COMPONENT(CommandQueue)
 

source/tools/atlas/GameInterface/Handlers/CameraCtrlHandlers.cpp

@@ -27 +27 @@
 #include "ps/Game.h"
 #include "renderer/Renderer.h"
 #include "graphics/GameView.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 
 #include "ps/World.h"
 #include "graphics/Terrain.h"

source/tools/atlas/GameInterface/Handlers/CinemaHandler.cpp

@@ -20 +20 @@
 #include "MessageHandler.h"
 #include "../CommandProc.h"
 #include "graphics/Camera.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/GameView.h"
 #include "ps/Game.h"
 #include "ps/CStr.h"
@@ -38 +38 @@
 {
     sCinemaPath path;
     const CCinemaData* data = source->GetData();
-    path.mode = data->m_Mode;
-    path.style = data->m_Style;
+    //path.mode = data->m_Mode;
+    //path.style = data->m_Style;
     path.growth = data->m_Growth;
-    path.timescale = data->m_Timescale;
+    path.timescale = data->m_Timescale.ToFloat();
     path.change = data->m_Switch;
 
     return path;
@@ -51 +51 @@
     CCinemaData data;
     data.m_Growth = data.m_GrowthCount = path.growth;
     data.m_Switch = path.change;
-    data.m_Mode = path.mode;
-    data.m_Style = path.style;
+    //data.m_Mode = path.mode;
+    //data.m_Style = path.style;
     
     return data;
 }
@@ -59 +59 @@
 sCinemaSplineNode ConstructCinemaNode(const SplineData& data)
 {
     sCinemaSplineNode node;
-    node.px = data.Position.X;
-    node.py = data.Position.Y;
-    node.pz = data.Position.Z;
+    node.px = data.Position.X.ToFloat();
+    node.py = data.Position.Y.ToFloat();
+    node.pz = data.Position.Z.ToFloat();
     
-    node.rx = data.Rotation.X;
-    node.ry = data.Rotation.Y;
-    node.rz = data.Rotation.Z;
-    node.t = data.Distance;
+    node.rx = data.Rotation.X.ToFloat();
+    node.ry = data.Rotation.Y.ToFloat();
+    node.rz = data.Rotation.Z.ToFloat();
+    node.t = data.Distance.ToFloat();
     
     return node;
 }
@@ -112 +112 @@
     {
         CStrW pathName(*it->name);
         paths[pathName] = CCinemaPath();
-        paths[pathName].SetTimescale(it->timescale);
+        paths[pathName].SetTimescale(fixed::FromFloat(it->timescale));
 
         const sCinemaPath& atlasPath = *it;
         const std::vector<sCinemaSplineNode> nodes = *atlasPath.nodes;
@@ -121 +121 @@
     
         for ( size_t j=0; j<nodes.size(); ++j )
         {   
-            spline.AddNode( CVector3D(nodes[j].px, nodes[j].py, nodes[j].pz), 
-                            CVector3D(nodes[j].rx, nodes[j].ry, nodes[j].rz), nodes[j].t );
+            spline.AddNode( CFixedVector3D(fixed::FromFloat(nodes[j].px), fixed::FromFloat(nodes[j].py), fixed::FromFloat(nodes[j].pz)), 
+                CFixedVector3D(fixed::FromFloat(nodes[j].rx), fixed::FromFloat(nodes[j].ry), fixed::FromFloat(nodes[j].rz)), fixed::FromFloat(nodes[j].t));
         }
-        paths[pathName] = CCinemaPath(data, spline);
+        paths[pathName] = CCinemaPath(data, spline, TNSpline());
     }
 
     g_Game->GetView()->GetCinema()->SetAllPaths(paths);
@@ -155 +155 @@
 {
     CCinemaManager* manager = g_Game->GetView()->GetCinema();
     
-    if ( msg->mode == eCinemaEventMode::SMOOTH )
-        manager->OverridePath(*msg->path);  
+    if (msg->mode == eCinemaEventMode::SMOOTH)
+    {
+        manager->ClearQueue();
+        manager->AddPathToQueue(*msg->path);
+    }
     else if ( msg->mode == eCinemaEventMode::IMMEDIATE_PATH )
         manager->MoveToPointAt(msg->t);
     else if ( msg->mode == eCinemaEventMode::RESET )
@@ -164 +167 @@
 //      g_Game->GetView()->ResetCamera();
     }
     else if ( msg->mode == eCinemaEventMode::SELECT )
-        manager->SetCurrentPath(*msg->path, msg->drawCurrent, msg->lines);
+        manager->SetCurrentPath(*msg->path, msg->drawCurrent);
     else
         ENSURE(false);
 }

source/tools/atlas/GameInterface/Handlers/MiscHandlers.cpp

@@ -22 +22 @@
 
 #include "../GameLoop.h"
 #include "../View.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/GameView.h"
 #include "gui/GUIManager.h"
 #include "gui/GUI.h"
@@ -57 +57 @@
 QUERYHANDLER(CinemaRecord)
 {
     CCinemaManager* manager = g_Game->GetView()->GetCinema();
-    manager->SetCurrentPath(*msg->path, false, false);
+    manager->SetCurrentPath(*msg->path, false);
 
     const int w = msg->width, h = msg->height;
 

source/tools/atlas/GameInterface/Handlers/TriggerHandler.cpp

@@ -23 +23 @@
 
 #include "ps/Game.h"
 #include "graphics/GameView.h"
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "simulation2/Simulation2.h"
 
 namespace AtlasMessage {

source/tools/atlas/GameInterface/View.cpp

@@ -24 +24 @@
 #include "Messages.h"
 #include "SimState.h"
 
-#include "graphics/CinemaTrack.h"
+#include "graphics/CinemaManager.h"
 #include "graphics/GameView.h"
 #include "graphics/ParticleManager.h"
 #include "graphics/SColor.h"