Changeset View
Changeset View
Standalone View
Standalone View
source/simulation2/components/CCmpCinemaManager.cpp
Show All 11 Lines | |||||
* GNU General Public License for more details. | * GNU General Public License for more details. | ||||
* | * | ||||
* You should have received a copy of the GNU General Public License | * 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/>. | * along with 0 A.D. If not, see <http://www.gnu.org/licenses/>. | ||||
*/ | */ | ||||
#include "precompiled.h" | #include "precompiled.h" | ||||
#include "CCmpCinemaManager.h" | |||||
#include "simulation2/system/Component.h" | #include "simulation2/system/Component.h" | ||||
#include "ICmpCinemaManager.h" | |||||
#include "ps/CLogger.h" | #include "ps/CLogger.h" | ||||
#include "simulation2/components/ICmpOverlayRenderer.h" | #include "simulation2/components/ICmpOverlayRenderer.h" | ||||
#include "simulation2/components/ICmpRangeManager.h" | #include "simulation2/components/ICmpRangeManager.h" | ||||
#include "simulation2/components/ICmpSelectable.h" | #include "simulation2/components/ICmpSelectable.h" | ||||
#include "simulation2/components/ICmpTerritoryManager.h" | #include "simulation2/components/ICmpTerritoryManager.h" | ||||
#include "simulation2/MessageTypes.h" | #include "simulation2/MessageTypes.h" | ||||
#include "simulation2/Simulation2.h" | #include "simulation2/Simulation2.h" | ||||
class CCmpCinemaManager final : public ICmpCinemaManager | |||||
{ | void CCmpCinemaManager::ClassInit(CComponentManager& componentManager) | ||||
public: | |||||
static void ClassInit(CComponentManager& componentManager) | |||||
{ | { | ||||
componentManager.SubscribeToMessageType(MT_Update); | componentManager.SubscribeToMessageType(MT_Update); | ||||
} | } | ||||
DEFAULT_COMPONENT_ALLOCATOR(CinemaManager) | IComponent* CCmpCinemaManager::Allocate(const ScriptInterface&, JS::HandleValue) | ||||
{ | |||||
return nullptr; | |||||
} | |||||
void CCmpCinemaManager::Deallocate(IComponent*) | |||||
{} | |||||
static std::string GetSchema() | int CCmpCinemaManager::GetComponentTypeId() const | ||||
{ | |||||
return CID_CinemaManager; | |||||
} | |||||
std::string CCmpCinemaManager::GetSchema() | |||||
{ | { | ||||
return "<a:component type='system'/><empty/>"; | return "<a:component type='system'/><empty/>"; | ||||
} | } | ||||
void Init(const CParamNode& UNUSED(paramNode)) override | void CCmpCinemaManager::Init(const CParamNode& UNUSED(paramNode)) | ||||
{ | { | ||||
m_Enabled = false; | m_Enabled = false; | ||||
m_MapRevealed = false; | m_MapRevealed = false; | ||||
m_ElapsedTime = fixed::Zero(); | m_ElapsedTime = fixed::Zero(); | ||||
m_TotalTime = fixed::Zero(); | m_TotalTime = fixed::Zero(); | ||||
m_CurrentPathElapsedTime = fixed::Zero(); | m_CurrentPathElapsedTime = fixed::Zero(); | ||||
} | } | ||||
void Deinit() override | void CCmpCinemaManager::Deinit() | ||||
{ | {} | ||||
} | |||||
void Serialize(ISerializer& serializer) override | void CCmpCinemaManager::Serialize(ISerializer& serializer) | ||||
{ | { | ||||
serializer.Bool("Enabled", m_Enabled); | serializer.Bool("Enabled", m_Enabled); | ||||
serializer.NumberFixed_Unbounded("ElapsedTime", m_ElapsedTime); | serializer.NumberFixed_Unbounded("ElapsedTime", m_ElapsedTime); | ||||
serializer.NumberFixed_Unbounded("CurrentPathElapsedTime", m_CurrentPathElapsedTime); | serializer.NumberFixed_Unbounded("CurrentPathElapsedTime", m_CurrentPathElapsedTime); | ||||
serializer.Bool("MapRevealed", m_MapRevealed); | serializer.Bool("MapRevealed", m_MapRevealed); | ||||
serializer.NumberU32_Unbounded("NumberOfPaths", m_Paths.size()); | serializer.NumberU32_Unbounded("NumberOfPaths", m_Paths.size()); | ||||
for (const std::pair<const CStrW, CCinemaPath>& it : m_Paths) | for (const std::pair<const CStrW, CCinemaPath>& it : m_Paths) | ||||
SerializePath(it.second, serializer); | SerializePath(it.second, serializer); | ||||
serializer.NumberU32_Unbounded("NumberOfQueuedPaths", m_PathQueue.size()); | serializer.NumberU32_Unbounded("NumberOfQueuedPaths", m_PathQueue.size()); | ||||
for (const CCinemaPath& path : m_PathQueue) | for (const CCinemaPath& path : m_PathQueue) | ||||
serializer.String("PathName", path.GetName(), 1, 128); | serializer.String("PathName", path.GetName(), 1, 128); | ||||
} | } | ||||
void Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserializer) override | void CCmpCinemaManager::Deserialize(const CParamNode& UNUSED(paramNode), IDeserializer& deserializer) | ||||
{ | { | ||||
deserializer.Bool("Enabled", m_Enabled); | deserializer.Bool("Enabled", m_Enabled); | ||||
deserializer.NumberFixed_Unbounded("ElapsedTime", m_ElapsedTime); | deserializer.NumberFixed_Unbounded("ElapsedTime", m_ElapsedTime); | ||||
deserializer.NumberFixed_Unbounded("CurrentPathElapsedTime", m_CurrentPathElapsedTime); | deserializer.NumberFixed_Unbounded("CurrentPathElapsedTime", m_CurrentPathElapsedTime); | ||||
deserializer.Bool("MapRevealed", m_MapRevealed); | deserializer.Bool("MapRevealed", m_MapRevealed); | ||||
uint32_t numberOfPaths = 0; | uint32_t numberOfPaths = 0; | ||||
deserializer.NumberU32_Unbounded("NumberOfPaths", numberOfPaths); | deserializer.NumberU32_Unbounded("NumberOfPaths", numberOfPaths); | ||||
for (uint32_t i = 0; i < numberOfPaths; ++i) | for (uint32_t i = 0; i < numberOfPaths; ++i) | ||||
{ | { | ||||
CCinemaPath path = DeserializePath(deserializer); | CCinemaPath path = DeserializePath(deserializer); | ||||
m_Paths[path.GetName()] = path; | m_Paths[path.GetName()] = path; | ||||
} | } | ||||
uint32_t numberOfQueuedPaths = 0; | uint32_t numberOfQueuedPaths = 0; | ||||
deserializer.NumberU32_Unbounded("NumberOfQueuedPaths", numberOfQueuedPaths); | deserializer.NumberU32_Unbounded("NumberOfQueuedPaths", numberOfQueuedPaths); | ||||
for (uint32_t i = 0; i < numberOfQueuedPaths; ++i) | for (uint32_t i = 0; i < numberOfQueuedPaths; ++i) | ||||
{ | { | ||||
CStrW pathName; | CStrW pathName; | ||||
deserializer.String("PathName", pathName, 1, 128); | deserializer.String("PathName", pathName, 1, 128); | ||||
ENSURE(HasPath(pathName)); | ENSURE(HasPath(pathName)); | ||||
AddCinemaPathToQueue(pathName); | AddCinemaPathToQueue(pathName); | ||||
} | } | ||||
if (!m_PathQueue.empty()) | if (!m_PathQueue.empty()) | ||||
{ | { | ||||
m_PathQueue.front().m_TimeElapsed = m_CurrentPathElapsedTime.ToFloat(); | m_PathQueue.front().m_TimeElapsed = m_CurrentPathElapsedTime.ToFloat(); | ||||
m_PathQueue.front().Validate(); | m_PathQueue.front().Validate(); | ||||
} | } | ||||
SetEnabled(m_Enabled); | SetEnabled(m_Enabled); | ||||
} | } | ||||
void HandleMessage(const CMessage& msg, bool UNUSED(global)) override | void CCmpCinemaManager::HandleMessage(const CMessage& msg, bool UNUSED(global)) | ||||
{ | { | ||||
switch (msg.GetType()) | switch (msg.GetType()) | ||||
{ | { | ||||
case MT_Update: | case MT_Update: | ||||
{ | { | ||||
const CMessageUpdate &msgData = static_cast<const CMessageUpdate&>(msg); | const CMessageUpdate &msgData = static_cast<const CMessageUpdate&>(msg); | ||||
if (!m_Enabled) | if (!m_Enabled) | ||||
break; | break; | ||||
m_ElapsedTime += msgData.turnLength; | m_ElapsedTime += msgData.turnLength; | ||||
m_CurrentPathElapsedTime += msgData.turnLength; | m_CurrentPathElapsedTime += msgData.turnLength; | ||||
if (m_CurrentPathElapsedTime >= m_PathQueue.front().GetDuration()) | if (m_CurrentPathElapsedTime >= m_PathQueue.front().GetDuration()) | ||||
{ | { | ||||
CMessageCinemaPathEnded msgCinemaPathEnded(m_PathQueue.front().GetName()); | CMessageCinemaPathEnded msgCinemaPathEnded(m_PathQueue.front().GetName()); | ||||
m_PathQueue.pop_front(); | m_PathQueue.pop_front(); | ||||
GetSimContext().GetComponentManager().PostMessage(SYSTEM_ENTITY, msgCinemaPathEnded); | GetSimContext().GetComponentManager().PostMessage(SYSTEM_ENTITY, msgCinemaPathEnded); | ||||
m_CurrentPathElapsedTime = fixed::Zero(); | m_CurrentPathElapsedTime = fixed::Zero(); | ||||
if (!m_PathQueue.empty()) | if (!m_PathQueue.empty()) | ||||
m_PathQueue.front().Reset(); | m_PathQueue.front().Reset(); | ||||
} | } | ||||
if (m_ElapsedTime >= m_TotalTime) | if (m_ElapsedTime >= m_TotalTime) | ||||
{ | { | ||||
m_CurrentPathElapsedTime = fixed::Zero(); | m_CurrentPathElapsedTime = fixed::Zero(); | ||||
m_ElapsedTime = fixed::Zero(); | m_ElapsedTime = fixed::Zero(); | ||||
m_TotalTime = fixed::Zero(); | m_TotalTime = fixed::Zero(); | ||||
SetEnabled(false); | SetEnabled(false); | ||||
GetSimContext().GetComponentManager().PostMessage(SYSTEM_ENTITY, CMessageCinemaQueueEnded()); | GetSimContext().GetComponentManager().PostMessage(SYSTEM_ENTITY, CMessageCinemaQueueEnded()); | ||||
} | } | ||||
break; | break; | ||||
} | } | ||||
default: | default: | ||||
break; | break; | ||||
} | } | ||||
} | } | ||||
void AddPath(const CCinemaPath& path) override | void CCmpCinemaManager::AddPath(const CCinemaPath& path) | ||||
{ | { | ||||
if (m_Paths.find(path.GetName()) != m_Paths.end()) | if (m_Paths.find(path.GetName()) != m_Paths.end()) | ||||
{ | { | ||||
LOGWARNING("Path with name '%s' already exists", path.GetName().ToUTF8()); | LOGWARNING("Path with name '%s' already exists", path.GetName().ToUTF8()); | ||||
return; | return; | ||||
} | } | ||||
m_Paths[path.GetName()] = path; | m_Paths[path.GetName()] = path; | ||||
} | } | ||||
void AddCinemaPathToQueue(const CStrW& name) override | void CCmpCinemaManager::AddCinemaPathToQueue(const CStrW& name) | ||||
{ | { | ||||
if (!HasPath(name)) | if (!HasPath(name)) | ||||
{ | { | ||||
LOGWARNING("Path with name '%s' doesn't exist", name.ToUTF8()); | LOGWARNING("Path with name '%s' doesn't exist", name.ToUTF8()); | ||||
return; | return; | ||||
} | } | ||||
m_PathQueue.push_back(m_Paths[name]); | m_PathQueue.push_back(m_Paths[name]); | ||||
if (m_PathQueue.size() == 1) | if (m_PathQueue.size() == 1) | ||||
m_PathQueue.front().Reset(); | m_PathQueue.front().Reset(); | ||||
m_TotalTime += m_Paths[name].GetDuration(); | m_TotalTime += m_Paths[name].GetDuration(); | ||||
} | } | ||||
void Play() override | void CCmpCinemaManager::Play() | ||||
{ | { | ||||
SetEnabled(true); | SetEnabled(true); | ||||
} | } | ||||
void Stop() override | void CCmpCinemaManager::Stop() | ||||
{ | { | ||||
SetEnabled(false); | SetEnabled(false); | ||||
} | } | ||||
bool HasPath(const CStrW& name) const override | bool CCmpCinemaManager::HasPath(const CStrW& name) const | ||||
{ | { | ||||
return m_Paths.find(name) != m_Paths.end(); | return m_Paths.find(name) != m_Paths.end(); | ||||
} | } | ||||
void ClearQueue() override | void CCmpCinemaManager::ClearQueue() | ||||
{ | { | ||||
m_PathQueue.clear(); | m_PathQueue.clear(); | ||||
} | } | ||||
void DeletePath(const CStrW& name) override | void CCmpCinemaManager::DeletePath(const CStrW& name) | ||||
{ | { | ||||
if (!HasPath(name)) | if (!HasPath(name)) | ||||
{ | { | ||||
LOGWARNING("Path with name '%s' doesn't exist", name.ToUTF8()); | LOGWARNING("Path with name '%s' doesn't exist", name.ToUTF8()); | ||||
return; | return; | ||||
} | } | ||||
m_PathQueue.remove_if([name](const CCinemaPath& path) { return path.GetName() == name; }); | m_PathQueue.remove_if([name](const CCinemaPath& path) { return path.GetName() == name; }); | ||||
m_Paths.erase(name); | m_Paths.erase(name); | ||||
} | } | ||||
const std::map<CStrW, CCinemaPath>& GetPaths() const override | const std::map<CStrW, CCinemaPath>& CCmpCinemaManager::GetPaths() const | ||||
{ | { | ||||
return m_Paths; | return m_Paths; | ||||
} | } | ||||
void SetPaths(const std::map<CStrW, CCinemaPath>& newPaths) override | void CCmpCinemaManager::SetPaths(const std::map<CStrW, CCinemaPath>& newPaths) | ||||
{ | { | ||||
m_Paths = newPaths; | m_Paths = newPaths; | ||||
} | } | ||||
const std::list<CCinemaPath>& GetQueue() const override | const std::list<CCinemaPath>& CCmpCinemaManager::GetQueue() const | ||||
{ | { | ||||
return m_PathQueue; | return m_PathQueue; | ||||
} | } | ||||
bool IsEnabled() const override | bool CCmpCinemaManager::IsEnabled() const | ||||
{ | { | ||||
return m_Enabled; | return m_Enabled; | ||||
} | } | ||||
void SetEnabled(bool enabled) override | void CCmpCinemaManager::SetEnabled(bool enabled) | ||||
{ | { | ||||
if (m_PathQueue.empty() && enabled) | if (m_PathQueue.empty() && enabled) | ||||
enabled = false; | enabled = false; | ||||
if (m_Enabled == enabled) | if (m_Enabled == enabled) | ||||
return; | return; | ||||
CmpPtr<ICmpRangeManager> cmpRangeManager(GetSimContext().GetSystemEntity()); | CmpPtr<ICmpRangeManager> cmpRangeManager(GetSimContext().GetSystemEntity()); | ||||
CmpPtr<ICmpTerritoryManager> cmpTerritoryManager(GetSimContext().GetSystemEntity()); | CmpPtr<ICmpTerritoryManager> cmpTerritoryManager(GetSimContext().GetSystemEntity()); | ||||
if (cmpRangeManager) | if (cmpRangeManager) | ||||
{ | { | ||||
if (enabled) | if (enabled) | ||||
m_MapRevealed = cmpRangeManager->GetLosRevealAll(-1); | m_MapRevealed = cmpRangeManager->GetLosRevealAll(-1); | ||||
// TODO: improve m_MapRevealed state and without fade in | // TODO: improve m_MapRevealed state and without fade in | ||||
cmpRangeManager->SetLosRevealAll(-1, enabled); | cmpRangeManager->SetLosRevealAll(-1, enabled); | ||||
} | } | ||||
if (cmpTerritoryManager) | if (cmpTerritoryManager) | ||||
cmpTerritoryManager->SetVisibility(!enabled); | cmpTerritoryManager->SetVisibility(!enabled); | ||||
ICmpSelectable::SetOverrideVisibility(!enabled); | ICmpSelectable::SetOverrideVisibility(!enabled); | ||||
ICmpOverlayRenderer::SetOverrideVisibility(!enabled); | ICmpOverlayRenderer::SetOverrideVisibility(!enabled); | ||||
m_Enabled = enabled; | m_Enabled = enabled; | ||||
} | } | ||||
void PlayQueue(const float deltaRealTime, CCamera* camera) override | void CCmpCinemaManager::PlayQueue(const float deltaRealTime, CCamera* camera) | ||||
{ | { | ||||
if (m_PathQueue.empty()) | if (m_PathQueue.empty()) | ||||
return; | return; | ||||
m_PathQueue.front().Play(deltaRealTime, camera); | m_PathQueue.front().Play(deltaRealTime, camera); | ||||
} | } | ||||
private: | void CCmpCinemaManager::SerializePath(const CCinemaPath& path, ISerializer& serializer) | ||||
void SerializePath(const CCinemaPath& path, ISerializer& serializer) | |||||
{ | { | ||||
const CCinemaData* data = path.GetData(); | const CCinemaData* data = path.GetData(); | ||||
serializer.String("PathName", data->m_Name, 1, 128); | serializer.String("PathName", data->m_Name, 1, 128); | ||||
serializer.String("PathOrientation", data->m_Orientation, 1, 128); | serializer.String("PathOrientation", data->m_Orientation, 1, 128); | ||||
serializer.String("PathMode", data->m_Mode, 1, 128); | serializer.String("PathMode", data->m_Mode, 1, 128); | ||||
serializer.String("PathStyle", data->m_Style, 1, 128); | serializer.String("PathStyle", data->m_Style, 1, 128); | ||||
serializer.NumberFixed_Unbounded("PathTimescale", data->m_Timescale); | serializer.NumberFixed_Unbounded("PathTimescale", data->m_Timescale); | ||||
serializer.Bool("LookAtTarget", data->m_LookAtTarget); | serializer.Bool("LookAtTarget", data->m_LookAtTarget); | ||||
serializer.NumberU32("NumberOfNodes", path.GetAllNodes().size(), 1, MAX_SPLINE_NODES); | serializer.NumberU32("NumberOfNodes", path.GetAllNodes().size(), 1, MAX_SPLINE_NODES); | ||||
const std::vector<SplineData>& nodes = path.GetAllNodes(); | const std::vector<SplineData>& nodes = path.GetAllNodes(); | ||||
for (size_t i = 0; i < nodes.size(); ++i) | for (size_t i = 0; i < nodes.size(); ++i) | ||||
{ | { | ||||
if (i > 0) | if (i > 0) | ||||
serializer.NumberFixed_Unbounded("NodeDeltaTime", nodes[i - 1].Distance); | serializer.NumberFixed_Unbounded("NodeDeltaTime", nodes[i - 1].Distance); | ||||
else | else | ||||
serializer.NumberFixed_Unbounded("NodeDeltaTime", fixed::Zero()); | serializer.NumberFixed_Unbounded("NodeDeltaTime", fixed::Zero()); | ||||
serializer.NumberFixed_Unbounded("PositionX", nodes[i].Position.X); | serializer.NumberFixed_Unbounded("PositionX", nodes[i].Position.X); | ||||
serializer.NumberFixed_Unbounded("PositionY", nodes[i].Position.Y); | serializer.NumberFixed_Unbounded("PositionY", nodes[i].Position.Y); | ||||
serializer.NumberFixed_Unbounded("PositionZ", nodes[i].Position.Z); | serializer.NumberFixed_Unbounded("PositionZ", nodes[i].Position.Z); | ||||
serializer.NumberFixed_Unbounded("RotationX", nodes[i].Rotation.X); | serializer.NumberFixed_Unbounded("RotationX", nodes[i].Rotation.X); | ||||
serializer.NumberFixed_Unbounded("RotationY", nodes[i].Rotation.Y); | serializer.NumberFixed_Unbounded("RotationY", nodes[i].Rotation.Y); | ||||
serializer.NumberFixed_Unbounded("RotationZ", nodes[i].Rotation.Z); | serializer.NumberFixed_Unbounded("RotationZ", nodes[i].Rotation.Z); | ||||
} | } | ||||
if (!data->m_LookAtTarget) | if (!data->m_LookAtTarget) | ||||
return; | return; | ||||
const std::vector<SplineData>& targetNodes = path.GetTargetSpline().GetAllNodes(); | const std::vector<SplineData>& targetNodes = path.GetTargetSpline().GetAllNodes(); | ||||
serializer.NumberU32("NumberOfTargetNodes", targetNodes.size(), 1, MAX_SPLINE_NODES); | serializer.NumberU32("NumberOfTargetNodes", targetNodes.size(), 1, MAX_SPLINE_NODES); | ||||
for (size_t i = 0; i < targetNodes.size(); ++i) | for (size_t i = 0; i < targetNodes.size(); ++i) | ||||
{ | { | ||||
if (i > 0) | if (i > 0) | ||||
serializer.NumberFixed_Unbounded("NodeDeltaTime", targetNodes[i - 1].Distance); | serializer.NumberFixed_Unbounded("NodeDeltaTime", targetNodes[i - 1].Distance); | ||||
else | else | ||||
serializer.NumberFixed_Unbounded("NodeDeltaTime", fixed::Zero()); | serializer.NumberFixed_Unbounded("NodeDeltaTime", fixed::Zero()); | ||||
serializer.NumberFixed_Unbounded("PositionX", targetNodes[i].Position.X); | serializer.NumberFixed_Unbounded("PositionX", targetNodes[i].Position.X); | ||||
serializer.NumberFixed_Unbounded("PositionY", targetNodes[i].Position.Y); | serializer.NumberFixed_Unbounded("PositionY", targetNodes[i].Position.Y); | ||||
serializer.NumberFixed_Unbounded("PositionZ", targetNodes[i].Position.Z); | serializer.NumberFixed_Unbounded("PositionZ", targetNodes[i].Position.Z); | ||||
} | } | ||||
} | } | ||||
CCinemaPath DeserializePath(IDeserializer& deserializer) | CCinemaPath CCmpCinemaManager::DeserializePath(IDeserializer& deserializer) | ||||
{ | { | ||||
CCinemaData data; | CCinemaData data; | ||||
deserializer.String("PathName", data.m_Name, 1, 128); | deserializer.String("PathName", data.m_Name, 1, 128); | ||||
deserializer.String("PathOrientation", data.m_Orientation, 1, 128); | deserializer.String("PathOrientation", data.m_Orientation, 1, 128); | ||||
deserializer.String("PathMode", data.m_Mode, 1, 128); | deserializer.String("PathMode", data.m_Mode, 1, 128); | ||||
deserializer.String("PathStyle", data.m_Style, 1, 128); | deserializer.String("PathStyle", data.m_Style, 1, 128); | ||||
deserializer.NumberFixed_Unbounded("PathTimescale", data.m_Timescale); | deserializer.NumberFixed_Unbounded("PathTimescale", data.m_Timescale); | ||||
deserializer.Bool("LookAtTarget", data.m_LookAtTarget); | deserializer.Bool("LookAtTarget", data.m_LookAtTarget); | ||||
TNSpline pathSpline, targetSpline; | TNSpline pathSpline, targetSpline; | ||||
uint32_t numberOfNodes = 0; | uint32_t numberOfNodes = 0; | ||||
deserializer.NumberU32("NumberOfNodes", numberOfNodes, 1, MAX_SPLINE_NODES); | deserializer.NumberU32("NumberOfNodes", numberOfNodes, 1, MAX_SPLINE_NODES); | ||||
for (uint32_t j = 0; j < numberOfNodes; ++j) | for (uint32_t j = 0; j < numberOfNodes; ++j) | ||||
{ | { | ||||
SplineData node; | SplineData node; | ||||
deserializer.NumberFixed_Unbounded("NodeDeltaTime", node.Distance); | deserializer.NumberFixed_Unbounded("NodeDeltaTime", node.Distance); | ||||
deserializer.NumberFixed_Unbounded("PositionX", node.Position.X); | deserializer.NumberFixed_Unbounded("PositionX", node.Position.X); | ||||
deserializer.NumberFixed_Unbounded("PositionY", node.Position.Y); | deserializer.NumberFixed_Unbounded("PositionY", node.Position.Y); | ||||
deserializer.NumberFixed_Unbounded("PositionZ", node.Position.Z); | deserializer.NumberFixed_Unbounded("PositionZ", node.Position.Z); | ||||
deserializer.NumberFixed_Unbounded("RotationX", node.Rotation.X); | deserializer.NumberFixed_Unbounded("RotationX", node.Rotation.X); | ||||
deserializer.NumberFixed_Unbounded("RotationY", node.Rotation.Y); | deserializer.NumberFixed_Unbounded("RotationY", node.Rotation.Y); | ||||
deserializer.NumberFixed_Unbounded("RotationZ", node.Rotation.Z); | deserializer.NumberFixed_Unbounded("RotationZ", node.Rotation.Z); | ||||
pathSpline.AddNode(node.Position, node.Rotation, node.Distance); | pathSpline.AddNode(node.Position, node.Rotation, node.Distance); | ||||
} | } | ||||
if (data.m_LookAtTarget) | if (data.m_LookAtTarget) | ||||
{ | { | ||||
uint32_t numberOfTargetNodes = 0; | uint32_t numberOfTargetNodes = 0; | ||||
deserializer.NumberU32("NumberOfTargetNodes", numberOfTargetNodes, 1, MAX_SPLINE_NODES); | deserializer.NumberU32("NumberOfTargetNodes", numberOfTargetNodes, 1, MAX_SPLINE_NODES); | ||||
for (uint32_t j = 0; j < numberOfTargetNodes; ++j) | for (uint32_t j = 0; j < numberOfTargetNodes; ++j) | ||||
{ | { | ||||
SplineData node; | SplineData node; | ||||
deserializer.NumberFixed_Unbounded("NodeDeltaTime", node.Distance); | deserializer.NumberFixed_Unbounded("NodeDeltaTime", node.Distance); | ||||
deserializer.NumberFixed_Unbounded("PositionX", node.Position.X); | deserializer.NumberFixed_Unbounded("PositionX", node.Position.X); | ||||
deserializer.NumberFixed_Unbounded("PositionY", node.Position.Y); | deserializer.NumberFixed_Unbounded("PositionY", node.Position.Y); | ||||
deserializer.NumberFixed_Unbounded("PositionZ", node.Position.Z); | deserializer.NumberFixed_Unbounded("PositionZ", node.Position.Z); | ||||
targetSpline.AddNode(node.Position, CFixedVector3D(), node.Distance); | targetSpline.AddNode(node.Position, CFixedVector3D(), node.Distance); | ||||
} | } | ||||
} | } | ||||
return CCinemaPath(data, pathSpline, targetSpline); | return CCinemaPath(data, pathSpline, targetSpline); | ||||
} | } | ||||
bool m_Enabled; | |||||
std::map<CStrW, CCinemaPath> m_Paths; | |||||
std::list<CCinemaPath> m_PathQueue; | |||||
// States before playing | |||||
bool m_MapRevealed; | |||||
fixed m_ElapsedTime; | |||||
fixed m_TotalTime; | |||||
fixed m_CurrentPathElapsedTime; | |||||
}; | |||||
REGISTER_COMPONENT_TYPE(CinemaManager) | REGISTER_COMPONENT_TYPE(CinemaManager) |
Wildfire Games · Phabricator