actoradapter.hpp

Go to the documentation of this file.

#ifndef CSM_WOLRD_ACTORADAPTER_H
#define CSM_WOLRD_ACTORADAPTER_H

#include <array>
#include <map>
#include <unordered_set>

#include <QObject>
#include <QModelIndex>

#include <components/esm/loadarmo.hpp>
#include <components/esm/loadbody.hpp>
#include <components/misc/weakcache.hpp>

#include "refidcollection.hpp"
#include "idcollection.hpp"

namespace ESM
{
    struct Race;
}

namespace CSMWorld
{
    class Data;

    class ActorAdapter : public QObject
    {
        Q_OBJECT
    public:

        using ActorPartList = std::map<ESM::PartReferenceType, std::pair<std::string, int>>;
        using RacePartList = std::array<std::string, ESM::BodyPart::MP_Count>;
        using StringSet = std::unordered_set<std::string>;


        class RaceData
        {
        public:
            const std::string& getId() const;
            bool isBeast() const;
            bool handlesPart(ESM::PartReferenceType type) const;
            const std::string& getFemalePart(ESM::PartReferenceType index) const;
            const std::string& getMalePart(ESM::PartReferenceType index) const;
            bool hasDependency(const std::string& id) const;

            void setFemalePart(ESM::BodyPart::MeshPart partIndex, const std::string& partId);
            void setMalePart(ESM::BodyPart::MeshPart partIndex, const std::string& partId);
            void addOtherDependency(const std::string& id);
            void reset_data(const std::string& raceId, bool isBeast=false);

        private:
            bool handles(ESM::PartReferenceType type) const;
            std::string mId;
            bool mIsBeast;
            RacePartList mFemaleParts;
            RacePartList mMaleParts;
            StringSet mDependencies;
        };
        using RaceDataPtr = std::shared_ptr<RaceData>;

        class ActorData
        {
        public:
            const std::string& getId() const;
            bool isCreature() const;
            bool isFemale() const;
            std::string getSkeleton() const;
            const std::string getPart(ESM::PartReferenceType index) const;
            bool hasDependency(const std::string& id) const;

            void setPart(ESM::PartReferenceType partIndex, const std::string& partId, int priority);
            void addOtherDependency(const std::string& id);
            void reset_data(const std::string& actorId, const std::string& skeleton="", bool isCreature=false, bool female=true, RaceDataPtr raceData=nullptr);

        private:
            std::string mId;
            bool mCreature;
            bool mFemale;
            std::string mSkeletonOverride;
            RaceDataPtr mRaceData;
            ActorPartList mParts;
            StringSet mDependencies;
        };
        using ActorDataPtr = std::shared_ptr<ActorData>;


        ActorAdapter(Data& data);

        ActorDataPtr getActorData(const std::string& refId);

    signals:

        void actorChanged(const std::string& refId);

    public slots:

        void handleReferenceablesInserted(const QModelIndex&, int, int);
        void handleReferenceableChanged(const QModelIndex&, const QModelIndex&);
        void handleReferenceablesAboutToBeRemoved(const QModelIndex&, int, int);
        void handleReferenceablesRemoved(const QModelIndex&, int, int);

        void handleRacesInserted(const QModelIndex&, int, int);
        void handleRaceChanged(const QModelIndex&, const QModelIndex&);
        void handleRacesAboutToBeRemoved(const QModelIndex&, int, int);
        void handleRacesRemoved(const QModelIndex&, int, int);

        void handleBodyPartsInserted(const QModelIndex&, int, int);
        void handleBodyPartChanged(const QModelIndex&, const QModelIndex&);
        void handleBodyPartsAboutToBeRemoved(const QModelIndex&, int, int);
        void handleBodyPartsRemoved(const QModelIndex&, int, int);

    private:

        ActorAdapter(const ActorAdapter&) = delete;
        ActorAdapter& operator=(const ActorAdapter&) = delete;

        QModelIndex getHighestIndex(QModelIndex) const;
        bool is1stPersonPart(const std::string& id) const;

        RaceDataPtr getRaceData(const std::string& raceId);

        void setupActor(const std::string& id, ActorDataPtr data);
        void setupRace(const std::string& id, RaceDataPtr data);

        void setupNpc(const std::string& id, ActorDataPtr data);
        void addNpcItem(const std::string& itemId, ActorDataPtr data);

        void setupCreature(const std::string& id, ActorDataPtr data);

        void markDirtyDependency(const std::string& dependency);
        void updateDirty();

        RefIdCollection& mReferenceables;
        IdCollection<ESM::Race>& mRaces;
        IdCollection<ESM::BodyPart>& mBodyParts;

        Misc::WeakCache<std::string, ActorData> mCachedActors; // Key: referenceable id
        Misc::WeakCache<std::string, RaceData> mCachedRaces; // Key: race id

        StringSet mDirtyActors; // Actors that need updating
        StringSet mDirtyRaces; // Races that need updating
    };
}

#endif