Ticket #3814: cinematic_camera_cleanup_3.patch

source/graphics/CinemaManager.cpp

@@ -171 +171 @@
     {
         // TODO: implement skip
     }
-    
-    m_CinematicSimulationData.m_PathQueue.front().Play(deltaRealTime);
+
+    CCamera *camera = g_Game->GetView()->GetCamera();
+    m_CinematicSimulationData.m_PathQueue.front().Play(deltaRealTime, camera);
 }
 
 void CCinemaManager::Render()

source/graphics/CinemaPath.cpp

@@ -217 +217 @@
     m_Timescale = scale;
 }
 
-void CCinemaPath::MoveToPointAt(float t, float nodet, const CVector3D& startRotation)
+void CCinemaPath::MoveToPointAt(float t, float nodet, const CVector3D& startRotation, CCamera* camera)
 {
-    CCamera *camera = g_Game->GetView()->GetCamera();
     t = (this->*DistModePtr)(t);
 
     CVector3D pos = GetPosition(t);
@@ -341 +340 @@
     return false;
 }
 
-bool CCinemaPath::Play(const float deltaRealTime)
+bool CCinemaPath::Play(const float deltaRealTime, CCamera* camera)
 {
     m_TimeElapsed += m_Timescale.ToFloat() * deltaRealTime;
     if (!Validate())
         return false;
 
-    MoveToPointAt(m_TimeElapsed / GetDuration().ToFloat(), GetNodeFraction(), m_PreviousRotation);
+    MoveToPointAt(m_TimeElapsed / GetDuration().ToFloat(), GetNodeFraction(), m_PreviousRotation, camera);
     return true;
 }
 

source/graphics/CinemaPath.h

@@ -61 +61 @@
     CCinemaPath(const CCinemaData& data, const TNSpline& spline, const TNSpline& targetSpline);
 
     // Sets camera position to calculated point on spline
-    void MoveToPointAt(float t, float nodet, const CVector3D&);
+    void MoveToPointAt(float t, float nodet, const CVector3D& startRotation, CCamera* camera);
 
     // Distortion mode functions-change how ratio is passed to distortion style functions
     float EaseIn(float t) const;
@@ -109 +109 @@
     /**
      * Returns false if finished.
      * @param deltaRealTime Elapsed real time since the last frame.
+     * @param camera An affected camera
      */
