AtomsCache.h

#pragma once
// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
 
#include <Atoms/Globals.h>
#include <Atoms/AgentGroup.h>
#include <Atoms/AgentTypes.h>
 
namespace Atoms
{
    class ATOMS_EXPORT AtomsCache
    {
    public:
 
        class FrameData
        {
        public:
            AtomsPtr<AtomsCore::MapMetadata> pose;
            AtomsPtr<AtomsCore::MapMetadata> metadata;
            AtomsPtr<AtomsCore::MapMetadata> frame;
            AtomsPtr<AtomsCore::MapMetadata> header;
        };
 
        AtomsCache();
 
        /*
        \param cachePath cache folder path
        \param cacheName cache name without .atoms
        */
        AtomsCache(const std::string& cachePath, const std::string& cacheName);
 
        /*
        \param cachePath cache folder path
        \param cacheName cache name without .atoms
        \param agents Agents ids, it loads only those agents form the cache
        */
        AtomsCache(const std::string& cachePath, const std::string& cacheName, const std::vector<int>& agents);
 
        ~AtomsCache();
 
 
        bool openCache(const std::string& cachePath, const std::string& cacheName);
 
 
        bool openCache(const std::string& cachePath, const std::string& cacheName, const std::vector<int>& agents);
 
        void loadPrevFrame(int frame);
 
 
        void loadFrame(int frame);
 
        void loadNextFrame(int frame);
 
        void loadPrevFrameHeader(int frame);
 
 
        void loadFrameHeader(int frame);
 
        void loadNextFrameHeader(int frame);
 
        size_t numAgents() const;
 
        int startFrame() const;
 
        int endFrame() const;
 
        int currentFrame() const;
 
        int prevFrame() const;
 
        int nextFrame() const;
 
        FrameData& prevFrameData();
 
        FrameData& frameData();
 
        FrameData& nextFrameData();
 
 
        void loadBoundingBox(double time, AtomsCore::Box3& box) const;
 
 
        void loadAgent(double time, unsigned int agentId, Atoms::Agent& agent) const;
 
 
        void loadAgentBoundingBox(double time, unsigned int agentId, AtomsCore::Box3& box) const;
 
 
        void loadAgentPose(double time, unsigned int agentId, AtomsCore::Pose& pose) const;
 
 
        void loadAgentMetadata(double time, unsigned int agentId, AtomsCore::MapMetadata& metadata) const;
 
        void clear();
 
 
        static bool exportCacheFrame(
            const std::string& cachePath,
            const std::string& cacheName,
            long frame, 
            const std::vector<AtomsPtr<Atoms::AgentGroup>>& agentGroups,
            std::unordered_map<size_t, size_t>& cacheIdMap,
            std::set<std::string>& agentTypes,
            size_t tags,
            bool useSkinMeshBBox = false);
 
        void processMetadata(AtomsCore::MapMetadata &outMetadata, std::vector<const AtomsCore::MapMetadata*> &inMetadatas, const std::vector<double> &inputWeightVector) const;
 
        void blendPose(size_t numJoints, std::vector<const AtomsCore::Pose*>& posePorts, std::vector<double>& weightPorts, AtomsCore::Pose& outPose) const;
 
        const std::string& agentType(double time, unsigned int agentId) const;
 
        const AtomsCore::Vector3& agentPosition(double time, unsigned int agentId) const;
 
        const std::string& agentVariation(double time, unsigned int agentId) const;
 
        int agentColorVariation(double time, unsigned int agentId) const;
 
        const std::string& agentLod(double time, unsigned int agentId) const;
 
        const AtomsCore::Vector3& agentVelocity(double time, unsigned int agentId) const;
 
        const std::vector<int>& agentIds(double time) const;
 
        const std::vector<int>& agentsCreated(double time) const;
 
        const std::vector<int>& agentsDeleted(double time) const;
 
        size_t numAgentsCreated(double time) const;
 
        size_t numAgentsDeleted(double time) const;
 
        void setAgentsToLoad(const std::vector<int>& agents);
 
        const std::string& cacheName() const;
 
        const std::string& cachePath() const;
 
        /*
        Get an agent type from the local AgentTypes or from the global AgentTypes singleton
        If an agent type desn't exists it loads from the cache folder and store isnide the local agentypes
        if asGlobal is false or on the global singleton if it's true.
        \param agentTypeName Agne type name
        \param asGlobal If false, it stores the agent type loaded from the cache inside the local agentTypes, else it stores inside the global AgetnTypes singleton
        */
        AgentTypePtr loadAgentType(const std::string& agentTypeName, bool asGlobal = true);
 
        AgentTypes& agentTypes();
 
        const AgentTypes& agentTypes() const;
 
    private:
 
        void readData(FrameData& data, int frame, int& m_currentFrame)  const;
 
        void readDataKeys(FrameData& data, int frame, std::vector<std::string>& keys, int& m_currentFrame)  const;
 
        void readFrameHeaderData(FrameData& data, int frame, int& m_currentFrame)  const;
 
    private:
 
        Atoms::AgentTypes m_agentTypes;
 
        AtomsCore::MapMetadata m_header;
 
        FrameData m_prevFrameData;
 
        FrameData m_currentFrameData;
 
        FrameData m_nextFrameData;
 
        std::vector<std::string> m_agentIdsToLoad;
 
        std::string m_cachePath;
 
        std::string m_cacheName;
 
        int m_startFrame;
 
        int m_endFrame;
 
        int m_prevFrame;
 
        int m_currentFrame;
 
        int m_nextFrame;
 
        std::vector<int> m_emptyIds;
 
        std::string m_emptyString;
 
        AtomsCore::Vector3 m_emptyVector;
    };
}