AtomsClothCache.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>
 
namespace Atoms
{
    class ATOMS_EXPORT AtomsClothCache
    {
    public:
 
        AtomsClothCache();
 
        /*
        \param cachePath cache folder path
        \param cacheName cache name without .clothcache
        */
        AtomsClothCache(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
        */
        AtomsClothCache(const std::string& cachePath, const std::string& cacheName, const std::vector<int>& agents);
 
        ~AtomsClothCache();
 
 
        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 loadTime(double time);
 
        void loadPrevFrame(int frame);
 
 
        void loadFrame(int frame);
 
        void loadNextFrame(int frame);
 
        int startFrame() const;
 
        int endFrame() const;
 
        int currentFrame() const;
 
        int prevFrame() const;
 
        int nextFrame() const;
 
        AtomsPtr<AtomsCore::MapMetadata>& prevFrameData();
 
        AtomsPtr<AtomsCore::MapMetadata>& frameData();
 
        AtomsPtr<AtomsCore::MapMetadata>& nextFrameData();
 
 
        void loadBoundingBox(double time, AtomsCore::Box3& box) const;
 
 
        void loadAgentClothBoundingBox(double time, unsigned int agentId, AtomsCore::Box3& box) const;
 
 
        void loadAgentClothMeshBoundingBox(double time, unsigned int agentId, const std::string& meshName, AtomsCore::Box3& box) const;
 
 
        void loadAgentClothMesh(double time, 
            unsigned int agentId,
            const std::string& meshName,
            std::vector<AtomsCore::Vector3>& points,
            std::vector<AtomsCore::Vector3>& normals
        ) const;
 
 
        std::string getAgentClothMeshStackOrder(double time,
            unsigned int agentId,
            const std::string& meshName
        ) const;
 
 
        bool hasAgentClothMesh(double time, unsigned int agentId, const std::string& meshName) const;
 
        void clear();
 
        static void processPoints(std::vector<AtomsCore::Vector3>& outPoints, std::vector<const std::vector<AtomsCore::Vector3>*> &inPoints, const std::vector<double> &inputWeightVector);
 
        static void processNormals(std::vector<AtomsCore::Vector3>& outNormals, std::vector<const std::vector<AtomsCore::Vector3>*> &inNormals, const std::vector<double> &inputWeightVector);
 
        std::vector<int> agentIds(double time) const;
 
        std::vector<std::string> agentClothMeshNames(double time, unsigned int agentId) const;
 
        size_t numAgents(double time) const;
 
        void setAgentsToLoad(const std::vector<int>& agents);
 
        const std::string& cacheName() const;
 
        const std::string& cachePath() const;
 
    private:
 
        int clampFrame(int frame) const;
 
        void readData(AtomsPtr<AtomsCore::MapMetadata>& data, int frame, int& m_currentFrame);
 
        void readDataKeys(AtomsPtr<AtomsCore::MapMetadata>& data, int frame, std::vector<std::string>& keys, int& m_currentFrame);
 
    private:
 
        AtomsCore::MapMetadata m_header;
 
        AtomsPtr<AtomsCore::MapMetadata> m_prevFrameData;
 
        AtomsPtr<AtomsCore::MapMetadata> m_currentFrameData;
 
        AtomsPtr<AtomsCore::MapMetadata> 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;
    };
}