-    bool Play(const float deltaRealTime);
+    bool Play(const float deltaRealTime, CCamera* camera);
 
     /**
      * Validate the path

source/graphics/MapReader.cpp

@@ -871 +871 @@
             CCinemaData pathData;
             XMBAttributeList attrs = element.GetAttributes();
             CStrW pathName(attrs.GetNamedItem(at_name).FromUTF8());
+            pathData.m_Name = pathName;
             pathData.m_Timescale = fixed::FromString(attrs.GetNamedItem(at_timescale));
-            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();
 
+            TNSpline positionSpline, targetSpline;
+            fixed lastPositionTime = fixed::Zero();
+            fixed lastTargetTime = fixed::Zero();
+
             XERO_ITER_EL(element, pathChild)
             {
                 elementName = pathChild.GetNodeName();
@@ -888 +889 @@
                 // Load node data used for spline
                 if (elementName == el_node)
                 {
-                    bool positionDeclared = false;
-                    SplineData data;
-                    data.Distance = fixed::FromString(attrs.GetNamedItem(at_deltatime));
+                    lastPositionTime += fixed::FromString(attrs.GetNamedItem(at_deltatime));
                     lastTargetTime += fixed::FromString(attrs.GetNamedItem(at_deltatime));
                     XERO_ITER_EL(pathChild, nodeChild)
                     {
@@ -899 +898 @@
 
                         if (elementName == el_position)
                         {
-                            data.Position.X = fixed::FromString(attrs.GetNamedItem(at_x));
-                            data.Position.Y = fixed::FromString(attrs.GetNamedItem(at_y));
-                            data.Position.Z = fixed::FromString(attrs.GetNamedItem(at_z));
-                            positionDeclared = true;
+                            CFixedVector3D position;
+                            position.X = fixed::FromString(attrs.GetNamedItem(at_x));
+                            position.Y = fixed::FromString(attrs.GetNamedItem(at_y));
+                            position.Z = fixed::FromString(attrs.GetNamedItem(at_z));
+
+                            positionSpline.AddNode(position, CFixedVector3D(), lastPositionTime);
+                            lastPositionTime = fixed::Zero();
                         }
                         else if (elementName == el_rotation)
                         {
-                            data.Rotation.X = fixed::FromString(attrs.GetNamedItem(at_x));
-                            data.Rotation.Y = fixed::FromString(attrs.GetNamedItem(at_y));
-                            data.Rotation.Z = fixed::FromString(attrs.GetNamedItem(at_z));
+                            // TODO: Implement rotation slerp/spline as another object
                         }
                         else if (elementName == el_target)
                         {
@@ -923 +923 @@
                         else
                             LOGWARNING("Invalid cinematic element for node child");
                     }
-
-                    // Skip the node if no position
-                    if (positionDeclared)
-                        pathSpline.AddNode(data.Position, data.Rotation, data.Distance);
                 }
                 else
                     LOGWARNING("Invalid cinematic element for path child");
@@ -933 +929 @@
             }
 
             // Construct cinema path with data gathered
-            CCinemaPath path(pathData, pathSpline, targetSpline);
+            CCinemaPath path(pathData, positionSpline, targetSpline);
             if (path.Empty())
             {
                 LOGWARNING("Path with name '%s' is empty", pathName.ToUTF8());

source/graphics/MapWriter.cpp

@@ -409 +409 @@
             for ( ; it != paths.end(); ++it )
             {
                 fixed timescale = it->second.GetTimescale();
-                const std::vector<SplineData>& nodes = it->second.GetAllNodes();
+                const std::vector<SplineData>& position_nodes = it->second.GetAllNodes();
                 const std::vector<SplineData>& target_nodes = it->second.GetTargetSpline().GetAllNodes();
                 const CCinemaData* data = it->second.GetData();
                 
@@ -420 +420 @@
                 XML_Attribute("mode", data->m_Mode);
                 XML_Attribute("style", data->m_Style);
 
-                fixed last_target = fixed::Zero();
-                for (size_t i = 0, j = 0; i < nodes.size(); ++i)
+                struct SEvent
                 {
-                    XML_Element("Node");
-                    fixed distance = i > 0 ? nodes[i - 1].Distance : fixed::Zero();
-                    last_target += distance;
-
-                    XML_Attribute("deltatime", distance);
-
+                    fixed time;
+                    const char* type;
+                    CFixedVector3D value;
+                    SEvent(fixed time, const char* type, CFixedVector3D value)
+                        : time(time), type(type), value(value)
+                    {}
+                    bool operator<(const SEvent& another)
                     {
-                        XML_Element("Position");
-                        XML_Attribute("x", nodes[i].Position.X);
-                        XML_Attribute("y", nodes[i].Position.Y);
-                        XML_Attribute("z", nodes[i].Position.Z);
+                        return time < another.time;
                     }
+                };
 
-                    {
-                        XML_Element("Rotation");
-                        XML_Attribute("x", nodes[i].Rotation.X);
-                        XML_Attribute("y", nodes[i].Rotation.Y);
-                        XML_Attribute("z", nodes[i].Rotation.Z);
-                    }
+                // All events of a manipulating of camera (position/rotation/target)
+                std::vector<SEvent> events;
 
-                    if (j >= target_nodes.size())
-                        continue;
+                fixed last_position = fixed::Zero();
+                for (size_t i = 0; i < position_nodes.size(); ++i)
+                {
+                    fixed distance = i > 0 ? position_nodes[i - 1].Distance : fixed::Zero();
+                    last_position += distance;
+                    events.emplace_back(last_position, "Position", position_nodes[i].Position);
+                }
 
-                    fixed target_distance = j > 0 ? target_nodes[j - 1].Distance : fixed::Zero();
+                fixed last_target = fixed::Zero();
+                for (size_t i = 0; i < target_nodes.size(); ++i)
+                {
+                    fixed distance = i > 0 ? target_nodes[i - 1].Distance : fixed::Zero();
+                    last_target += distance;
+                    events.emplace_back(last_target, "Target", target_nodes[i].Position);
+                }
 
-                    if (target_distance > last_target)
-                        continue;
-
+                std::sort(events.begin(), events.end());
+                for (size_t i = 0; i < events.size();)
+                {
+                    XML_Element("Node");
+                    fixed deltatime = i > 0 ? (events[i].time - events[i - 1].time) : fixed::Zero();
+                    XML_Attribute("deltatime", deltatime);
+                    size_t j = i;
+                    for (; j < events.size() && events[j].time == events[i].time; ++j)
                     {
-                        XML_Element("Target");
-                        XML_Attribute("x", target_nodes[j].Position.X);
-                        XML_Attribute("y", target_nodes[j].Position.Y);
-                        XML_Attribute("z", target_nodes[j].Position.Z);
+                        // Types: Position/Rotation/Target
+                        XML_Element(events[j].type);
+                        XML_Attribute("x", events[j].value.X);
+                        XML_Attribute("y", events[j].value.Y);
+                        XML_Attribute("z", events[j].value.Z);
                     }
-
-                    last_target = fixed::Zero();
-                    ++j;
+                    i = j;
                 }
             }
         }