carb/assets/AssetsTypes.h

File members: carb/assets/AssetsTypes.h

// Copyright (c) 2018-2022, NVIDIA CORPORATION. All rights reserved.
//
// NVIDIA CORPORATION and its licensors retain all intellectual property
// and proprietary rights in and to this software, related documentation
// and any modifications thereto. Any use, reproduction, disclosure or
// distribution of this software and related documentation without an express
// license agreement from NVIDIA CORPORATION is strictly prohibited.
//

#pragma once

#include "../Defines.h"

#include "../extras/Hash.h"
#include "../Strong.h"

namespace carb
{

#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace datasource
{
struct IDataSource;
struct Connection;
} // namespace datasource
#endif

namespace assets
{

enum class Reason
{
    eSuccess,
    eInvalidHandle,
    eInvalidType,
    eFailed,
    eLoading,
};

// The following are handles to detect incorrect usage patters such as using a handle
// after it has be destroyed.

CARB_STRONGTYPE(Id, size_t);

CARB_STRONGTYPE(Pool, size_t);

CARB_STRONGTYPE(Snapshot, size_t);

using HashedType = uint64_t;

constexpr Id kInvalidAssetId{};

constexpr Pool kInvalidPool{};

constexpr Snapshot kInvalidSnapshot{};

struct LoadContext
{
};

struct LoadParameters
{
};

struct Type
{
    Type(HashedType hashedType, uint32_t majorVersion, uint32_t minorVersion)
        : hashedType(hashedType), majorVersion(majorVersion), minorVersion(minorVersion)
    {
    }
    uint64_t hashedType;
    uint32_t majorVersion;
    uint32_t minorVersion;
};

template <class Type>
class ScopedSnapshot;

using AssetHash = extras::hash128_t;

template <typename T>
Type getAssetType();

using IsLoadCanceledFn = bool (*)(void* userData);

using LoadAssetFn = void* (*)(carb::datasource::IDataSource* dataSource,
                              carb::datasource::Connection* connection,
                              const char* path,
                              const uint8_t* data,
                              size_t size,
                              const LoadParameters* loadParameters,
                              LoadContext* loadContext,
                              IsLoadCanceledFn isLoadCanceled,
                              void* isLoadCanceledUserData);

using UnloadAssetFn = void (*)(void* asset);

using CreateContextFn = LoadContext* (*)(carb::datasource::IDataSource* dataSource,
                                         carb::datasource::Connection* connection,
                                         const char* path,
                                         const uint8_t* data,
                                         size_t size,
                                         const LoadParameters* loadParameters);

using DestroyContextFn = void (*)(LoadContext* context);

using CreateDependenciesFn = const char* (*)(carb::datasource::IDataSource* dataSource,
                                             carb::datasource::Connection* connection,
                                             const char* path,
                                             const uint8_t* data,
                                             size_t size,
                                             const LoadParameters* loadParameters,
                                             LoadContext* context);

using DestroyDependenciesFn = void (*)(const char* dependencies, LoadContext* context);

using OnDependencyChangedFn = void (*)(carb::datasource::IDataSource* dataSource,
                                       carb::datasource::Connection* connection,
                                       const char* path);

using HashAssetFn = AssetHash (*)(carb::datasource::IDataSource* dataSource,
                                  carb::datasource::Connection* connection,
                                  const char* path,
                                  const uint8_t* data,
                                  size_t size,
                                  const LoadParameters* loadParameters,
                                  LoadContext* context);

using CreateLoadParametersFn = LoadParameters* (*)(const LoadParameters* loadParameters);

using DestroyLoadParametersFn = void (*)(LoadParameters* loadParameters);

using HashLoadParametersFn = uint64_t (*)(const LoadParameters* loadParameters);

using LoadParametersEqualsFn = bool (*)(const LoadParameters* loadParametersA, const LoadParameters* loadParametersB);

struct LoaderDesc
{
    LoadAssetFn loadAsset;
    UnloadAssetFn unloadAsset;
    CreateLoadParametersFn createLoadParameters;
    DestroyLoadParametersFn destroyLoadParameters;
    HashLoadParametersFn hashLoadParameters;
    LoadParametersEqualsFn loadParametersEquals;
    HashAssetFn hashAsset;
    CreateContextFn createContext;
    DestroyContextFn destroyContext;
    CreateDependenciesFn createDependencies;
    DestroyDependenciesFn destroyDependencies;
    OnDependencyChangedFn onDependencyChanged;
};

struct AssetTypeParams
{
    size_t sizeofThis;

    uint32_t maxConcurrency;

    bool autoReload;

    uint32_t reloadDelayMs;

    constexpr static AssetTypeParams getDefault()
    {
        return AssetTypeParams{ sizeof(AssetTypeParams), 0, true, 100 };
    }
};

using OnChangeEventFn = void (*)(Id assetId, void* userData);

} // namespace assets
} // namespace carb

#ifdef DOXYGEN_BUILD
#    define CARB_ASSET(t, majorVersion, minorVersion)
#else
#    define CARB_ASSET(t, majorVersion, minorVersion)                                                                  \
        namespace carb                                                                                                 \
        {                                                                                                              \
        namespace assets                                                                                               \
        {                                                                                                              \
        template <>                                                                                                    \
        inline Type getAssetType<t>()                                                                                  \
        {                                                                                                              \
            return Type(CARB_HASH_TYPE(t), majorVersion, minorVersion);                                                \
        }                                                                                                              \
        }                                                                                                              \
        }
#endif