Ticket #3301: cinematic_camera_core_v0.6.patch

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_Active(false), m_Paused(true), m_DrawPaths(true)
+{
+}
+
+void CCinemaManager::AddPath(const CStrW& name, CCinemaPath path)
+{
+    ENSURE(m_Paths.find(name) == m_Paths.end());
+    m_Paths[name] = path;
+}
+
+void CCinemaManager::AddPathToQueue(const CStrW& name)
+{
+    ENSURE(HasPath(name));
+    m_PathQueue.push_back(m_Paths[name]);
+}
+
+void CCinemaManager::ClearQueue()
+{
+    m_PathQueue.clear();
+}
+
+void CCinemaManager::SetAllPaths(const std::map<CStrW, CCinemaPath>& paths)
+{
+    m_Paths = paths;
+}
+
+void CCinemaManager::SetCurrentPath(const CStrW& name, bool current)
+{
+    // ...
+}
+
+bool CCinemaManager::HasPath(const CStrW& name) const
+{
+    return m_Paths.find(name) != m_Paths.end();
+}
+
+void CCinemaManager::SetActive(bool active)
+{
+    if (m_Active == active)
+        return;
+
+    IGUIObject *sn = g_GUI->FindObjectByName("sn");
+    CmpPtr <ICmpRangeManager> cmpRangeManager(*(g_Game->GetSimulation2()), SYSTEM_ENTITY);
+    CmpPtr <ICmpTerritoryManager> cmpTerritoryManager(*(g_Game->GetSimulation2()), SYSTEM_ENTITY);
+
+    // GUI visibility
+    if (sn)
+    {
+        if (active)
+            sn->SetSetting("hidden", L"true");
+        else
+            sn->SetSetting("hidden", L"false");
+    }
+
+    // Overlay visibility
+    g_Renderer.SetOptionBool(CRenderer::Option::OPT_SILHOUETTES, !active);
+    if (cmpRangeManager)
+    {
+        if (active)
+            m_MapRevealed = cmpRangeManager->GetLosRevealAll(-1);
+        // TODO: improve m_MapRevealed state and without fade in
+        cmpRangeManager->SetLosRevealAll(-1, active);
+    }
+    if (cmpTerritoryManager)
+        cmpTerritoryManager->SetVisibility(!active);
+    ICmpSelectable::SetOverrideVisibility(!active);
+    ICmpOverlayRenderer::SetOverrideVisibility(!active);
+
+    m_Active = active;
+}
+
+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()
+{
+    SetActive(true);
+    m_Paused = false;
+}
+
+void CCinemaManager::Pause()
+{
+    m_Paused = true;
+}
+
+void CCinemaManager::Stop()
+{
+    m_Paused = true;
+}
+
+void CCinemaManager::Skip()
+{
+    m_PathQueue.clear();
+    SetActive(false);
+    m_Paused = true;
+}
+
+void CCinemaManager::Next()
+{
+    CMessageCinemaPathEnded msg(m_PathQueue.back().GetName());
+    g_Game->GetSimulation2()->PostMessage(SYSTEM_ENTITY, msg);
+
+    m_PathQueue.pop_front();
+    if (m_PathQueue.empty())
+    {
+        SetActive(false);
+        m_Paused = true;
+    }
+}
+
+void CCinemaManager::Update(const float deltaRealTime)
+{
+    if (!m_Active || m_Paused)
+        return;
+
+    if (HotkeyIsPressed("leave"))
+    {
+        Skip();
+        return;
+    }
+
+    if (m_PathQueue.front().Play(deltaRealTime))
+        return;
+
+    Next();
+    return;
+}
+
+void CCinemaManager::Render()
+{
+    if (IsActive())
+    {
+        DrawBars();
+        return;
+    }
+    
+    if (!m_DrawPaths)
+        return;
+
+    for (auto it : m_Paths)
+    {
+        it.second.DrawSpline(CVector4D(0.2f, 0.2f, 1.f, 0.5f), 100, true);
+        it.second.DrawNodes(CVector4D(0.5f, 1.0f, 0.f, 0.5f));
+    }
+}
+
+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
+}

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 "graphics/CinemaPath.h"
+#include "ps/CStr.h"
+
+/*
+    desc: contains various functions used for cinematic camera paths
+    See also: CinemaHandler.cpp, CinemaPath.cpp
+*/
+
+/**
+ * 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
+    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);
+
+    /**
+     * Starts play paths
+     */
+    void Play();
+    void Pause();
+    void Next();
+    void Stop();
+    void Skip();
+    inline bool IsPlaying() const { return !m_Paused; }
+
+    /**
+     * Renders black bars and paths (if enabled)
+     */
+    void Render();
+    void DrawBars() const;
+
+    /**
+     * Sets active state of the cinema manager (shows/hide gui, show/hide rings, etc)
+     * @active new active state
+     */
+    void SetActive(bool active);
+    inline bool IsActive() const { return m_Active; }
+
+    /**
+     * Updates CCinemManager and current path
+     * @param deltaRealTime Elapsed real time since the last frame.
+     */
+    void Update(const float deltaRealTime);
+
+private:    
+    bool m_Active, m_Paused, m_DrawPaths;
+
+    std::map<CStrW, CCinemaPath> m_Paths;
+    std::list<CCinemaPath> m_PathQueue;
+
+    // States before playing
+    bool m_MapRevealed;
+};
+
+#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 "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 <sstream>
+#include <string>
+#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
+    {
+        debug_printf("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
+    {
+        debug_printf("Cinematic style not found for '%s'\n", data.m_Style.ToUTF8().c_str());
+        DistStylePtr = &CCinemaPath::EaseDefault;
+    }
+
+    //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::DrawNodes(const CVector4D& RGBA) const
+{
+#if CONFIG2_GLES
+    #warning TODO : do something about CCinemaPath on GLES
+#else
+    glColor4f(RGBA.X, RGBA.Y, RGBA.Z, RGBA.W);
+    glEnable(GL_POINT_SMOOTH);
+    glPointSize(5.0f);
+    glBegin(GL_POINTS);
+    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 pos = GetPosition(t);
+    
+    if (m_LookAtTarget)
+    {
+        if (m_TimeElapsed <= m_TargetSpline.MaxDistance)
+            Cam->LookAt(pos, m_TargetSpline.GetPosition(m_TimeElapsed / m_TargetSpline.MaxDistance), CVector3D(0, 1, 0));
+        else
+            Cam->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);
+
+        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;
+}

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(1) {}
+    virtual ~CCinemaData() {}
+
+    const CCinemaData* GetData() const { return this; }
+
+    CStrW m_Name;
+    CStrW m_Orientation;
+    bool m_LookAtTarget;
+
+    // Distortion variables
+    mutable float m_GrowthCount;
+    float m_Growth;
+    float m_Switch;
+    CStrW m_Mode;
+    CStrW 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), 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 DrawSpline(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 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; }
+
+    CStrW GetName() const { return m_Name; }
+
+    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);
+
+    /**
+     * 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(); }
+
+    inline float GetTimescale() const { return m_Timescale; }
+
+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.IsActive())
     {
-        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"
@@ -55 +55 @@
 CMapReader::CMapReader()
     : xml_reader(0), m_PatchesPerSide(0), m_MapGen(0)
 {
-    cur_terrain_tex = 0;    // important - resets generator state
+    cur_terrain_tex = 0;    // important - resets generator state
 
     // Maps that don't override the default probably want the old lighting model
     //m_LightEnv.SetLightingModel("old");
@@ -215 +215 @@
 {
     // now unpack everything into local data
     int ret = UnpackTerrain();
-    if (ret != 0)   // failed or timed out
+    if (ret != 0)   // failed or timed out
     {
         return ret;
     }
@@ -224 +224 @@
 }
 
 // UnpackTerrain: unpack the terrain from the end of the input data stream
-//      - data: map size, heightmap, list of textures used by map, texture tile assignments
+//      - data: map size, heightmap, list of textures used by map, texture tile assignments
 int CMapReader::UnpackTerrain()
 {
     // yield after this time is reached. balances increased progress bar
@@ -292 +292 @@
             for (ssize_t i=0; i<m_PatchesPerSide; i++) {
                 for (ssize_t m=0; m<PATCH_SIZE; m++) {
                     for (ssize_t k=0; k<PATCH_SIZE; k++) {
-                        CMiniPatch& mp = pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];  // can't fail
+                        CMiniPatch& mp = pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];  // can't fail
 
                         mp.Tex = m_TerrainTextures[tileptr->m_Tex1Index];
                         mp.Priority = tileptr->m_Priority;
@@ -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);
 };
@@ -573 +573 @@
     {
         for (ssize_t px = 0; px < patches; ++px)
         {
-            CPatch* patch = m_MapReader.pTerrain->GetPatch(px, pz); // can't fail
+            CPatch* patch = m_MapReader.pTerrain->GetPatch(px, pz); // can't fail
 
             for (ssize_t z = 0; z < PATCH_SIZE; ++z)
             {
@@ -605 +605 @@
     EL(color);
     EL(tint);
     EL(height);
-    EL(shininess);  // for compatibility
+    EL(shininess);  // for compatibility
     EL(waviness);
     EL(murkiness);
     EL(windangle);
-    EL(reflectiontint); // for compatibility
-    EL(reflectiontintstrength); // for compatibility
+    EL(reflectiontint); // for compatibility
+    EL(reflectiontintstrength); // for compatibility
     EL(fog);
     EL(fogcolor);
     EL(fogfactor);
@@ -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 = attrs.GetNamedItem(at_timescale).ToFloat();
+            TNSpline pathSpline, targetSpline;
+            float lastTargetTime = 0;
+            
+            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)
                 {
                     SplineData data;
+                    data.Distance = pathChild.GetAttributes().GetNamedItem(at_deltatime).ToFloat();
+                    lastTargetTime += 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;
                         }
-                        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;
                         }
-                        else if ( elementName == el_time )
-                            data.Distance = nodeChild.GetText().ToFloat();
+                        else if (elementName == el_target)
+                        {
+                            CVector3D targetPosition;
+                            targetPosition.X = attrs.GetNamedItem(at_x).ToFloat();
+                            targetPosition.Y = attrs.GetNamedItem(at_y).ToFloat();
+                            targetPosition.Z = attrs.GetNamedItem(at_z).ToFloat();
+
+                            targetSpline.AddNode(targetPosition, CVector3D(), lastTargetTime);
+                            lastTargetTime = 0;
+                        }
                         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");
                     }
+                    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))
@@ -1048 +1039 @@
         entity_id_t ent = sim.AddEntity(TemplateName, EntityUid);
         entity_id_t player = cmpPlayerManager->GetPlayerByID(PlayerID);
         if (ent == INVALID_ENTITY || player == INVALID_ENTITY)
-        {   // Don't add entities with invalid player IDs
+        {   // Don't add entities with invalid player IDs
             LOGERROR("Failed to load entity template '%s'", utf8_from_wstring(TemplateName));
         }
         else
@@ -1125 +1116 @@
         }
         else if (name == "Paths")
         {
-            ReadCinema(node);
+            ReadPaths(node);
         }
         else if (name == "Triggers")
         {
@@ -1161 +1152 @@
             if (!m_MapReader.m_SkipEntities)
             {
                 ret = ReadEntities(node, end_time);
-                if (ret != 0)   // error or timed out
+                if (ret != 0)   // error or timed out
                     return ret;
             }
         }
@@ -1323 +1314 @@
     JSAutoRequest rq(cx);
     
     // parse terrain from map data
-    //  an error here should stop the loading process
+    //  an error here should stop the loading process
 #define GET_TERRAIN_PROPERTY(val, prop, out)\
     if (!pSimulation2->GetScriptInterface().GetProperty(val, #prop, out))\
-        {   LOGERROR("CMapReader::ParseTerrain() failed to get '%s' property", #prop);\
+        {   LOGERROR("CMapReader::ParseTerrain() failed to get '%s' property", #prop);\
             throw PSERROR_Game_World_MapLoadFailed("Error parsing terrain data.\nCheck application log for details"); }
 
     u32 size;
@@ -1420 +1411 @@
         entity_id_t ent = pSimulation2->AddEntity(currEnt.templateName, currEnt.entityID);
         entity_id_t player = cmpPlayerManager->GetPlayerByID(currEnt.playerID);
         if (ent == INVALID_ENTITY || player == INVALID_ENTITY)
-        {   // Don't add entities with invalid player IDs
+        {   // Don't add entities with invalid player IDs
             LOGERROR("Failed to load entity template '%s'", utf8_from_wstring(currEnt.templateName));
         }
         else
@@ -1576 +1567 @@
     GET_CAMERA_PROPERTY(m_MapData.get(), Camera, &cameraObj)
 
     if (!cameraObj.isUndefined())
-    {   // If camera property exists, read values
+    {   // If camera property exists, read values
         CFixedVector3D pos;
         GET_CAMERA_PROPERTY(cameraObj, Position, pos)
         translation = pos;

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"
@@ -84 +84 @@
 // handle isn't in list
 static u16 GetEntryIndex(const CTerrainTextureEntry* entry, const std::vector<CTerrainTextureEntry*>& entries)
 {
-    const size_t limit = std::min(entries.size(), size_t(0xFFFEu)); // paranoia
+    const size_t limit = std::min(entries.size(), size_t(0xFFFEu)); // paranoia
     for (size_t i=0;i<limit;i++) {
         if (entries[i]==entry) {
             return (u16)i;
@@ -114 +114 @@
         for (ssize_t i=0;i<patchesPerSide;i++) {
             for (ssize_t m=0;m<PATCH_SIZE;m++) {
                 for (ssize_t k=0;k<PATCH_SIZE;k++) {
-                    CMiniPatch& mp=pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];    // can't fail
+                    CMiniPatch& mp=pTerrain->GetPatch(i,j)->m_MiniPatches[m][k];    // can't fail
                     u16 index=u16(GetEntryIndex(mp.GetTextureEntry(),entries));
                     if (index==0xFFFF) {
                         index=(u16)entries.size();
@@ -154 +154 @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 // PackTerrain: pack the terrain onto the end of the output data stream
-//      - data: map size, heightmap, list of textures used by map, texture tile assignments
+//      - data: map size, heightmap, list of textures used by map, texture tile assignments
 void CMapWriter::PackTerrain(CFilePacker& packer, CTerrain* pTerrain)
 {
     // pack map size
@@ -162 +162 @@
     packer.PackSize(mapsize);
     
     // pack heightmap
-    packer.PackRaw(pTerrain->GetHeightMap(),sizeof(u16)*SQR(pTerrain->GetVerticesPerSide()));   
+    packer.PackRaw(pTerrain->GetHeightMap(),sizeof(u16)*SQR(pTerrain->GetVerticesPerSide()));   
 
     // the list of textures used by map
     std::vector<CStr> terrainTextures;
@@ -408 +408 @@
 
             for ( ; it != paths.end(); ++it )
             {
-                CStrW name = it->first;
                 float 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();
-                
+                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 +440 @@
                         XML_Attribute("y", nodes[j].Rotation.Y);
                         XML_Attribute("z", nodes[j].Rotation.Z);
                     }
-
-                    XML_Setting("Time", nodes[j].Distance);
                 }
             }
         }

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
@@ -48 +48 @@
 // adds node and updates segment length
 void RNSpline::AddNode(const CVector3D &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;
+    }
+    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 > 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 < 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);
 }
 
 // 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 = (Node[index + 1].Position - Node[index].Position) * 3.0f * (1.0f / Node[index].Distance);
+    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 = (Node[index].Position - Node[index - 1].Position) * 3.0f * (1.0f / Node[index - 1].Distance);
+    return (temp - Node[index - 1].Velocity) * 0.5f;
 }
 
 /*********************************** S N S **************************************************/
