Asset.h

Go to the documentation of this file.

#pragma once
 
#include "PolyphaseAPI.h"
#include "EngineTypes.h"
#include "EmbeddedFile.h"
#include "Factory.h"
#include "Object.h"
#include "Maths.h"
 
#include <string>
#include <vector>
#include <unordered_map>
 
class Stream;
class Property;
class AssetDir;
 
#define ASSET_MAGIC_NUMBER 0x4f435421
 
//----------------------------------------------------
// --------------- ASSET VERSIONING ------------------
// ---------------------------------------------------
#define ASSET_VERSION_BASE 1
#define ASSET_VERSION_SCENE_EXTRA_DATA 2
#define ASSET_VERSION_PARTICLE_RADIAL_SPAWN 3
#define ASSET_VERSION_PROPERTY_EXTRA 4
#define ASSET_VERSION_SCENE_SUB_SCENE_OVERRIDE 5
#define ASSET_VERSION_FONT_TTF_FLAG 6
#define ASSET_VERSION_TEXTURE_COOKED_PROPERTIES 7
#define ASSET_VERSION_TEXTURE_LOW_QUALITY 8
#define ASSET_VERSION_MATERIAL_LITE_TEXTURE_COUNT 9
#define ASSET_VERSION_STATIC_MESH_3D_HAS_BAKED_LIGHTING 10
#define ASSET_VERSION_SCENE_SUBSCENE_INSTANCE_COLORS 11
#define ASSET_VERSION_UUID_SUPPORT 12
#define ASSET_VERSION_UUID_WITH_NAME_FALLBACK 13
#define ASSET_VERSION_NODE_PERSISTENT_UUID 14
#define ASSET_VERSION_MATERIAL_LITE_NODE_GRAPH 15
#define ASSET_VERSION_NODE_GRAPH_FUNCTIONS 16
#define ASSET_VERSION_NODE_GRAPH_VARIABLES 17
#define ASSET_VERSION_SCENE_ICON_OVERRIDE 18
#define ASSET_VERSION_SCENE_MENU_OVERRIDE 19
#define ASSET_VERSION_VOXEL3D 20
#define ASSET_VERSION_VOXEL3D_ATLAS 21
#define ASSET_VERSION_VOXEL3D_ATLAS_INT32 22
#define ASSET_VERSION_TERRAIN3D 23
#define ASSET_VERSION_TERRAIN3D_MATSLOTS 24
#define ASSET_VERSION_TERRAIN3D_ATLAS 25
#define ASSET_VERSION_TERRAIN3D_BAKE 26
#define ASSET_VERSION_TERRAIN3D_BAKEDMAP 27
#define ASSET_VERSION_TILESET_BASE 28
#define ASSET_VERSION_TILEMAP_BASE 29
#define ASSET_VERSION_TILESET_METADATA 30
#define ASSET_VERSION_TILESET_AUTOTILE 31
#define ASSET_VERSION_TRANSFORM_KEYFRAME_SIGNAL 32
#define ASSET_VERSION_INPUT_PROMPT_MAP 33
#define ASSET_VERSION_INPUT_PROMPT_STYLE 34
#define ASSET_VERSION_MATERIAL_LITE_UV_SOURCE 35
#define ASSET_VERSION_SKELETAL_MESH_SECTIONS 36
#define ASSET_VERSION_BONE_MASK 37
#define ASSET_VERSION_CURRENT 37
// ----------------------------------------------------
 
#define DECLARE_ASSET(Base, Parent) DECLARE_FACTORY(Base, Asset); DECLARE_OBJECT(Base, Parent);
#define DEFINE_ASSET(Base) DEFINE_FACTORY(Base, Asset); DEFINE_OBJECT(Base);
 
POLYPHASE_API extern bool HandleAssetPropChange(Datum* datum, uint32_t index, const void* newValue);
 
enum class AssetLoadState
{
    Unloaded,
    AwaitBegin,
    AwaitEnd,
    Loaded,
 
    Count
};
 
struct AssetHeader
{
    uint32_t mMagic = ASSET_MAGIC_NUMBER;
    uint32_t mVersion = ASSET_VERSION_CURRENT;
    TypeId mType = INVALID_TYPE_ID;
    uint8_t mEmbedded = false;
    uint64_t mUuid = 0;  // Added in ASSET_VERSION_UUID_SUPPORT (12)
};
 