@@ -142 +142 @@
 // 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 +
+            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;
 }
 
 /*********************************** T N S **************************************************/
@@ -165 +165 @@
 // ie time period is time from last node to this node
 void TNSpline::AddNode(const CVector3D &pos, const CVector3D& rotation, float 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;
+    }
 
-  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 = 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)
 {
-  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;
+    }
+    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;
+        MaxDistance -= Node[index - 1].Distance;
+        Node[index - 1].Distance = 0.0f;
+        Node.erase(Node.begin() + index, Node.begin() + index + 1);
+    }
+    NodeCount--;
 }
 void TNSpline::UpdateNodeTime(const int index, float time)
 { 
@@ -238 +238 @@
 }
 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() / 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));
+    }
 }
 

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 "Vector3D.h"

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)

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& UNUSED(serialize))
+    {
+        // ...
+    }
+
+    virtual void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& UNUSED(deserialize))
+    {
+        // ...
+    }
+
+    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)
+ No newline at end of file

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) :
+    m_PathName(name)
+    {
+    }
+
+    CStrW m_PathName;
+};
+
 #endif // INCLUDED_MESSAGETYPES

source/simulation2/scripting/MessageTypeConversions.cpp

@@ -470 +470 @@
     return new CMessageMinimapPing();
 }
 
+////////////////////////////////
+
+jsval CMessageCinemaPathEnded::ToJSVal(ScriptInterface& scriptInterface) const
+{
+    TOJSVAL_SETUP();
+    SET_MSG_PROPERTY(m_PathName);
+    return OBJECT_TO_JSVAL(obj);
+}
+
+CMessage* CMessageCinemaPathEnded::FromJSVal(ScriptInterface& scriptInterface, JS::HandleValue val)
+{
+    FROMJSVAL_SETUP();
+    GET_MSG_PROPERTY(CStrW, name);
+    return new CMessageCinemaPathEnded(name);
+}
+
 ////////////////////////////////////////////////////////////////
 
 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.change = data->m_Switch;
@@ -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;
 }
@@ -124 +124 @@
             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 );
         }
-        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"