struct AssetStub
{
    Asset* mAsset = nullptr;
    const EmbeddedFile* mEmbeddedData = nullptr;
    std::string mPath;
    TypeId mType = INVALID_TYPE_ID;
    bool mEngineAsset = false;
    uint64_t mUuid = 0;  // Primary identifier
 
    // Per-asset packaging metadata, sourced from the {asset}.meta sidecar at discovery time.
    // Defaults preserve pre-meta behaviour: ship to all platforms, loose on disk.
    uint32_t mPlatformMask = PlatformBit_All;
    bool     mEmbed        = false;
 
#if EDITOR
    std::string mName;
    AssetDir* mDirectory = nullptr;
#endif
};
 
class ImportOptions
{
public:
    bool HasOption(const std::string& key);
    Datum GetOptionValue(const std::string& key);
    void SetOptionValue(const std::string& key, const Datum& value);
 
protected:
    std::unordered_map<std::string, Datum> mOptions;
};
 
class POLYPHASE_API Asset : public Object
{
public:
 
    DECLARE_FACTORY_MANAGER(Asset);
    DECLARE_FACTORY(Asset, Asset);
    DECLARE_OBJECT(Asset, Object);
 
    Asset();
    virtual ~Asset();
 
    virtual void Create();
    virtual void Destroy();
 
    virtual void Copy(Asset* srcAsset);
 
    // Reset the loaded flag without destroying the asset or erasing live
    // AssetRefs. Lets a caller tear down the GPU/physics side of an asset
    // and then call Create() again to rebuild from new data, while any
    // scene references to this asset stay intact. Used by editor-time
    // rebuilds such as StaticMesh::CreateRaw being invoked on an asset
    // that AssetManager already auto-Create()'d at registration time.
    void ResetLoadedFlag();
 
    const std::string& GetName() const;
    bool IsLoaded() const;
    bool IsRefCounted() const;
    int32_t GetRefCount() const;
 
    bool IsEmbedded() const;
    void SetEmbedded(bool embed);
 
    bool IsEngineAsset() const;
    void SetEngineAsset(bool engineAsset);
 
    void SetName(const std::string& name);
    void IncrementRefCount();
    void DecrementRefCount();
 
    void LoadFile(const char* path, AsyncLoadRequest* request = nullptr);
    void LoadEmbedded(const EmbeddedFile* embeddedAsset, AsyncLoadRequest* request = nullptr);
    void SaveFile(const char* path, Platform platform);
 
    virtual void LoadStream(Stream& stream, Platform platform);
    virtual void SaveStream(Stream& stream, Platform platform);
    virtual bool Import(const std::string& path, ImportOptions* options = nullptr);
 
    virtual void GatherProperties(std::vector<Property>& outProps) override;
    virtual glm::vec4 GetTypeColor();
    virtual const char* GetTypeName();
    virtual const char* GetTypeImportExt();
 
    // Editor-only behavior: when true, EditorState snapshots this asset's
    // serialized state (and dirty flag) at PIE start and restores it at PIE
    // stop, so script mutations during play don't leak into the editor view.
    // Kept unconditional to keep vtable layout identical across editor and
    // runtime builds; the runtime never calls this.
    virtual bool ShouldSnapshotForPie() const { return false; }
 
    bool IsTransient() const;
    void SetTransient(bool transient);
 
    uint64_t GetUuid() const;
    void SetUuid(uint64_t uuid);
    void EnsureUuid();  // Generate UUID if not already assigned
 
    static AssetHeader ReadHeader(Stream& stream);
    void WriteHeader(Stream& stream);
 
    static std::string GetNameFromPath(const std::string& path);
    static std::string GetDirectoryFromPath(const std::string& path);
 
    static const char* GetNameFromTypeId(TypeId id);
    static TypeId GetTypeIdFromName(const char* name);
 
protected:
 
    uint32_t mVersion = 0;
    TypeId mType = INVALID_TYPE_ID;
    uint64_t mUuid = 0;
    bool mEmbedded = false;
    bool mLoaded = false;
    bool mEnableRefCount = true;
    bool mEngineAsset = false;
    bool mTransient = false;
 
    std::string mName = "Asset";
    int32_t mRefCount = 0;
 
#if EDITOR
public:
    void ClearDirtyFlag();
    void SetDirtyFlag();
    bool GetDirtyFlag();
 
protected:
    bool mDirty = false;
#endif
};