Compare commits
43
Commits
ae18a062b7
..
Vulkan
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
2fcb2fd64c | ||
|
|
df985d0397 | ||
|
|
130ea26f4f | ||
|
|
1799ff01c4 | ||
|
|
3cde56717f | ||
|
|
cd5f7b3823 | ||
|
|
e1e16268a2 | ||
|
|
c4e9f6f7d9 | ||
|
|
6ee035843e | ||
|
|
3c19e0e931 | ||
|
|
fc2f947557 | ||
|
|
2cce2e40e6 | ||
|
|
22e16561dc | ||
|
|
8d86fe007e | ||
|
|
087114b21b | ||
|
|
5703e25773 | ||
|
|
71dfb57179 | ||
|
|
d8b7698d4b | ||
|
|
e27d69b36e | ||
|
|
7f3b46867f | ||
|
|
fcf9bfa19e | ||
|
|
6895daa676 | ||
|
|
246ea70e93 | ||
|
|
7e6c2b62f3 | ||
|
|
2e512ad556 | ||
|
|
db0b5da1f3 | ||
|
|
aef49e7f11 | ||
|
|
10f4a09c37 | ||
|
|
0c3974cdec | ||
|
|
2303fe6182 | ||
|
|
23f623d9de | ||
|
|
16d5d0fffb | ||
|
|
f82d40532c | ||
|
|
310d16b9ed | ||
|
|
9f034fed3c | ||
|
|
33a79ed12f | ||
|
|
c4467ea2f2 | ||
|
|
8c9f78dbc7 | ||
|
|
1558a19f19 | ||
|
|
3a5dd1affe | ||
|
|
dc534acdd5 | ||
|
|
9fd1cd0d68 | ||
|
|
b7f4677c68 |
+68
-11
@@ -121,22 +121,79 @@ SpaceInEmptyBlock: true
|
||||
PenaltyBreakAssignment: 200
|
||||
KeepEmptyLinesAtTheStartOfBlocks: false
|
||||
IncludeCategories:
|
||||
- Regex: '^<Engine/'
|
||||
- Regex: '^<GraphicsCore/.*_generated\.h(pp)?>$'
|
||||
Priority: 16
|
||||
- Regex: '^<GraphicsVulkan/.*_generated\.h(pp)?>$'
|
||||
Priority: 17
|
||||
- Regex: '^<GraphicsInterface/.*_generated\.h(pp)?>$'
|
||||
Priority: 18
|
||||
- Regex: '^<Engine/.*_generated\.h(pp)?>$'
|
||||
Priority: 19
|
||||
- Regex: '^<System/.*_generated\.h(pp)?>$'
|
||||
Priority: 20
|
||||
- Regex: '^<Utils/.*_generated\.h(pp)?>$'
|
||||
Priority: 21
|
||||
- Regex: '^<SasquatchBaker/.*_generated\.h(pp)?>$'
|
||||
Priority: 22
|
||||
- Regex: '^<EngineTests/.*_generated\.h(pp)?>$'
|
||||
Priority: 23
|
||||
- Regex: '^<SystemTests/.*_generated\.h(pp)?>$'
|
||||
Priority: 24
|
||||
- Regex: '^<UtilsTests/.*_generated\.h(pp)?>$'
|
||||
Priority: 25
|
||||
- Regex: '^<AssetsForTesting/.*_generated\.h(pp)?>$'
|
||||
Priority: 26
|
||||
- Regex: '^<SasquatchBakerTests/.*_generated\.h(pp)?>$'
|
||||
Priority: 27
|
||||
- Regex: '^<EngineBenchmarks/.*_generated\.h(pp)?>$'
|
||||
Priority: 28
|
||||
- Regex: '^<AssetsForBenchmarking/.*_generated\.h(pp)?>$'
|
||||
Priority: 29
|
||||
- Regex: '^<SasquatchBakerBenchmarks/.*_generated\.h(pp)?>$'
|
||||
Priority: 30
|
||||
- Regex: '^<GraphicsCore/'
|
||||
Priority: 1
|
||||
- Regex: '^<System/'
|
||||
- Regex: '^<GraphicsVulkan/'
|
||||
Priority: 2
|
||||
- Regex: '^<Utils/'
|
||||
- Regex: '^<GraphicsInterface/'
|
||||
Priority: 3
|
||||
- Regex: '^<EngineTests/'
|
||||
- Regex: '^<Engine/'
|
||||
Priority: 4
|
||||
- Regex: '^<SystemTests/'
|
||||
- Regex: '^<System/'
|
||||
Priority: 5
|
||||
- Regex: '^<UtilsTests/'
|
||||
- Regex: '^<Utils/'
|
||||
Priority: 6
|
||||
- Regex: '^<[a-zA-Z0-9_/]+\.h>'
|
||||
- Regex: '^<SasquatchBaker/'
|
||||
Priority: 7
|
||||
- Regex: '^<[a-zA-Z0-9_/]+\.hpp>'
|
||||
Priority: 7
|
||||
- Regex: '^<[a-zA-Z0-9_/]+>'
|
||||
- Regex: '^<EngineTests/'
|
||||
Priority: 8
|
||||
MainIncludeChar: AngleBracket
|
||||
- Regex: '^<SystemTests/'
|
||||
Priority: 9
|
||||
- Regex: '^<UtilsTests/'
|
||||
Priority: 10
|
||||
- Regex: '^<AssetsForTesting/'
|
||||
Priority: 11
|
||||
- Regex: '^<SasquatchBakerTests/'
|
||||
Priority: 12
|
||||
- Regex: '^<EngineBenchmarks/'
|
||||
Priority: 13
|
||||
- Regex: '^<AssetsForBenchmarking/'
|
||||
Priority: 14
|
||||
- Regex: '^<SasquatchBakerBenchmarks/'
|
||||
Priority: 15
|
||||
- Regex: '^<[a-zA-Z0-9_/]+\.h>'
|
||||
Priority: 31
|
||||
- Regex: '^<[a-zA-Z0-9_/]+\.hpp>'
|
||||
Priority: 31
|
||||
- Regex: '^<[a-zA-Z0-9_/]+>'
|
||||
Priority: 32
|
||||
MainIncludeChar: AngleBracket
|
||||
Macros:
|
||||
- 'BIGFOOT_OPTIMIZED_ONLY(x)=x'
|
||||
- 'BIGFOOT_OPTIMIZED_ONLY(x,y)=x,y'
|
||||
- 'BIGFOOT_NOT_OPTIMIZED_ONLY(x)=x'
|
||||
- 'BIGFOOT_NOT_OPTIMIZED_ONLY(x,y)=x,y'
|
||||
- 'BIGFOOT_TOOLMODE_ONLY(x)=x'
|
||||
- 'BIGFOOT_TOOLMODE_ONLY(x,y)=x,y'
|
||||
- 'BIGFOOT_GAME_ONLY(x)=x'
|
||||
- 'BIGFOOT_GAME_ONLY(x,y)=x,y'
|
||||
|
||||
+5
-1
@@ -11,9 +11,13 @@ Checks: >
|
||||
portability-*,
|
||||
|
||||
-modernize-use-trailing-return-type,
|
||||
-modernize-use-auto,
|
||||
-readability-avoid-const-params-in-decls,
|
||||
-cppcoreguidelines-macro-usage,
|
||||
-cppcoreguidelines-avoid-do-while
|
||||
-cppcoreguidelines-avoid-do-while,
|
||||
-cppcoreguidelines-pro-bounds-avoid-unchecked-container-access,
|
||||
-cppcoreguidelines-pro-bounds-pointer-arithmetic,
|
||||
-cppcoreguidelines-pro-type-reinterpret-cast
|
||||
|
||||
ExcludeHeaderFilterRegex: '_generated.*'
|
||||
|
||||
|
||||
+19
-14
@@ -15,10 +15,16 @@ jobs:
|
||||
|
||||
strategy:
|
||||
matrix:
|
||||
build_type: ["Debug", "RelWithDebInfo", "Release"]
|
||||
build_type:
|
||||
- { value: "Debug", profile: "debug" }
|
||||
- { value: "RelWithDebInfo", profile: "relwithdebinfo" }
|
||||
- { value: "Release", profile: "release" }
|
||||
unity_build: ["ON", "OFF"]
|
||||
conan_profile: ["./ConanProfiles/host/clang", "./ConanProfiles/host/clang_asan"]
|
||||
name: "Build & Test ${{ matrix.build_type }} with ${{ matrix.conan_profile }} (Unity Build: ${{ matrix.unity_build }})"
|
||||
conan_profile: ["clang", "clang_asan"]
|
||||
variant:
|
||||
- { value: "True", name: "toolmode" }
|
||||
- { value: "False", name: "game" }
|
||||
name: "Build & Test ${{ matrix.build_type.value }} with ${{ matrix.conan_profile }} (Unity Build: ${{ matrix.unity_build }}, Variant: ${{ matrix.variant.name }})"
|
||||
steps:
|
||||
- name: Install Node.js
|
||||
run: apt-get update && apt-get install -y nodejs
|
||||
@@ -30,18 +36,17 @@ jobs:
|
||||
|
||||
- name: Build
|
||||
run: |
|
||||
conan install . --remote=bigfootpackages -pr:h=${{ matrix.conan_profile }} -pr:b=./ConanProfiles/build/clang --build=* -s build_type=${{ matrix.build_type }} -o bigfoot/*:build_tests=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:tracy=False -o bigfoot/*:vulkan=True
|
||||
. ./build/${{ matrix.build_type }}/generators/conanbuild.sh
|
||||
cmake -S . -B ./build/${{ matrix.build_type }} --toolchain ./build/${{ matrix.build_type }}/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=${{ matrix.build_type }} -DCMAKE_UNITY_BUILD=${{ matrix.unity_build }} -G "Ninja"
|
||||
cmake --build build/${{ matrix.build_type }} --parallel $(nproc)
|
||||
. ./build/${{ matrix.build_type }}/generators/deactivate_conanbuild.sh
|
||||
bash ./generate_bigfoot.sh missing ${{ matrix.build_type.value }} --profile=${{ matrix.conan_profile }} --variant=${{ matrix.variant.name }} --unity=${{ matrix.unity_build }} --tracy=False
|
||||
. ./build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/conanbuild.sh
|
||||
cmake --build build-linux-${{ matrix.variant.name }}/${{ matrix.build_type.value }} --parallel $(nproc)
|
||||
. ./build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/deactivate_conanbuild.sh
|
||||
|
||||
- name: Unit Tests
|
||||
run: |
|
||||
cd ./build/${{ matrix.build_type }}
|
||||
. ../../build/${{ matrix.build_type }}/generators/conanbuild.sh
|
||||
xvfb-run ctest . --output-on-failure
|
||||
. ../../build/${{ matrix.build_type }}/generators/deactivate_conanbuild.sh
|
||||
cd ./build-linux-${{ matrix.variant.name }}/${{ matrix.build_type.value }}
|
||||
. ../../build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/conanbuild.sh
|
||||
weston-run ctest . --output-on-failure
|
||||
. ../../build-linux-${{ matrix.variant.name }}/build/${{ matrix.build_type.value }}/generators/deactivate_conanbuild.sh
|
||||
|
||||
clang-format:
|
||||
runs-on: ubuntu-latest
|
||||
@@ -57,6 +62,6 @@ jobs:
|
||||
uses: actions/checkout@v6
|
||||
with:
|
||||
submodules: recursive
|
||||
|
||||
|
||||
- name: Clang Format Checks
|
||||
run: chmod +x format.sh && ./format.sh --check Bigfoot
|
||||
run: chmod +x format.sh && ./format.sh --check Bigfoot
|
||||
|
||||
@@ -5,6 +5,10 @@ on:
|
||||
branches:
|
||||
- main
|
||||
- Development
|
||||
pull_request:
|
||||
branches:
|
||||
- main
|
||||
- Development
|
||||
|
||||
jobs:
|
||||
build-and-test:
|
||||
@@ -13,7 +17,14 @@ jobs:
|
||||
container:
|
||||
image: git.romainboullard.com/bigfootdev/linuxcppbuilder:development
|
||||
|
||||
name: "Sonarqube"
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
variant:
|
||||
- { value: "True", name: "toolmode", projectKey: "Bigfoot-Tool", projectName: "Bigfoot Tool" }
|
||||
- { value: "False", name: "game", projectKey: "Bigfoot-Game", projectName: "Bigfoot Game" }
|
||||
|
||||
name: "Sonarqube (${{ matrix.variant.name }})"
|
||||
steps:
|
||||
- name: Install Node.js
|
||||
run: apt-get update && apt-get install -y nodejs
|
||||
@@ -23,28 +34,63 @@ jobs:
|
||||
with:
|
||||
fetch-depth: 0
|
||||
submodules: recursive
|
||||
ref: ${{ github.event.pull_request.head.sha || github.sha }}
|
||||
|
||||
- name: Read version
|
||||
id: version
|
||||
run: echo "version=$(cat VERSION)" >> "$GITHUB_OUTPUT"
|
||||
|
||||
- name: Build
|
||||
run: |
|
||||
conan install . --remote=bigfootpackages -pr:h=./ConanProfiles/host/clang_coverage -pr:b=./ConanProfiles/build/clang --build=* -s build_type=Debug -o bigfoot/*:build_tests=True -o bigfoot/*:build_benchmarks=True -o bigfoot/*:tracy=False -o bigfoot/*:build_tools=True -o bigfoot/*:vulkan=True
|
||||
. ./build/Debug/generators/conanbuild.sh
|
||||
cmake -S . -B ./build/Debug --toolchain ./build/Debug/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Debug -G "Ninja"
|
||||
cmake --build build/Debug --parallel $(nproc)
|
||||
. ./build/Debug/generators/deactivate_conanbuild.sh
|
||||
bash ./generate_bigfoot.sh missing Debug --profile=clang_coverage --variant=${{ matrix.variant.name }} --tracy=False
|
||||
. ./build-linux-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
|
||||
cmake --build build-linux-${{ matrix.variant.name }}/Debug --parallel $(nproc)
|
||||
. ./build-linux-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh
|
||||
|
||||
- name: Run tests
|
||||
run: |
|
||||
cd ./build-linux-${{ matrix.variant.name }}/Debug
|
||||
. ../../build-linux-${{ matrix.variant.name }}/build/Debug/generators/conanbuild.sh
|
||||
LLVM_PROFILE_FILE="%p.profraw%c" weston-run ctest --output-on-failure
|
||||
. ../../build-linux-${{ matrix.variant.name }}/build/Debug/generators/deactivate_conanbuild.sh
|
||||
|
||||
- name: Clang-Tidy
|
||||
run: run-clang-tidy -p ./build/Debug/ >> tidy_result.txt
|
||||
run: run-clang-tidy -p ./build-linux-${{ matrix.variant.name }}/Debug/ > tidy_result.txt
|
||||
|
||||
- name: Infer
|
||||
run: infer run --compilation-database build/Debug/compile_commands.json
|
||||
run: infer run --compilation-database build-linux-${{ matrix.variant.name }}/Debug/compile_commands.json
|
||||
|
||||
- name: Generate coverage report
|
||||
shell: bash
|
||||
run: |
|
||||
# gcovr's own LLVM-JSON reader only understands coverage-mapping format
|
||||
# 2.x; this image's clang 22 llvm-cov emits format 3.x, which gcovr
|
||||
# rejects outright ("Wrong major version"). Bypassing gcovr's JSON
|
||||
# path entirely: llvm-cov's lcov exporter is a separate, unaffected
|
||||
# code path, so merge -> export lcov -> convert lcov to Cobertura.
|
||||
llvm-profdata merge -sparse $(find build-linux-${{ matrix.variant.name }}/Debug -name "*.profraw") -o merged.profdata
|
||||
BINARIES=($(find build-linux-${{ matrix.variant.name }}/Debug -maxdepth 8 -type f -executable -iname "*Tests"))
|
||||
OBJECT_ARGS=$(printf -- '-object %s ' "${BINARIES[@]:1}")
|
||||
llvm-cov export -format=lcov -instr-profile=merged.profdata "${BINARIES[0]}" $OBJECT_ARGS > coverage.lcov
|
||||
# lcov_cobertura isn't preinstalled on the image; inject it into
|
||||
# gcovr's existing pipx venv and expose its CLI on PATH.
|
||||
pipx inject gcovr lcov_cobertura --include-apps
|
||||
lcov_cobertura coverage.lcov -b . -o coverage.xml
|
||||
|
||||
- name: SonarQube Scan
|
||||
if: github.head_ref == 'main' || github.ref_name == 'main'
|
||||
uses: SonarSource/sonarqube-scan-action@v7.0.0
|
||||
with:
|
||||
args: >
|
||||
-Dsonar.cxx.jsonCompilationDatabase=./build/Debug/compile_commands.json
|
||||
-Dsonar.verbose=true
|
||||
-Dsonar.projectKey=${{ matrix.variant.projectKey }}
|
||||
"-Dsonar.projectName=${{ matrix.variant.projectName }}"
|
||||
-Dsonar.projectVersion=${{ steps.version.outputs.version }}
|
||||
-Dsonar.cxx.jsonCompilationDatabase=./build-linux-${{ matrix.variant.name }}/Debug/compile_commands.json
|
||||
-Dsonar.cxx.xunit.reportPaths=build-linux-${{ matrix.variant.name }}/Debug/TestResults/*.xml
|
||||
-Dsonar.qualitygate.wait=true
|
||||
${{ github.event_name == 'pull_request' &&
|
||||
format('-Dsonar.pullrequest.key={0} -Dsonar.pullrequest.branch={1} -Dsonar.pullrequest.base={2} -Dsonar.analysis.sqbot={3}',
|
||||
github.event.pull_request.number, github.head_ref, github.base_ref, github.event.pull_request.head.sha)
|
||||
|| format('-Dsonar.branch.name={0}', github.ref_name) }}
|
||||
env:
|
||||
SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
|
||||
SONAR_HOST_URL: ${{ secrets.SONAR_HOST }}
|
||||
SONAR_HOST_URL: ${{ secrets.SONAR_HOST }}
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
InheritParentConfig: true
|
||||
Checks: >
|
||||
-cppcoreguidelines-non-private-member-variables-in-classes,
|
||||
-cppcoreguidelines-avoid-magic-numbers,
|
||||
-readability-magic-numbers
|
||||
+3
-3
@@ -1,11 +1,11 @@
|
||||
/*********************************************************************
|
||||
* \file BenchAssetLeaf.cpp
|
||||
* \file BenchmarkAsset.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetLeaf.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetHelper.hpp>
|
||||
|
||||
BIGFOOT_ASSET(BenchAssetLeaf, ::Bigfoot::BenchAssetLeaf)
|
||||
BIGFOOT_ASSET(BenchmarkAsset, ::Bigfoot::BenchmarkAsset)
|
||||
+3
-3
@@ -1,11 +1,11 @@
|
||||
/*********************************************************************
|
||||
* \file BenchAssetRoot.cpp
|
||||
* \file BenchmarkAssetReferred.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetRoot.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetHelper.hpp>
|
||||
|
||||
BIGFOOT_ASSET(BenchAssetRoot, ::Bigfoot::BenchAssetRoot)
|
||||
BIGFOOT_ASSET(BenchmarkAssetReferred, ::Bigfoot::BenchmarkAssetReferred)
|
||||
+2
-2
@@ -7,9 +7,9 @@ set(BigfootPublicDependencies)
|
||||
set(BigfootPrivateDependencies
|
||||
Engine)
|
||||
|
||||
bigfoot_create_package_tests_helper_lib(
|
||||
bigfoot_create_package_lib(
|
||||
"${PublicDependencies}"
|
||||
"${PrivateDependencies}"
|
||||
"${BigfootPublicDependencies}"
|
||||
"${BigfootPrivateDependencies}"
|
||||
"")
|
||||
"Bigfoot/Benchmarks")
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
include "Engine/Asset/Reference.fbs";
|
||||
|
||||
namespace Flat.Bigfoot;
|
||||
|
||||
table BenchmarkAsset
|
||||
{
|
||||
payload: [ubyte];
|
||||
refs: [HardReference] (native_inline, bigfoot_ref: "::Bigfoot::BenchmarkAssetReferred");
|
||||
}
|
||||
|
||||
root_type BenchmarkAsset;
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
/*********************************************************************
|
||||
* \file BenchmarkAsset.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHMARKASSET_HPP
|
||||
#define BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHMARKASSET_HPP
|
||||
#include <Engine/Asset/Asset.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct BenchmarkAssetTraits
|
||||
{
|
||||
using FLAT = ::Flat::Bigfoot::BenchmarkAsset;
|
||||
};
|
||||
|
||||
class BenchmarkAsset: public Asset<BenchmarkAssetTraits>
|
||||
{
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+7
@@ -0,0 +1,7 @@
|
||||
namespace Flat.Bigfoot;
|
||||
|
||||
table BenchmarkAssetReferred
|
||||
{
|
||||
}
|
||||
|
||||
root_type BenchmarkAssetReferred;
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
/*********************************************************************
|
||||
* \file BenchmarkAssetReferred.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHMARKASSETREFERRED_HPP
|
||||
#define BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHMARKASSETREFERRED_HPP
|
||||
#include <Engine/Asset/Asset.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct BenchmarkAssetReferredTraits
|
||||
{
|
||||
using FLAT = ::Flat::Bigfoot::BenchmarkAssetReferred;
|
||||
};
|
||||
|
||||
class BenchmarkAssetReferred: public Asset<BenchmarkAssetReferredTraits>
|
||||
{
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+172
@@ -0,0 +1,172 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_BENCHMARKASSETREFERRED_FLAT_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_BENCHMARKASSETREFERRED_FLAT_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
struct BenchmarkAssetReferred;
|
||||
struct BenchmarkAssetReferredBuilder;
|
||||
struct BenchmarkAssetReferredT;
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchmarkAssetReferredTypeTable();
|
||||
|
||||
struct BenchmarkAssetReferredT : public ::flatbuffers::NativeTable {
|
||||
typedef BenchmarkAssetReferred TableType;
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchmarkAssetReferredT";
|
||||
}
|
||||
};
|
||||
|
||||
struct BenchmarkAssetReferred FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef BenchmarkAssetReferredT NativeTableType;
|
||||
typedef BenchmarkAssetReferredBuilder Builder;
|
||||
struct Traits;
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return BenchmarkAssetReferredTypeTable();
|
||||
}
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchmarkAssetReferred";
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
BenchmarkAssetReferredT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(BenchmarkAssetReferredT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<BenchmarkAssetReferred> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetReferredT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct BenchmarkAssetReferredBuilder {
|
||||
typedef BenchmarkAssetReferred Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
explicit BenchmarkAssetReferredBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<BenchmarkAssetReferred> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<BenchmarkAssetReferred>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAssetReferred> CreateBenchmarkAssetReferred(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb) {
|
||||
BenchmarkAssetReferredBuilder builder_(_fbb);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BenchmarkAssetReferred::Traits {
|
||||
using type = BenchmarkAssetReferred;
|
||||
static auto constexpr Create = CreateBenchmarkAssetReferred;
|
||||
};
|
||||
|
||||
::flatbuffers::Offset<BenchmarkAssetReferred> CreateBenchmarkAssetReferred(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetReferredT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline BenchmarkAssetReferredT *BenchmarkAssetReferred::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<BenchmarkAssetReferredT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void BenchmarkAssetReferred::UnPackTo(BenchmarkAssetReferredT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAssetReferred> CreateBenchmarkAssetReferred(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetReferredT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return BenchmarkAssetReferred::Pack(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAssetReferred> BenchmarkAssetReferred::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetReferredT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BenchmarkAssetReferredT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
return Flat::Bigfoot::CreateBenchmarkAssetReferred(
|
||||
_fbb);
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchmarkAssetReferredTypeTable() {
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 0, nullptr, nullptr, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchmarkAssetReferred *GetBenchmarkAssetReferred(const void *buf) {
|
||||
return ::flatbuffers::GetRoot<Flat::Bigfoot::BenchmarkAssetReferred>(buf);
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchmarkAssetReferred *GetSizePrefixedBenchmarkAssetReferred(const void *buf) {
|
||||
return ::flatbuffers::GetSizePrefixedRoot<Flat::Bigfoot::BenchmarkAssetReferred>(buf);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifyBenchmarkAssetReferredBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifyBuffer<Flat::Bigfoot::BenchmarkAssetReferred>(nullptr);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifySizePrefixedBenchmarkAssetReferredBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifySizePrefixedBuffer<Flat::Bigfoot::BenchmarkAssetReferred>(nullptr);
|
||||
}
|
||||
|
||||
inline const char *BenchmarkAssetReferredExtension() {
|
||||
return "bfbs";
|
||||
}
|
||||
|
||||
inline void FinishBenchmarkAssetReferredBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchmarkAssetReferred> root) {
|
||||
fbb.Finish(root);
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedBenchmarkAssetReferredBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchmarkAssetReferred> root) {
|
||||
fbb.FinishSizePrefixed(root);
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetReferredT> UnPackBenchmarkAssetReferred(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetReferredT>(GetBenchmarkAssetReferred(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetReferredT> UnPackSizePrefixedBenchmarkAssetReferred(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetReferredT>(GetSizePrefixedBenchmarkAssetReferred(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_BENCHMARKASSETREFERRED_FLAT_BIGFOOT_H_
|
||||
+238
@@ -0,0 +1,238 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_BENCHMARKASSET_FLAT_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_BENCHMARKASSET_FLAT_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "System/UUID/UUID.hpp"
|
||||
#include "Engine/Asset/Reference.hpp"
|
||||
#include "Engine/Asset/Reference_generated.hpp"
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
struct BenchmarkAsset;
|
||||
struct BenchmarkAssetBuilder;
|
||||
struct BenchmarkAssetT;
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
namespace Bigfoot {
|
||||
class BenchmarkAssetReferred;
|
||||
} // namespace Bigfoot
|
||||
|
||||
namespace flatbuffers {
|
||||
Flat::Bigfoot::HardReference PackHardReferenceBenchmarkAssetReferred(const ::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred>& p_asset);
|
||||
::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred> UnPackHardReferenceBenchmarkAssetReferred(const Flat::Bigfoot::HardReference& p_asset);
|
||||
} // namespace flatbuffers
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchmarkAssetTypeTable();
|
||||
|
||||
struct BenchmarkAssetT : public ::flatbuffers::NativeTable {
|
||||
typedef BenchmarkAsset TableType;
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchmarkAssetT";
|
||||
}
|
||||
eastl::vector<uint8_t> payload{};
|
||||
eastl::vector<::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred>> refs{};
|
||||
};
|
||||
|
||||
struct BenchmarkAsset FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef BenchmarkAssetT NativeTableType;
|
||||
typedef BenchmarkAssetBuilder Builder;
|
||||
struct Traits;
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return BenchmarkAssetTypeTable();
|
||||
}
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchmarkAsset";
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
VT_PAYLOAD = 4,
|
||||
VT_REFS = 6
|
||||
};
|
||||
const ::flatbuffers::Vector<uint8_t> *payload() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
|
||||
}
|
||||
const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *refs() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<const Flat::Bigfoot::HardReference *> *>(VT_REFS);
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyOffset(verifier, VT_PAYLOAD) &&
|
||||
verifier.VerifyVector(payload()) &&
|
||||
VerifyOffset(verifier, VT_REFS) &&
|
||||
verifier.VerifyVector(refs()) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
BenchmarkAssetT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(BenchmarkAssetT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<BenchmarkAsset> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct BenchmarkAssetBuilder {
|
||||
typedef BenchmarkAsset Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload) {
|
||||
fbb_.AddOffset(BenchmarkAsset::VT_PAYLOAD, payload);
|
||||
}
|
||||
void add_refs(::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> refs) {
|
||||
fbb_.AddOffset(BenchmarkAsset::VT_REFS, refs);
|
||||
}
|
||||
explicit BenchmarkAssetBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<BenchmarkAsset> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<BenchmarkAsset>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAsset> CreateBenchmarkAsset(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload = 0,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<const Flat::Bigfoot::HardReference *>> refs = 0) {
|
||||
BenchmarkAssetBuilder builder_(_fbb);
|
||||
builder_.add_refs(refs);
|
||||
builder_.add_payload(payload);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BenchmarkAsset::Traits {
|
||||
using type = BenchmarkAsset;
|
||||
static auto constexpr Create = CreateBenchmarkAsset;
|
||||
};
|
||||
|
||||
::flatbuffers::Offset<BenchmarkAsset> CreateBenchmarkAsset(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline BenchmarkAssetT *BenchmarkAsset::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<BenchmarkAssetT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void BenchmarkAsset::UnPackTo(BenchmarkAssetT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = payload(); if (_e) { _o->payload.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->payload.begin()); } }
|
||||
{ auto _e = refs(); if (_e) { _o->refs.resize(_e->size()); for (::flatbuffers::uoffset_t _i = 0; _i < _e->size(); _i++) { _o->refs[_i] = ::flatbuffers::UnPackHardReferenceBenchmarkAssetReferred(*_e->Get(_i)); } } else { _o->refs.resize(0); } }
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAsset> CreateBenchmarkAsset(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return BenchmarkAsset::Pack(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchmarkAsset> BenchmarkAsset::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchmarkAssetT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BenchmarkAssetT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _payload = _fbb.CreateVector(_o->payload.data(), _o->payload.size());
|
||||
auto _refs = _fbb.CreateVectorOfNativeStructs<Flat::Bigfoot::HardReference, ::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred>>(_o->refs.data(), _o->refs.size(), ::flatbuffers::PackHardReferenceBenchmarkAssetReferred);
|
||||
return Flat::Bigfoot::CreateBenchmarkAsset(
|
||||
_fbb,
|
||||
_payload,
|
||||
_refs);
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchmarkAssetTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_UCHAR, 1, -1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 1, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Flat::Bigfoot::HardReferenceTypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 2, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchmarkAsset *GetBenchmarkAsset(const void *buf) {
|
||||
return ::flatbuffers::GetRoot<Flat::Bigfoot::BenchmarkAsset>(buf);
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchmarkAsset *GetSizePrefixedBenchmarkAsset(const void *buf) {
|
||||
return ::flatbuffers::GetSizePrefixedRoot<Flat::Bigfoot::BenchmarkAsset>(buf);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifyBenchmarkAssetBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifyBuffer<Flat::Bigfoot::BenchmarkAsset>(nullptr);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifySizePrefixedBenchmarkAssetBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifySizePrefixedBuffer<Flat::Bigfoot::BenchmarkAsset>(nullptr);
|
||||
}
|
||||
|
||||
inline const char *BenchmarkAssetExtension() {
|
||||
return "bfbs";
|
||||
}
|
||||
|
||||
inline void FinishBenchmarkAssetBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchmarkAsset> root) {
|
||||
fbb.Finish(root);
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedBenchmarkAssetBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchmarkAsset> root) {
|
||||
fbb.FinishSizePrefixed(root);
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetT> UnPackBenchmarkAsset(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetT>(GetBenchmarkAsset(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetT> UnPackSizePrefixedBenchmarkAsset(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchmarkAssetT>(GetSizePrefixedBenchmarkAsset(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
namespace flatbuffers {
|
||||
#ifndef FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHMARKASSETREFERRED
|
||||
#define FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHMARKASSETREFERRED
|
||||
inline Flat::Bigfoot::HardReference PackHardReferenceBenchmarkAssetReferred(const ::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred>& p_asset) { return {Pack(p_asset.GetUUID())}; }
|
||||
inline ::Bigfoot::HardReference<::Bigfoot::BenchmarkAssetReferred> UnPackHardReferenceBenchmarkAssetReferred(const Flat::Bigfoot::HardReference& p_asset) { return {UnPack(p_asset.uuid())}; }
|
||||
#endif // FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHMARKASSETREFERRED
|
||||
} // namespace flatbuffers
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_BENCHMARKASSET_FLAT_BIGFOOT_H_
|
||||
@@ -1,3 +1,5 @@
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/AssetsForBenchmarking)
|
||||
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Misc)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Graphics)
|
||||
|
||||
@@ -0,0 +1,175 @@
|
||||
/*********************************************************************
|
||||
* \file AssetContainer.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
namespace
|
||||
{
|
||||
using Random = effolkronium::random_static;
|
||||
} // namespace
|
||||
|
||||
class AssetContainerFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
[[nodiscard]]
|
||||
static eastl::vector<UUID> InsertRandomAssets(AssetContainer<BenchmarkAsset>& p_container,
|
||||
const std::uint32_t p_count)
|
||||
{
|
||||
eastl::vector<UUID> uuids;
|
||||
uuids.reserve(p_count);
|
||||
for (std::uint32_t i = 0; i < p_count; ++i)
|
||||
{
|
||||
uuids.push_back(p_container.Insert()->GetAsset()->GetHeader().uuid);
|
||||
}
|
||||
Random::shuffle(uuids);
|
||||
|
||||
return uuids;
|
||||
}
|
||||
|
||||
AssetContainer<BenchmarkAsset> m_container;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(AssetContainerFixture, Insert)(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
AssetContainer<BenchmarkAsset> container;
|
||||
for (std::uint32_t i = 0; i < count; ++i)
|
||||
{
|
||||
benchmark::DoNotOptimize(container.Insert());
|
||||
}
|
||||
benchmark::DoNotOptimize(container);
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(BenchmarkAsset)));
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(AssetContainerFixture, Insert)->Name("AssetContainer/Insert")->Arg(512)->Arg(8192)->Arg(131'072);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(AssetContainerFixture, Get)(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
const eastl::vector<UUID> uuids = InsertRandomAssets(m_container, count);
|
||||
|
||||
eastl::vector<ContainerHandle*> handles;
|
||||
handles.reserve(count);
|
||||
for (const UUID& uuid: uuids)
|
||||
{
|
||||
handles.push_back(m_container.AcquireContainerHandle(uuid));
|
||||
}
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
for (ContainerHandle* const handle: handles)
|
||||
{
|
||||
if (const auto* const asset = static_cast<const BenchmarkAsset*>(handle->GetAsset()))
|
||||
{
|
||||
sum += asset->GetHeader().type_id;
|
||||
}
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(AssetContainerFixture, Get)->Name("AssetContainer/Get")->Arg(512)->Arg(8192)->Arg(131'072);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(AssetContainerFixture, Has)(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
const eastl::vector<UUID> uuids = InsertRandomAssets(m_container, count);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
bool result = true;
|
||||
for (const UUID& uuid: uuids)
|
||||
{
|
||||
result = result && m_container.Has(uuid);
|
||||
}
|
||||
benchmark::DoNotOptimize(result);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(AssetContainerFixture, Has)->Name("AssetContainer/Has")->Arg(512)->Arg(8192)->Arg(131'072);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(AssetContainerFixture, AcquireContainerHandle)(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
const eastl::vector<UUID> uuids = InsertRandomAssets(m_container, count);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
for (const UUID& uuid: uuids)
|
||||
{
|
||||
sum += m_container.AcquireContainerHandle(uuid)->GetHardRefCount();
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(AssetContainerFixture, AcquireContainerHandle)
|
||||
->Name("AssetContainer/AcquireContainerHandle")
|
||||
->Arg(512)
|
||||
->Arg(8192)
|
||||
->Arg(131'072);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(AssetContainerFixture, Remove)(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
eastl::vector<UUID> uuids;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
uuids = InsertRandomAssets(m_container, count);
|
||||
state.ResumeTiming();
|
||||
|
||||
for (const UUID& uuid: uuids)
|
||||
{
|
||||
m_container.Remove(uuid);
|
||||
}
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(BenchmarkAsset)));
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(AssetContainerFixture, Remove)->Name("AssetContainer/Remove")->Arg(512)->Arg(8192)->Arg(131'072);
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,187 @@
|
||||
/*********************************************************************
|
||||
* \file Reference.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/Reference.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
|
||||
#include <EASTL/optional.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <cstddef>
|
||||
#include <utility>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
template<template<class> class REFERENCE>
|
||||
class ReferenceFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
using ReferenceType = REFERENCE<BenchmarkAsset>;
|
||||
|
||||
void SetUp(benchmark::State&) override
|
||||
{
|
||||
SetActiveAssetLibrary(&m_library);
|
||||
std::ignore = m_library.Insert(&m_container);
|
||||
|
||||
m_uuid = CreateAsset<BenchmarkAsset>()->GetHeader().uuid;
|
||||
m_reference.emplace(m_uuid);
|
||||
}
|
||||
|
||||
void TearDown(benchmark::State&) override
|
||||
{
|
||||
SetActiveAssetLibrary(g_assetLibrary);
|
||||
}
|
||||
|
||||
AssetLibrary m_library;
|
||||
AssetContainer<BenchmarkAsset> m_container;
|
||||
UUID m_uuid;
|
||||
eastl::optional<ReferenceType> m_reference;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, HardReferenceConstruct, HardReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
ReferenceType reference {m_uuid};
|
||||
benchmark::DoNotOptimize(reference);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, HardReferenceConstruct)->Name("Reference/HardReference/Construct");
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, SoftReferenceConstruct, SoftReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
ReferenceType reference {m_uuid};
|
||||
benchmark::DoNotOptimize(reference);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, SoftReferenceConstruct)->Name("Reference/SoftReference/Construct");
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, HardReferenceGet, HardReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(m_reference->Get());
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, HardReferenceGet)->Name("Reference/HardReference/Get");
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, SoftReferenceGet, SoftReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(m_reference->Get());
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, SoftReferenceGet)->Name("Reference/SoftReference/Get");
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, HardReferenceCopy, HardReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
ReferenceType copy {*m_reference};
|
||||
benchmark::DoNotOptimize(copy);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, HardReferenceCopy)->Name("Reference/HardReference/Copy");
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, SoftReferenceCopy, SoftReference)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
ReferenceType copy {*m_reference};
|
||||
benchmark::DoNotOptimize(copy);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, SoftReferenceCopy)->Name("Reference/SoftReference/Copy");
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, HardReferenceMove, HardReference)(benchmark::State& state)
|
||||
{
|
||||
constexpr std::size_t BATCH_SIZE = 128;
|
||||
eastl::vector<ReferenceType> batch;
|
||||
batch.reserve(BATCH_SIZE);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
batch.clear();
|
||||
for (std::size_t i = 0; i < BATCH_SIZE; ++i)
|
||||
{
|
||||
batch.emplace_back(m_uuid);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
|
||||
for (ReferenceType& reference: batch)
|
||||
{
|
||||
ReferenceType moved {std::move(reference)};
|
||||
benchmark::DoNotOptimize(moved);
|
||||
}
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * BATCH_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, HardReferenceMove)->Name("Reference/HardReference/Move");
|
||||
|
||||
BENCHMARK_TEMPLATE_DEFINE_F(ReferenceFixture, SoftReferenceMove, SoftReference)(benchmark::State& state)
|
||||
{
|
||||
constexpr std::size_t BATCH_SIZE = 128;
|
||||
eastl::vector<ReferenceType> batch;
|
||||
batch.reserve(BATCH_SIZE);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
batch.clear();
|
||||
for (std::size_t i = 0; i < BATCH_SIZE; ++i)
|
||||
{
|
||||
batch.emplace_back(m_uuid);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
|
||||
for (ReferenceType& reference: batch)
|
||||
{
|
||||
ReferenceType moved {std::move(reference)};
|
||||
benchmark::DoNotOptimize(moved);
|
||||
}
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * BATCH_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(ReferenceFixture, SoftReferenceMove)->Name("Reference/SoftReference/Move");
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,312 @@
|
||||
/*********************************************************************
|
||||
* \file BigFile.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/BigFile/BigFile.hpp>
|
||||
|
||||
#include <System/File/File.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>
|
||||
|
||||
#include <EngineBenchmarks/BigFileInfo_generated.hpp>
|
||||
|
||||
#include <EASTL/optional.h>
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
#ifdef BIGFOOT_TOOLMODE
|
||||
using Random = effolkronium::random_static;
|
||||
|
||||
class BigFileFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
static constexpr std::uint32_t ASSET_COUNT = 20'000;
|
||||
static constexpr std::uint32_t REFS_PER_ASSET = 4;
|
||||
static constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;
|
||||
|
||||
void SetUp([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
// The DB is populated exactly once for the entire benchmark process.
|
||||
// SetUp is called before every calibration round (Google Benchmark doubles
|
||||
// iteration counts until it reaches a stable measurement), so rebuilding
|
||||
// the DB each time would dominate the total benchmark time.
|
||||
m_uuids = BuildData();
|
||||
m_bigFile.emplace(File {BIGFILE_ENGINEBENCHMARKS_LOCATION});
|
||||
}
|
||||
|
||||
void TearDown([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
m_bigFile.reset();
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> RandomBatch(const std::size_t p_batchSize) const
|
||||
{
|
||||
eastl::vector<UUID> batch;
|
||||
batch.reserve(p_batchSize);
|
||||
for (std::size_t i = 0; i < p_batchSize; ++i)
|
||||
{
|
||||
batch.push_back(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
}
|
||||
|
||||
return batch;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<UUID>> RandomBatchPool(const std::size_t p_batchSize,
|
||||
const std::size_t p_poolSize) const
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> pool;
|
||||
pool.reserve(p_poolSize);
|
||||
for (std::size_t i = 0; i < p_poolSize; ++i)
|
||||
{
|
||||
pool.push_back(RandomBatch(p_batchSize));
|
||||
}
|
||||
|
||||
return pool;
|
||||
}
|
||||
|
||||
eastl::optional<BigFile> m_bigFile;
|
||||
eastl::span<const UUID> m_uuids;
|
||||
|
||||
private:
|
||||
static const eastl::vector<UUID>& BuildData()
|
||||
{
|
||||
static const eastl::vector<UUID> s_uuids = []()
|
||||
{
|
||||
eastl::vector<UUID> uuids;
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
uuids.reserve(ASSET_COUNT);
|
||||
flatbuffers.reserve(ASSET_COUNT);
|
||||
hardReferences.reserve(ASSET_COUNT);
|
||||
|
||||
for (std::uint32_t i = 0; i < ASSET_COUNT; ++i)
|
||||
{
|
||||
BenchmarkAsset asset;
|
||||
asset.SetName(asset.GetHeader().uuid.ToString());
|
||||
asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ASSET; ++j)
|
||||
{
|
||||
BenchmarkAssetReferred assetReferred;
|
||||
assetReferred.SetName(assetReferred.GetHeader().uuid.ToString());
|
||||
|
||||
asset.GetAsset().refs.emplace_back(assetReferred.GetHeader().uuid);
|
||||
}
|
||||
|
||||
eastl::vector<std::byte> flatbuffer = asset.Pack();
|
||||
hardReferences.push_back(asset.GetHardReferences(flatbuffer));
|
||||
flatbuffers.push_back(std::move(flatbuffer));
|
||||
uuids.push_back(asset.GetHeader().uuid);
|
||||
}
|
||||
|
||||
BigFile bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
|
||||
bigFile.Clear();
|
||||
bigFile.SaveAssetFlatbuffers(uuids, flatbuffers, hardReferences);
|
||||
|
||||
return uuids;
|
||||
}();
|
||||
|
||||
return s_uuids;
|
||||
}
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, GetAssetFlatbuffer)(benchmark::State& state)
|
||||
{
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
eastl::vector<std::byte> flatbuffer = m_bigFile->GetAssetFlatbuffer(
|
||||
m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
benchmark::DoNotOptimize(flatbuffer);
|
||||
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, GetAssetFlatbuffer)->Name("BigFile/GetAssetFlatbuffer")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, GetAssetFlatbuffers)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
|
||||
constexpr std::size_t BATCH_POOL_SIZE = 64;
|
||||
const eastl::vector<eastl::vector<UUID>> batchPool = RandomBatchPool(batchSize, BATCH_POOL_SIZE);
|
||||
|
||||
std::int64_t bytesProcessed = 0;
|
||||
std::size_t batchIndex = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers = m_bigFile->GetAssetFlatbuffers(batchPool[batchIndex]);
|
||||
benchmark::DoNotOptimize(flatbuffers);
|
||||
|
||||
for (const eastl::vector<std::byte>& flatbuffer: flatbuffers)
|
||||
{
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
}
|
||||
|
||||
batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, GetAssetFlatbuffers)
|
||||
->Name("BigFile/GetAssetFlatbuffers")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, GetAssetHardReferences)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(
|
||||
m_bigFile->GetAssetHardReferences(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]));
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * REFS_PER_ASSET * UUID::UUID_BYTE_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, GetAssetHardReferences)->Name("BigFile/GetAssetHardReferences")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, GetAssetsHardReferences)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
|
||||
constexpr std::size_t BATCH_POOL_SIZE = 64;
|
||||
const eastl::vector<eastl::vector<UUID>> batchPool = RandomBatchPool(batchSize, BATCH_POOL_SIZE);
|
||||
|
||||
std::size_t batchIndex = 0;
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(m_bigFile->GetAssetsHardReferences(batchPool[batchIndex]));
|
||||
batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * batchSize * REFS_PER_ASSET *
|
||||
UUID::UUID_BYTE_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, GetAssetsHardReferences)
|
||||
->Name("BigFile/GetAssetsHardReferences")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, SaveAssetFlatbuffer)(benchmark::State& state)
|
||||
{
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
BenchmarkAsset asset;
|
||||
asset.SetName(asset.GetHeader().uuid.ToString());
|
||||
asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ASSET; ++j)
|
||||
{
|
||||
asset.GetAsset().refs.emplace_back(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
}
|
||||
|
||||
const eastl::vector<std::byte> flatbuffer = asset.Pack();
|
||||
const eastl::vector<UUID> hardReferences = asset.GetHardReferences(flatbuffer);
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
state.ResumeTiming();
|
||||
|
||||
m_bigFile->SaveAssetFlatbuffer(asset.GetHeader().uuid, flatbuffer, hardReferences);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, SaveAssetFlatbuffer)->Name("BigFile/SaveAssetFlatbuffer")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(BigFileFixture, SaveAssetFlatbuffers)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
eastl::vector<UUID> uuids;
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
uuids.reserve(batchSize);
|
||||
flatbuffers.reserve(batchSize);
|
||||
hardReferences.reserve(batchSize);
|
||||
|
||||
for (std::size_t i = 0; i < batchSize; ++i)
|
||||
{
|
||||
BenchmarkAsset asset;
|
||||
asset.SetName(asset.GetHeader().uuid.ToString());
|
||||
asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ASSET; ++j)
|
||||
{
|
||||
asset.GetAsset().refs.emplace_back(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
}
|
||||
|
||||
eastl::vector<std::byte> flatbuffer = asset.Pack();
|
||||
uuids.push_back(asset.GetHeader().uuid);
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
hardReferences.push_back(asset.GetHardReferences(flatbuffer));
|
||||
flatbuffers.push_back(std::move(flatbuffer));
|
||||
}
|
||||
state.ResumeTiming();
|
||||
|
||||
m_bigFile->SaveAssetFlatbuffers(uuids, flatbuffers, hardReferences);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(BigFileFixture, SaveAssetFlatbuffers)
|
||||
->Name("BigFile/SaveAssetFlatbuffers")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
@@ -1,465 +0,0 @@
|
||||
/*********************************************************************
|
||||
* \file Sasquatch.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetLeaf.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetRoot.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/Asset/Reference.hpp>
|
||||
#include <Engine/Asset/SerializationManager.hpp>
|
||||
#include <Engine/BigFile/BigFile.hpp>
|
||||
#include <Engine/Sasquatch/Sasquatch.hpp>
|
||||
|
||||
#include <EngineBenchmarks/BigFileInfo_generated.hpp>
|
||||
|
||||
#include <System/File.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/string.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <cstring>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <optional>
|
||||
#include <random>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
// Tool-mode only: populates via SerializationManager::SaveAsset, which only exists in Tool mode (see
|
||||
// SerializationManager.hpp). Building EngineBenchmarks against BIGFOOT_GAME (see
|
||||
// SasquatchLoadAssets.cpp, in this same directory) compiles this file down to nothing.
|
||||
#if defined BIGFOOT_TOOL
|
||||
|
||||
// Compares the production BigFile/SQLite path against the production Sasquatch path, loading real
|
||||
// Asset<T> objects (see AssetsForBenchmarking) through the real AssetContainer/SerializationManager
|
||||
// pipeline - Pack()/Unpack(), HardReference resolution and all - at asset sizes big enough that per-asset
|
||||
// fixed overhead (hashing, SQL parsing, small allocations) stops dominating and storage throughput does.
|
||||
// Sasquatch_RawRead skips the AssetContainer/flatbuffers layer entirely to show the ceiling that layer
|
||||
// costs against - see the class comment on SerializationManager for why Sasquatch has no BigFile-style
|
||||
// prepared-statement-reuse concern (it's a single mmap, not a series of SQL round-trips).
|
||||
namespace Bigfoot
|
||||
{
|
||||
namespace
|
||||
{
|
||||
[[nodiscard]]
|
||||
eastl::string UniqueName(const UUID& p_uuid)
|
||||
{
|
||||
const std::string uuidString = p_uuid.ToString();
|
||||
return eastl::string {uuidString.data(), uuidString.size()};
|
||||
}
|
||||
|
||||
void ClearBigFile(BigFile& p_bigFile)
|
||||
{
|
||||
// Cascades to Asset/AssetHardReference/AssetSoftReference (see BigFileSchema.sql's ON DELETE CASCADE):
|
||||
// the fixture BigFile is shared and persistent across every Arg() this benchmark runs with, so each
|
||||
// run clears out whatever the previous one left behind. VACUUM reclaims the freed pages: without it,
|
||||
// repeated DELETE+repopulate cycles across every Arg()/repetition only ever grow the file, and query
|
||||
// planning cost on a several-hundred-MB file swamps everything else being measured.
|
||||
BigFile::Request deleteRequest {p_bigFile, "DELETE FROM AssetHeader;"};
|
||||
std::ignore = deleteRequest.Execute();
|
||||
|
||||
BigFile::Request vacuumRequest {p_bigFile, "VACUUM;"};
|
||||
std::ignore = vacuumRequest.Execute();
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
std::filesystem::path TempPath(const std::string_view p_name)
|
||||
{
|
||||
return std::filesystem::temp_directory_path() / p_name;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
File ToFile(const std::filesystem::path& p_path)
|
||||
{
|
||||
const std::string pathString = p_path.string();
|
||||
return File {eastl::string_view {pathString.c_str(), pathString.size()}};
|
||||
}
|
||||
|
||||
// Sums every 8 bytes of the payload, so the loop can't be optimized away and every byte actually gets
|
||||
// faulted in/read - a stride of 8 rather than 1 so the reduction itself stays cheap enough not to become
|
||||
// the bottleneck we're trying to measure around it.
|
||||
[[nodiscard]]
|
||||
std::uint64_t Touch(const eastl::span<const std::byte> p_bytes)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
|
||||
std::size_t i = 0;
|
||||
for (; i + sizeof(std::uint64_t) <= p_bytes.size(); i += sizeof(std::uint64_t))
|
||||
{
|
||||
std::uint64_t chunk;
|
||||
std::memcpy(&chunk, p_bytes.data() + i, sizeof(chunk));
|
||||
sum += chunk;
|
||||
}
|
||||
for (; i < p_bytes.size(); ++i)
|
||||
{
|
||||
sum += static_cast<std::uint8_t>(p_bytes[i]);
|
||||
}
|
||||
|
||||
return sum;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
std::uint64_t Touch(const eastl::vector<std::uint8_t>& p_payload)
|
||||
{
|
||||
return Touch(eastl::span<const std::byte> {reinterpret_cast<const std::byte*>(p_payload.data()),
|
||||
p_payload.size()});
|
||||
}
|
||||
|
||||
// Builds p_count BenchAssetRoot/BenchAssetLeaf pairs, each leaf carrying a p_payloadSize-byte payload, and
|
||||
// saves each one via SerializationManager::SaveAsset - the real Pack()/BigFile write path - then unloads
|
||||
// them (SaveAndUnload, same as Tests/Engine/Asset/SerializationManager.cpp's fixture) so the benchmarked
|
||||
// LoadAsset calls have real work to do instead of trivially finding everything already Has()-true.
|
||||
void PopulateAssets(SerializationManager& p_manager,
|
||||
AssetContainer<BenchAssetLeaf>& p_leafContainer,
|
||||
AssetContainer<BenchAssetRoot>& p_rootContainer,
|
||||
const std::uint32_t p_count,
|
||||
const std::size_t p_payloadSize,
|
||||
std::mt19937_64& p_rng,
|
||||
std::vector<UUID>& p_outRootUUIDs,
|
||||
std::vector<UUID>& p_outLeafUUIDs)
|
||||
{
|
||||
std::uniform_int_distribution<int> byteDist {0, 255};
|
||||
|
||||
p_outRootUUIDs.reserve(p_count);
|
||||
p_outLeafUUIDs.reserve(p_count);
|
||||
|
||||
for (std::uint32_t i = 0; i < p_count; ++i)
|
||||
{
|
||||
BenchAssetLeaf leaf;
|
||||
leaf.SetName(UniqueName(leaf.GetHeader().uuid));
|
||||
leaf.GetAsset().payload.resize(p_payloadSize);
|
||||
for (std::uint8_t& byte: leaf.GetAsset().payload)
|
||||
{
|
||||
byte = static_cast<std::uint8_t>(byteDist(p_rng));
|
||||
}
|
||||
const UUID leafUUID = leaf.GetHeader().uuid;
|
||||
std::ignore = p_leafContainer.Insert(std::move(leaf));
|
||||
p_manager.SaveAsset(leafUUID);
|
||||
p_leafContainer.Remove(leafUUID);
|
||||
|
||||
BenchAssetRoot root;
|
||||
root.SetName(UniqueName(root.GetHeader().uuid));
|
||||
root.GetAsset().leaf = HardReference<BenchAssetLeaf> {leafUUID};
|
||||
const UUID rootUUID = root.GetHeader().uuid;
|
||||
std::ignore = p_rootContainer.Insert(std::move(root));
|
||||
p_manager.SaveAsset(rootUUID);
|
||||
p_rootContainer.Remove(rootUUID);
|
||||
|
||||
p_outRootUUIDs.push_back(rootUUID);
|
||||
p_outLeafUUIDs.push_back(leafUUID);
|
||||
}
|
||||
}
|
||||
|
||||
// SerializationManager's LoadAsset body is picked at compile time by BIGFOOT_TOOL/BIGFOOT_GAME (see
|
||||
// SerializationManager.hpp): this benchmark binary is built Tool-mode, so only the BigFile-backed body
|
||||
// exists in it - there is no compiled Game-mode/Sasquatch LoadAsset to call here. This mirrors just enough
|
||||
// of it (no cycle guard: this fixture's data is a strict two-level root->leaf tree, never cyclic) to
|
||||
// exercise Sasquatch::Find() and AssetContainerBase::Insert() the same way a Game build would.
|
||||
void LoadFromSasquatch(Sasquatch& p_sasquatch, AssetLibrary& p_library, const UUID& p_uuid)
|
||||
{
|
||||
if (!p_uuid)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
const std::optional<Sasquatch::Entry> entry = p_sasquatch.Find(p_uuid);
|
||||
if (!entry.has_value())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
AssetContainerBase* container = p_library.GetAssetContainer(entry->m_typeID);
|
||||
if (container == nullptr || container->Has(p_uuid))
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
for (std::size_t offset = 0; offset < entry->m_hardReferenceUUIDs.size(); offset += UUID::UUID_BYTE_SIZE)
|
||||
{
|
||||
const eastl::span<const std::byte> uuidBytes = entry->m_hardReferenceUUIDs.subspan(offset, UUID::UUID_BYTE_SIZE);
|
||||
LoadFromSasquatch(
|
||||
p_sasquatch, p_library,
|
||||
UUID {std::span<const std::byte, UUID::UUID_BYTE_SIZE> {uuidBytes.data(), UUID::UUID_BYTE_SIZE}});
|
||||
}
|
||||
|
||||
container->Insert(entry->m_bytes);
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
std::uint64_t TouchLoadedRoot(AssetContainer<BenchAssetRoot>& p_rootContainer, const UUID& p_uuid)
|
||||
{
|
||||
const auto* root = static_cast<const BenchAssetRoot*>(p_rootContainer.AcquireContainerHandle(p_uuid)->GetAsset());
|
||||
if (root == nullptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const BenchAssetLeaf* leaf = root->GetAsset().leaf.Get();
|
||||
return leaf == nullptr ? 0 : Touch(leaf->GetAsset().payload);
|
||||
}
|
||||
|
||||
void RunBigFileBenchmark(benchmark::State& state, const bool p_shuffleLookupOrder)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
const auto payloadSize = static_cast<std::size_t>(state.range(1));
|
||||
|
||||
BigFile bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
|
||||
SerializationManager manager {bigFile};
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchAssetLeaf> leafContainer;
|
||||
AssetContainer<BenchAssetRoot> rootContainer;
|
||||
SetActiveAssetLibrary(&library);
|
||||
std::ignore = library.Insert(&leafContainer);
|
||||
std::ignore = library.Insert(&rootContainer);
|
||||
|
||||
ClearBigFile(bigFile);
|
||||
|
||||
std::mt19937_64 rng {0x5EEDULL};
|
||||
std::vector<UUID> rootUUIDs;
|
||||
std::vector<UUID> leafUUIDs;
|
||||
PopulateAssets(manager, leafContainer, rootContainer, count, payloadSize, rng, rootUUIDs, leafUUIDs);
|
||||
|
||||
std::vector<UUID> lookupOrder = rootUUIDs;
|
||||
if (p_shuffleLookupOrder)
|
||||
{
|
||||
std::shuffle(lookupOrder.begin(), lookupOrder.end(), rng);
|
||||
}
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
for (const UUID& uuid: lookupOrder)
|
||||
{
|
||||
manager.LoadAsset(uuid);
|
||||
sum += TouchLoadedRoot(rootContainer, uuid);
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
|
||||
state.PauseTiming();
|
||||
for (const UUID& uuid: rootUUIDs)
|
||||
{
|
||||
rootContainer.Remove(uuid);
|
||||
}
|
||||
for (const UUID& uuid: leafUUIDs)
|
||||
{
|
||||
leafContainer.Remove(uuid);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * lookupOrder.size());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * count * static_cast<std::int64_t>(payloadSize));
|
||||
|
||||
SetActiveAssetLibrary(&g_assetLibrary);
|
||||
}
|
||||
|
||||
void RunSasquatchBenchmark(benchmark::State& state, const bool p_shuffleLookupOrder)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
const auto payloadSize = static_cast<std::size_t>(state.range(1));
|
||||
const std::filesystem::path sasquatchPath = TempPath("BigfootAssetBench.sasquatch");
|
||||
|
||||
BigFile bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
|
||||
SerializationManager manager {bigFile};
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchAssetLeaf> leafContainer;
|
||||
AssetContainer<BenchAssetRoot> rootContainer;
|
||||
SetActiveAssetLibrary(&library);
|
||||
std::ignore = library.Insert(&leafContainer);
|
||||
std::ignore = library.Insert(&rootContainer);
|
||||
|
||||
ClearBigFile(bigFile);
|
||||
|
||||
std::mt19937_64 rng {0x5EEDULL};
|
||||
std::vector<UUID> rootUUIDs;
|
||||
std::vector<UUID> leafUUIDs;
|
||||
PopulateAssets(manager, leafContainer, rootContainer, count, payloadSize, rng, rootUUIDs, leafUUIDs);
|
||||
Sasquatch::WriteFrom(bigFile, ToFile(sasquatchPath));
|
||||
|
||||
std::vector<UUID> lookupOrder = rootUUIDs;
|
||||
if (p_shuffleLookupOrder)
|
||||
{
|
||||
std::shuffle(lookupOrder.begin(), lookupOrder.end(), rng);
|
||||
}
|
||||
|
||||
{
|
||||
Sasquatch sasquatch {ToFile(sasquatchPath)};
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
for (const UUID& uuid: lookupOrder)
|
||||
{
|
||||
LoadFromSasquatch(sasquatch, library, uuid);
|
||||
sum += TouchLoadedRoot(rootContainer, uuid);
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
|
||||
state.PauseTiming();
|
||||
for (const UUID& uuid: rootUUIDs)
|
||||
{
|
||||
rootContainer.Remove(uuid);
|
||||
}
|
||||
for (const UUID& uuid: leafUUIDs)
|
||||
{
|
||||
leafContainer.Remove(uuid);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * lookupOrder.size());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * count *
|
||||
static_cast<std::int64_t>(payloadSize));
|
||||
}
|
||||
|
||||
SetActiveAssetLibrary(&g_assetLibrary);
|
||||
std::filesystem::remove(sasquatchPath);
|
||||
}
|
||||
|
||||
// Bypasses AssetContainer/flatbuffers entirely: just Sasquatch::Find() (hash lookup into the index built
|
||||
// at construction) plus a direct read of the returned span. This is the ceiling the full pipeline above
|
||||
// (Unpack + HardReference resolution + AssetContainer::Insert) is measured against - the gap between the
|
||||
// two is exactly what that layer costs.
|
||||
void Sasquatch_RawRead(benchmark::State& state)
|
||||
{
|
||||
const auto count = static_cast<std::uint32_t>(state.range(0));
|
||||
const auto payloadSize = static_cast<std::size_t>(state.range(1));
|
||||
const std::filesystem::path sasquatchPath = TempPath("BigfootAssetBench.sasquatch");
|
||||
|
||||
BigFile bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
|
||||
SerializationManager manager {bigFile};
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchAssetLeaf> leafContainer;
|
||||
AssetContainer<BenchAssetRoot> rootContainer;
|
||||
SetActiveAssetLibrary(&library);
|
||||
std::ignore = library.Insert(&leafContainer);
|
||||
std::ignore = library.Insert(&rootContainer);
|
||||
|
||||
ClearBigFile(bigFile);
|
||||
|
||||
std::mt19937_64 rng {0x5EEDULL};
|
||||
std::vector<UUID> rootUUIDs;
|
||||
std::vector<UUID> leafUUIDs;
|
||||
PopulateAssets(manager, leafContainer, rootContainer, count, payloadSize, rng, rootUUIDs, leafUUIDs);
|
||||
Sasquatch::WriteFrom(bigFile, ToFile(sasquatchPath));
|
||||
|
||||
SetActiveAssetLibrary(&g_assetLibrary);
|
||||
|
||||
std::vector<UUID> lookupOrder = leafUUIDs;
|
||||
std::shuffle(lookupOrder.begin(), lookupOrder.end(), rng);
|
||||
|
||||
{
|
||||
Sasquatch sasquatch {ToFile(sasquatchPath)};
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
for (const UUID& uuid: lookupOrder)
|
||||
{
|
||||
if (const std::optional<Sasquatch::Entry> entry = sasquatch.Find(uuid))
|
||||
{
|
||||
sum += Touch(entry->m_bytes);
|
||||
}
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * lookupOrder.size());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * count *
|
||||
static_cast<std::int64_t>(payloadSize));
|
||||
}
|
||||
|
||||
std::filesystem::remove(sasquatchPath);
|
||||
}
|
||||
|
||||
void BigFile_RandomLookup(benchmark::State& state)
|
||||
{
|
||||
RunBigFileBenchmark(state, true);
|
||||
}
|
||||
|
||||
void BigFile_FullScan(benchmark::State& state)
|
||||
{
|
||||
RunBigFileBenchmark(state, false);
|
||||
}
|
||||
|
||||
void Sasquatch_RandomLookup(benchmark::State& state)
|
||||
{
|
||||
RunSasquatchBenchmark(state, true);
|
||||
}
|
||||
|
||||
void Sasquatch_FullScan(benchmark::State& state)
|
||||
{
|
||||
RunSasquatchBenchmark(state, false);
|
||||
}
|
||||
|
||||
// Not a real benchmark: writes a persistent .sasquatch file plus a manifest of its root/leaf UUID pairs
|
||||
// (one "root leaf" line per pair) to well-known temp paths, for
|
||||
// Benchmarks/Engine/BigFile/SasquatchLoadAssets.cpp's Game-mode-only LoadAsset/LoadAssets comparison to
|
||||
// read - Game mode never writes, so it can't produce its own fixture data or know the UUIDs without being
|
||||
// told. Run once via --benchmark_filter=GenerateLoadAssetsFixture before running that Game-mode build.
|
||||
void Sasquatch_GenerateLoadAssetsFixture(benchmark::State& state)
|
||||
{
|
||||
static constexpr std::uint32_t COUNT = 5'000;
|
||||
static constexpr std::size_t PAYLOAD_SIZE = 262'144;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
BigFile bigFile {File {BIGFILE_ENGINEBENCHMARKS_LOCATION}};
|
||||
SerializationManager manager {bigFile};
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchAssetLeaf> leafContainer;
|
||||
AssetContainer<BenchAssetRoot> rootContainer;
|
||||
SetActiveAssetLibrary(&library);
|
||||
std::ignore = library.Insert(&leafContainer);
|
||||
std::ignore = library.Insert(&rootContainer);
|
||||
|
||||
ClearBigFile(bigFile);
|
||||
|
||||
std::mt19937_64 rng {0x5EEDULL};
|
||||
std::vector<UUID> rootUUIDs;
|
||||
std::vector<UUID> leafUUIDs;
|
||||
PopulateAssets(manager, leafContainer, rootContainer, COUNT, PAYLOAD_SIZE, rng, rootUUIDs, leafUUIDs);
|
||||
|
||||
Sasquatch::WriteFrom(bigFile, ToFile(TempPath("BigfootLoadAssetsFixture.sasquatch")));
|
||||
|
||||
std::ofstream manifest {TempPath("BigfootLoadAssetsFixture.manifest")};
|
||||
for (std::size_t i = 0; i < rootUUIDs.size(); ++i)
|
||||
{
|
||||
manifest << rootUUIDs[i].ToString() << ' ' << leafUUIDs[i].ToString() << '\n';
|
||||
}
|
||||
|
||||
SetActiveAssetLibrary(&g_assetLibrary);
|
||||
}
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// {count, payloadSize} - total data volume kept in the low hundreds of MB so population (real,
|
||||
// transactional SaveAsset calls on the BigFile side) stays fast: 2000x64KiB=128MiB, 200x1MiB=200MiB,
|
||||
// 20x16MiB=320MiB. Small-to-large so per-asset fixed overhead's share of the total is visible shrinking.
|
||||
#define BIGFOOT_ASSET_SIZE_ARGS \
|
||||
Args({2'000, 65'536})->Args({200, 1'048'576})->Args({20, 16'777'216})
|
||||
|
||||
BENCHMARK(BigFile_RandomLookup)->Name("BigFile/RandomLookup")->BIGFOOT_ASSET_SIZE_ARGS;
|
||||
BENCHMARK(Sasquatch_RandomLookup)->Name("Sasquatch/RandomLookup")->BIGFOOT_ASSET_SIZE_ARGS;
|
||||
BENCHMARK(BigFile_FullScan)->Name("BigFile/FullScan")->BIGFOOT_ASSET_SIZE_ARGS;
|
||||
BENCHMARK(Sasquatch_FullScan)->Name("Sasquatch/FullScan")->BIGFOOT_ASSET_SIZE_ARGS;
|
||||
BENCHMARK(Sasquatch_RawRead)->Name("Sasquatch/RawRead")->BIGFOOT_ASSET_SIZE_ARGS;
|
||||
BENCHMARK(Sasquatch_GenerateLoadAssetsFixture)->Name("GenerateLoadAssetsFixture")->Iterations(1);
|
||||
|
||||
#undef BIGFOOT_ASSET_SIZE_ARGS
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
@@ -1,182 +0,0 @@
|
||||
/*********************************************************************
|
||||
* \file SasquatchLoadAssets.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#if !defined BIGFOOT_TOOL
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetLeaf.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetRoot.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/Asset/SerializationManager.hpp>
|
||||
#include <Engine/EngineAssertHandler.hpp>
|
||||
#include <Engine/Sasquatch/Sasquatch.hpp>
|
||||
|
||||
#include <System/File.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
#include <cstdint>
|
||||
#include <filesystem>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <tuple>
|
||||
#include <vector>
|
||||
|
||||
// Game-mode-only: compares the existing, single-threaded LoadAsset (called once per root, in a loop)
|
||||
// against the new, parallel-decode LoadAssets (one call, the whole batch) - see SerializationManager -
|
||||
// against real Asset<T> objects. Reads the fixture Sasquatch_GenerateLoadAssetsFixture (Tool mode, see
|
||||
// Sasquatch.cpp in this directory) writes out, since a Game build never saves and so can't produce its
|
||||
// own: run that once first via a Tool-mode EngineBenchmarks build.
|
||||
namespace Bigfoot
|
||||
{
|
||||
namespace
|
||||
{
|
||||
[[nodiscard]]
|
||||
File ToFile(const std::filesystem::path& p_path)
|
||||
{
|
||||
const std::string pathString = p_path.string();
|
||||
return File {eastl::string_view {pathString.c_str(), pathString.size()}};
|
||||
}
|
||||
|
||||
struct ManifestEntry
|
||||
{
|
||||
UUID m_root;
|
||||
UUID m_leaf;
|
||||
};
|
||||
|
||||
[[nodiscard]]
|
||||
std::vector<ManifestEntry> ReadManifest()
|
||||
{
|
||||
const std::filesystem::path path = std::filesystem::temp_directory_path() / "BigfootLoadAssetsFixture.manifest";
|
||||
std::ifstream manifest {path};
|
||||
CRITICAL_ASSERT(EngineAssertHandler, manifest.is_open(),
|
||||
"Missing LoadAssets fixture manifest at {} - run "
|
||||
"EngineBenchmarks --benchmark_filter=GenerateLoadAssetsFixture from a Tool-mode build first",
|
||||
path.string());
|
||||
|
||||
std::vector<ManifestEntry> entries;
|
||||
std::string rootString;
|
||||
std::string leafString;
|
||||
while (manifest >> rootString >> leafString)
|
||||
{
|
||||
entries.push_back({UUID {rootString}, UUID {leafString}});
|
||||
}
|
||||
return entries;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
std::uint64_t Touch(const eastl::vector<std::uint8_t>& p_payload)
|
||||
{
|
||||
return p_payload.empty() ? 0 : p_payload.back();
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
std::uint64_t TouchLoadedRoot(AssetContainer<BenchAssetRoot>& p_rootContainer, const UUID& p_uuid)
|
||||
{
|
||||
const auto* root = static_cast<const BenchAssetRoot*>(p_rootContainer.AcquireContainerHandle(p_uuid)->GetAsset());
|
||||
if (root == nullptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
const BenchAssetLeaf* leaf = root->GetAsset().leaf.Get();
|
||||
return leaf == nullptr ? 0 : Touch(leaf->GetAsset().payload);
|
||||
}
|
||||
|
||||
void RunLoadAssetsBenchmark(benchmark::State& state, const bool p_parallel)
|
||||
{
|
||||
Sasquatch sasquatch {ToFile(std::filesystem::temp_directory_path() / "BigfootLoadAssetsFixture.sasquatch")};
|
||||
const std::vector<ManifestEntry> manifest = ReadManifest();
|
||||
|
||||
SerializationManager manager {sasquatch};
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchAssetLeaf> leafContainer;
|
||||
AssetContainer<BenchAssetRoot> rootContainer;
|
||||
SetActiveAssetLibrary(&library);
|
||||
std::ignore = library.Insert(&leafContainer);
|
||||
std::ignore = library.Insert(&rootContainer);
|
||||
|
||||
eastl::vector<UUID> rootUUIDs;
|
||||
rootUUIDs.reserve(manifest.size());
|
||||
for (const ManifestEntry& entry: manifest)
|
||||
{
|
||||
rootUUIDs.push_back(entry.m_root);
|
||||
}
|
||||
|
||||
std::uintmax_t totalBytes = 0;
|
||||
for (const ManifestEntry& entry: manifest)
|
||||
{
|
||||
if (const std::optional<Sasquatch::Entry> leaf = sasquatch.Find(entry.m_leaf))
|
||||
{
|
||||
totalBytes += leaf->m_bytes.size();
|
||||
}
|
||||
}
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
std::uint64_t sum = 0;
|
||||
|
||||
if (p_parallel)
|
||||
{
|
||||
manager.LoadAssets(eastl::span<const UUID> {rootUUIDs.data(), rootUUIDs.size()});
|
||||
for (const UUID& uuid: rootUUIDs)
|
||||
{
|
||||
sum += TouchLoadedRoot(rootContainer, uuid);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
for (const UUID& uuid: rootUUIDs)
|
||||
{
|
||||
manager.LoadAsset(uuid);
|
||||
sum += TouchLoadedRoot(rootContainer, uuid);
|
||||
}
|
||||
}
|
||||
benchmark::DoNotOptimize(sum);
|
||||
|
||||
state.PauseTiming();
|
||||
for (const ManifestEntry& entry: manifest)
|
||||
{
|
||||
rootContainer.Remove(entry.m_root);
|
||||
leafContainer.Remove(entry.m_leaf);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * manifest.size());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * static_cast<std::int64_t>(totalBytes));
|
||||
|
||||
SetActiveAssetLibrary(&g_assetLibrary);
|
||||
}
|
||||
|
||||
void Sasquatch_LoadAsset_Sequential(benchmark::State& state)
|
||||
{
|
||||
RunLoadAssetsBenchmark(state, false);
|
||||
}
|
||||
|
||||
void Sasquatch_LoadAssets_Parallel(benchmark::State& state)
|
||||
{
|
||||
RunLoadAssetsBenchmark(state, true);
|
||||
}
|
||||
} // namespace
|
||||
|
||||
// UseRealTime(): LoadAssets does its decoding on worker threads, not the calling one, so the default CPU-
|
||||
// time measurement (which only counts the calling thread) would wildly understate the real cost - wall
|
||||
// time is what actually matters for "how long until these assets are usable."
|
||||
BENCHMARK(Sasquatch_LoadAsset_Sequential)
|
||||
->Name("Sasquatch/LoadAsset_Sequential")
|
||||
->Unit(benchmark::kMillisecond)
|
||||
->UseRealTime();
|
||||
BENCHMARK(Sasquatch_LoadAssets_Parallel)
|
||||
->Name("Sasquatch/LoadAssets_Parallel")
|
||||
->Unit(benchmark::kMillisecond)
|
||||
->UseRealTime();
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
@@ -2,10 +2,13 @@ get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName}Benchmarks)
|
||||
|
||||
bigfoot_create_package_benchmarks(
|
||||
"")
|
||||
"Bigfoot/Benchmarks")
|
||||
|
||||
target_link_libraries(${PROJECT_NAME}
|
||||
PRIVATE
|
||||
effolkronium_random
|
||||
$<LINK_LIBRARY:WHOLE_ARCHIVE,AssetsForBenchmarking>)
|
||||
|
||||
bigfoot_create_bigfile("Benchmarks/Bigfoot")
|
||||
bigfoot_create_bigfile("Bigfoot/Benchmarks")
|
||||
|
||||
bigfoot_create_sasquatch_info()
|
||||
|
||||
@@ -9,11 +9,14 @@
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
* BigFile location
|
||||
*/
|
||||
constexpr eastl::string_view BIGFILE_ENGINEBENCHMARKS_LOCATION {"./EngineBenchmarks-bigfile.db"};
|
||||
constexpr eastl::string_view BIGFILE_ENGINEBENCHMARKS_LOCATION {"./EngineBenchmarks.db"};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,22 @@
|
||||
// AUTO-GENERATED DO NOT TOUCH
|
||||
|
||||
/*********************************************************************
|
||||
* \file SasquatchInfo.generated.hpp
|
||||
*
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINEBENCHMARKS_SASQUATCHINFO_GENERATED_HPP
|
||||
#define BIGFOOT_ENGINEBENCHMARKS_SASQUATCHINFO_GENERATED_HPP
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
|
||||
#if defined BIGFOOT_GAME
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
* Sasquatch location
|
||||
*/
|
||||
constexpr eastl::string_view SASQUATCH_ENGINEBENCHMARKS_LOCATION {"./EngineBenchmarks.sasquatch"};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,245 @@
|
||||
/*********************************************************************
|
||||
* \file Sasquatch.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Sasquatch/Sasquatch.hpp>
|
||||
|
||||
#include <System/File/File.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>
|
||||
|
||||
#include <EngineBenchmarks/SasquatchInfo_generated.hpp>
|
||||
|
||||
#include <EASTL/optional.h>
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
#ifdef BIGFOOT_GAME
|
||||
using Random = effolkronium::random_static;
|
||||
|
||||
class SasquatchFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
static constexpr std::uint32_t ASSET_COUNT = 20'000;
|
||||
static constexpr std::uint32_t REFS_PER_ASSET = 4;
|
||||
static constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;
|
||||
|
||||
void SetUp([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
// The Sasquatch file is built exactly once for the entire benchmark process.
|
||||
// SetUp is called before every calibration round (Google Benchmark doubles
|
||||
// iteration counts until it reaches a stable measurement), so rebuilding
|
||||
// the file each time would dominate the total benchmark time.
|
||||
m_uuids = BuildData();
|
||||
m_sasquatch.emplace(File {SASQUATCH_ENGINEBENCHMARKS_LOCATION});
|
||||
}
|
||||
|
||||
void TearDown([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
m_sasquatch.reset();
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> RandomBatch(const std::size_t p_batchSize) const
|
||||
{
|
||||
eastl::vector<UUID> batch;
|
||||
batch.reserve(p_batchSize);
|
||||
for (std::size_t i = 0; i < p_batchSize; ++i)
|
||||
{
|
||||
batch.push_back(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
}
|
||||
|
||||
return batch;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<UUID>> RandomBatchPool(const std::size_t p_batchSize,
|
||||
const std::size_t p_poolSize) const
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> pool;
|
||||
pool.reserve(p_poolSize);
|
||||
for (std::size_t i = 0; i < p_poolSize; ++i)
|
||||
{
|
||||
pool.push_back(RandomBatch(p_batchSize));
|
||||
}
|
||||
|
||||
return pool;
|
||||
}
|
||||
|
||||
eastl::optional<Sasquatch> m_sasquatch;
|
||||
eastl::span<const UUID> m_uuids;
|
||||
|
||||
private:
|
||||
static const eastl::vector<UUID>& BuildData()
|
||||
{
|
||||
static const eastl::vector<UUID> s_uuids = []()
|
||||
{
|
||||
File {SASQUATCH_ENGINEBENCHMARKS_LOCATION}.Delete();
|
||||
|
||||
eastl::vector<UUID> uuids;
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
uuids.reserve(ASSET_COUNT);
|
||||
flatbuffers.reserve(ASSET_COUNT);
|
||||
hardReferences.reserve(ASSET_COUNT);
|
||||
|
||||
for (std::uint32_t i = 0; i < ASSET_COUNT; ++i)
|
||||
{
|
||||
BenchmarkAsset asset;
|
||||
asset.SetName(asset.GetHeader().uuid.ToString());
|
||||
asset.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ASSET; ++j)
|
||||
{
|
||||
BenchmarkAssetReferred assetReferred;
|
||||
assetReferred.SetName(assetReferred.GetHeader().uuid.ToString());
|
||||
|
||||
asset.GetAsset().refs.emplace_back(assetReferred.GetHeader().uuid);
|
||||
}
|
||||
|
||||
eastl::vector<std::byte> flatbuffer = asset.Pack();
|
||||
hardReferences.push_back(asset.GetHardReferences(flatbuffer));
|
||||
flatbuffers.push_back(std::move(flatbuffer));
|
||||
uuids.push_back(asset.GetHeader().uuid);
|
||||
}
|
||||
|
||||
std::size_t totalFlatbufferBytes = 0;
|
||||
std::size_t totalHardReferencesBytes = 0;
|
||||
for (std::size_t i = 0; i < uuids.size(); ++i)
|
||||
{
|
||||
totalFlatbufferBytes += flatbuffers[i].size();
|
||||
totalHardReferencesBytes += hardReferences[i].size() * UUID::UUID_BYTE_SIZE;
|
||||
}
|
||||
|
||||
SasquatchWriter writer {File {SASQUATCH_ENGINEBENCHMARKS_LOCATION},
|
||||
uuids.size(),
|
||||
totalFlatbufferBytes,
|
||||
totalHardReferencesBytes};
|
||||
for (std::size_t i = 0; i < uuids.size(); ++i)
|
||||
{
|
||||
writer.WriteAsset(uuids[i], flatbuffers[i], hardReferences[i]);
|
||||
}
|
||||
|
||||
return uuids;
|
||||
}();
|
||||
|
||||
return s_uuids;
|
||||
}
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SasquatchFixture, GetAssetHardReferences)(benchmark::State& state)
|
||||
{
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(
|
||||
m_sasquatch->GetAssetHardReferences(m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]));
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * REFS_PER_ASSET * UUID::UUID_BYTE_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetHardReferences)->Name("Sasquatch/GetAssetHardReferences")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SasquatchFixture, GetAssetsHardReferences)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
|
||||
constexpr std::size_t BATCH_POOL_SIZE = 64;
|
||||
const eastl::vector<eastl::vector<UUID>> batchPool = RandomBatchPool(batchSize, BATCH_POOL_SIZE);
|
||||
|
||||
std::size_t batchIndex = 0;
|
||||
for (auto _: state)
|
||||
{
|
||||
benchmark::DoNotOptimize(m_sasquatch->GetAssetsHardReferences(batchPool[batchIndex]));
|
||||
batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations()) * batchSize * REFS_PER_ASSET *
|
||||
UUID::UUID_BYTE_SIZE);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetsHardReferences)
|
||||
->Name("Sasquatch/GetAssetsHardReferences")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SasquatchFixture, GetAssetFlatbuffer)(benchmark::State& state)
|
||||
{
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
eastl::vector<std::byte> flatbuffer = m_sasquatch->GetAssetFlatbuffer(
|
||||
m_uuids[Random::get<std::size_t>(0, m_uuids.size() - 1)]);
|
||||
benchmark::DoNotOptimize(flatbuffer);
|
||||
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetFlatbuffer)->Name("Sasquatch/GetAssetFlatbuffer")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SasquatchFixture, GetAssetFlatbuffers)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
|
||||
constexpr std::size_t BATCH_POOL_SIZE = 64;
|
||||
const eastl::vector<eastl::vector<UUID>> batchPool = RandomBatchPool(batchSize, BATCH_POOL_SIZE);
|
||||
|
||||
std::int64_t bytesProcessed = 0;
|
||||
std::size_t batchIndex = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers = m_sasquatch->GetAssetFlatbuffers(batchPool[batchIndex]);
|
||||
benchmark::DoNotOptimize(flatbuffers);
|
||||
|
||||
for (const eastl::vector<std::byte>& flatbuffer: flatbuffers)
|
||||
{
|
||||
bytesProcessed += static_cast<std::int64_t>(flatbuffer.size());
|
||||
}
|
||||
|
||||
batchIndex = (batchIndex + 1) % BATCH_POOL_SIZE;
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SasquatchFixture, GetAssetFlatbuffers)
|
||||
->Name("Sasquatch/GetAssetFlatbuffers")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,391 @@
|
||||
/*********************************************************************
|
||||
* \file SerializationManager.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/SerializationManager/SerializationManager.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/DataAccessor/DataAccessor.hpp>
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
#include <Engine/BigFile/BigFile.hpp>
|
||||
|
||||
#include <EngineBenchmarks/BigFileInfo_generated.hpp>
|
||||
#elif defined BIGFOOT_GAME
|
||||
#include <Engine/Sasquatch/Sasquatch.hpp>
|
||||
|
||||
#include <EngineBenchmarks/SasquatchInfo_generated.hpp>
|
||||
#endif
|
||||
|
||||
#include <System/File/File.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAsset.hpp>
|
||||
#include <AssetsForBenchmarking/Asset/BenchmarkAssetReferred.hpp>
|
||||
|
||||
#include <EASTL/optional.h>
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <tuple>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
using Random = effolkronium::random_static;
|
||||
|
||||
class SerializationManagerFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
static constexpr std::uint32_t ROOT_ASSET_COUNT = 20'000;
|
||||
static constexpr std::uint32_t REFS_PER_ROOT = 4;
|
||||
static constexpr std::size_t ASSET_PAYLOAD_SIZE = 256;
|
||||
|
||||
void SetUp([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
m_previousDataAccessor = g_dataAccessor;
|
||||
m_previousAssetLibrary = g_activeAssetLibrary;
|
||||
|
||||
// The data store is populated exactly once for the entire benchmark process.
|
||||
// SetUp is called before every calibration round (Google Benchmark doubles
|
||||
// iteration counts until it reaches a stable measurement), so rebuilding
|
||||
// the data store each time would dominate the total benchmark time.
|
||||
static const SharedData& s_data = BuildData();
|
||||
m_rootUuids = s_data.rootUuids;
|
||||
m_leafUuids = s_data.leafUuids;
|
||||
m_rootTotalBytes = &s_data.rootTotalBytes;
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
m_bigFile.emplace(File {BIGFILE_ENGINEBENCHMARKS_LOCATION});
|
||||
SetDataAccessor(&*m_bigFile);
|
||||
#elif defined BIGFOOT_GAME
|
||||
m_sasquatch.emplace(File {SASQUATCH_ENGINEBENCHMARKS_LOCATION});
|
||||
SetDataAccessor(&*m_sasquatch);
|
||||
#endif
|
||||
}
|
||||
|
||||
void TearDown([[maybe_unused]] benchmark::State& p_state) override
|
||||
{
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
m_bigFile.reset();
|
||||
#elif defined BIGFOOT_GAME
|
||||
m_sasquatch.reset();
|
||||
#endif
|
||||
SetDataAccessor(m_previousDataAccessor);
|
||||
SetActiveAssetLibrary(m_previousAssetLibrary);
|
||||
}
|
||||
|
||||
/*
|
||||
* Registers a fresh, empty AssetLibrary as the active one, so that every root and leaf asset appears unloaded
|
||||
*
|
||||
* \param p_library The library to register
|
||||
* \param p_leafContainer The container to register leaves into
|
||||
* \param p_rootContainer The container to register roots into
|
||||
*/
|
||||
static void ResetActiveLibrary(AssetLibrary& p_library,
|
||||
AssetContainer<BenchmarkAssetReferred>& p_leafContainer,
|
||||
AssetContainer<BenchmarkAsset>& p_rootContainer)
|
||||
{
|
||||
std::ignore = p_library.Insert(&p_leafContainer);
|
||||
std::ignore = p_library.Insert(&p_rootContainer);
|
||||
SetActiveAssetLibrary(&p_library);
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> RandomRootBatch(const std::size_t p_batchSize) const
|
||||
{
|
||||
eastl::vector<UUID> batch;
|
||||
batch.reserve(p_batchSize);
|
||||
for (std::size_t i = 0; i < p_batchSize; ++i)
|
||||
{
|
||||
batch.push_back(m_rootUuids[Random::get<std::size_t>(0, m_rootUuids.size() - 1)]);
|
||||
}
|
||||
|
||||
return batch;
|
||||
}
|
||||
|
||||
/*
|
||||
* Total flatbuffer bytes (root + its leaves) that loading p_roots will actually read, deduplicated the same way
|
||||
* SerializationManager::LoadAssets deduplicates its own transitive discovery
|
||||
*
|
||||
* \param p_roots The root assets that would be loaded
|
||||
* \return The total flatbuffer bytes across the unique roots
|
||||
*/
|
||||
[[nodiscard]]
|
||||
std::int64_t TotalBytes(const eastl::vector<UUID>& p_roots) const
|
||||
{
|
||||
ankerl::unordered_dense::set<UUID> unique;
|
||||
unique.reserve(p_roots.size());
|
||||
for (const UUID& uuid: p_roots)
|
||||
{
|
||||
unique.insert(uuid);
|
||||
}
|
||||
|
||||
std::int64_t bytes = 0;
|
||||
for (const UUID& uuid: unique)
|
||||
{
|
||||
bytes += static_cast<std::int64_t>(m_rootTotalBytes->at(uuid));
|
||||
}
|
||||
|
||||
return bytes;
|
||||
}
|
||||
|
||||
DataAccessor* m_previousDataAccessor = nullptr;
|
||||
AssetLibrary* m_previousAssetLibrary = nullptr;
|
||||
|
||||
eastl::span<const UUID> m_rootUuids;
|
||||
eastl::span<const UUID> m_leafUuids;
|
||||
const ankerl::unordered_dense::map<UUID, std::size_t>* m_rootTotalBytes = nullptr;
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
eastl::optional<BigFile> m_bigFile;
|
||||
#elif defined BIGFOOT_GAME
|
||||
eastl::optional<Sasquatch> m_sasquatch;
|
||||
#endif
|
||||
|
||||
private:
|
||||
struct SharedData
|
||||
{
|
||||
eastl::vector<UUID> rootUuids;
|
||||
eastl::vector<UUID> leafUuids;
|
||||
ankerl::unordered_dense::map<UUID, std::size_t> rootTotalBytes;
|
||||
};
|
||||
|
||||
static const SharedData& BuildData()
|
||||
{
|
||||
static const SharedData s_data = []()
|
||||
{
|
||||
SharedData data;
|
||||
data.rootUuids.reserve(ROOT_ASSET_COUNT);
|
||||
data.leafUuids.reserve(ROOT_ASSET_COUNT * REFS_PER_ROOT);
|
||||
data.rootTotalBytes.reserve(ROOT_ASSET_COUNT);
|
||||
|
||||
eastl::vector<UUID> uuids;
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
uuids.reserve(ROOT_ASSET_COUNT * (1 + REFS_PER_ROOT));
|
||||
flatbuffers.reserve(uuids.capacity());
|
||||
hardReferences.reserve(uuids.capacity());
|
||||
|
||||
for (std::uint32_t i = 0; i < ROOT_ASSET_COUNT; ++i)
|
||||
{
|
||||
BenchmarkAsset root;
|
||||
root.SetName(root.GetHeader().uuid.ToString());
|
||||
root.GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
|
||||
std::size_t totalBytes = 0;
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ROOT; ++j)
|
||||
{
|
||||
BenchmarkAssetReferred leaf;
|
||||
leaf.SetName(leaf.GetHeader().uuid.ToString());
|
||||
|
||||
root.GetAsset().refs.emplace_back(leaf.GetHeader().uuid);
|
||||
|
||||
eastl::vector<std::byte> leafFlatbuffer = leaf.Pack();
|
||||
totalBytes += leafFlatbuffer.size();
|
||||
data.leafUuids.push_back(leaf.GetHeader().uuid);
|
||||
uuids.push_back(leaf.GetHeader().uuid);
|
||||
hardReferences.push_back(leaf.GetHardReferences(leafFlatbuffer));
|
||||
flatbuffers.push_back(std::move(leafFlatbuffer));
|
||||
}
|
||||
|
||||
eastl::vector<std::byte> rootFlatbuffer = root.Pack();
|
||||
totalBytes += rootFlatbuffer.size();
|
||||
data.rootTotalBytes.emplace(root.GetHeader().uuid, totalBytes);
|
||||
data.rootUuids.push_back(root.GetHeader().uuid);
|
||||
uuids.push_back(root.GetHeader().uuid);
|
||||
hardReferences.push_back(root.GetHardReferences(rootFlatbuffer));
|
||||
flatbuffers.push_back(std::move(rootFlatbuffer));
|
||||
}
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
BigFile bigFile {File { BIGFILE_ENGINEBENCHMARKS_LOCATION }};
|
||||
bigFile.Clear();
|
||||
bigFile.SaveAssetFlatbuffers(uuids, flatbuffers, hardReferences);
|
||||
#elif defined BIGFOOT_GAME
|
||||
std::size_t totalFlatbufferBytes = 0;
|
||||
std::size_t totalHardReferencesBytes = 0;
|
||||
for (std::size_t i = 0; i < uuids.size(); ++i)
|
||||
{
|
||||
totalFlatbufferBytes += flatbuffers[i].size();
|
||||
totalHardReferencesBytes += hardReferences[i].size() * UUID::UUID_BYTE_SIZE;
|
||||
}
|
||||
|
||||
File {SASQUATCH_ENGINEBENCHMARKS_LOCATION}.Delete();
|
||||
SasquatchWriter writer {File {SASQUATCH_ENGINEBENCHMARKS_LOCATION},
|
||||
uuids.size(),
|
||||
totalFlatbufferBytes,
|
||||
totalHardReferencesBytes};
|
||||
for (std::size_t i = 0; i < uuids.size(); ++i)
|
||||
{
|
||||
writer.WriteAsset(uuids[i], flatbuffers[i], hardReferences[i]);
|
||||
}
|
||||
#endif
|
||||
|
||||
return data;
|
||||
}();
|
||||
|
||||
return s_data;
|
||||
}
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SerializationManagerFixture, LoadAsset)(benchmark::State& state)
|
||||
{
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
AssetLibrary library;
|
||||
// leafContainer must outlive rootContainer: the loaded root's HardReferences release into leafContainer's
|
||||
// handles on destruction, so declaring it second would tear it down first and use-after-free those handles.
|
||||
AssetContainer<BenchmarkAssetReferred> leafContainer;
|
||||
AssetContainer<BenchmarkAsset> rootContainer;
|
||||
ResetActiveLibrary(library, leafContainer, rootContainer);
|
||||
|
||||
const UUID uuid = m_rootUuids[Random::get<std::size_t>(0, m_rootUuids.size() - 1)];
|
||||
const std::size_t uuidBytes = m_rootTotalBytes->at(uuid);
|
||||
state.ResumeTiming();
|
||||
|
||||
SerializationManager::LoadAsset(uuid);
|
||||
bytesProcessed += static_cast<std::int64_t>(uuidBytes);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * (1 + REFS_PER_ROOT));
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SerializationManagerFixture, LoadAsset)->Name("SerializationManager/LoadAsset")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SerializationManagerFixture, LoadAssets)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
AssetLibrary library;
|
||||
// leafContainer must outlive rootContainer, see the same comment in the LoadAsset benchmark above.
|
||||
AssetContainer<BenchmarkAssetReferred> leafContainer;
|
||||
AssetContainer<BenchmarkAsset> rootContainer;
|
||||
ResetActiveLibrary(library, leafContainer, rootContainer);
|
||||
|
||||
const eastl::vector<UUID> batch = RandomRootBatch(batchSize);
|
||||
const std::int64_t batchBytes = TotalBytes(batch);
|
||||
state.ResumeTiming();
|
||||
|
||||
SerializationManager::LoadAssets(batch);
|
||||
bytesProcessed += batchBytes;
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize * (1 + REFS_PER_ROOT));
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SerializationManagerFixture, LoadAssets)
|
||||
->Name("SerializationManager/LoadAssets")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->Arg(4096)
|
||||
->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
BENCHMARK_DEFINE_F(SerializationManagerFixture, SaveAsset)(benchmark::State& state)
|
||||
{
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchmarkAsset> container;
|
||||
std::ignore = library.Insert(&container);
|
||||
SetActiveAssetLibrary(&library);
|
||||
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
auto* asset = CreateAsset<BenchmarkAsset>();
|
||||
asset->SetName(asset->GetHeader().uuid.ToString());
|
||||
asset->GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ROOT; ++j)
|
||||
{
|
||||
asset->GetAsset().refs.emplace_back(m_leafUuids[Random::get<std::size_t>(0, m_leafUuids.size() - 1)]);
|
||||
}
|
||||
const UUID uuid = asset->GetHeader().uuid;
|
||||
const std::size_t assetBytes = asset->Pack().size();
|
||||
bytesProcessed += static_cast<std::int64_t>(assetBytes);
|
||||
state.ResumeTiming();
|
||||
|
||||
benchmark::DoNotOptimize(SerializationManager::SaveAsset(uuid));
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations());
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SerializationManagerFixture, SaveAsset)->Name("SerializationManager/SaveAsset")->UseRealTime();
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(SerializationManagerFixture, SaveAssets)(benchmark::State& state)
|
||||
{
|
||||
const auto batchSize = static_cast<std::size_t>(state.range(0));
|
||||
|
||||
AssetLibrary library;
|
||||
AssetContainer<BenchmarkAsset> container;
|
||||
std::ignore = library.Insert(&container);
|
||||
SetActiveAssetLibrary(&library);
|
||||
|
||||
std::int64_t bytesProcessed = 0;
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
state.PauseTiming();
|
||||
eastl::vector<UUID> uuids;
|
||||
uuids.reserve(batchSize);
|
||||
std::size_t batchBytes = 0;
|
||||
for (std::size_t i = 0; i < batchSize; ++i)
|
||||
{
|
||||
auto* asset = CreateAsset<BenchmarkAsset>();
|
||||
asset->SetName(asset->GetHeader().uuid.ToString());
|
||||
asset->GetAsset().payload.assign(ASSET_PAYLOAD_SIZE, std::uint8_t {0xAB});
|
||||
for (std::uint32_t j = 0; j < REFS_PER_ROOT; ++j)
|
||||
{
|
||||
asset->GetAsset().refs.emplace_back(m_leafUuids[Random::get<std::size_t>(0, m_leafUuids.size() - 1)]);
|
||||
}
|
||||
|
||||
batchBytes += asset->Pack().size();
|
||||
uuids.push_back(asset->GetHeader().uuid);
|
||||
}
|
||||
state.ResumeTiming();
|
||||
|
||||
benchmark::DoNotOptimize(SerializationManager::SaveAssets(uuids));
|
||||
bytesProcessed += static_cast<std::int64_t>(batchBytes);
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * batchSize);
|
||||
state.SetBytesProcessed(bytesProcessed);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(SerializationManagerFixture, SaveAssets)
|
||||
->Name("SerializationManager/SaveAssets")
|
||||
->Arg(1)
|
||||
->Arg(8)
|
||||
->Arg(64)
|
||||
->Arg(512)
|
||||
->UseRealTime();
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,26 @@
|
||||
/*********************************************************************
|
||||
* \file main.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
|
||||
|
||||
::benchmark::Initialize(&argc, argv);
|
||||
if (::benchmark::ReportUnrecognizedArguments(argc, argv))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
::benchmark::RunSpecifiedBenchmarks();
|
||||
::benchmark::Shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
if(${VULKAN})
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsVulkan)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsCore)
|
||||
endif()
|
||||
@@ -0,0 +1,5 @@
|
||||
get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName}Benchmarks)
|
||||
|
||||
bigfoot_create_package_benchmarks(
|
||||
"Bigfoot/Benchmarks/Graphics")
|
||||
@@ -0,0 +1,26 @@
|
||||
/*********************************************************************
|
||||
* \file main.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
|
||||
|
||||
::benchmark::Initialize(&argc, argv);
|
||||
if (::benchmark::ReportUnrecognizedArguments(argc, argv))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
::benchmark::RunSpecifiedBenchmarks();
|
||||
::benchmark::Shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName}Benchmarks)
|
||||
|
||||
bigfoot_create_package_benchmarks(
|
||||
"Bigfoot/Benchmarks/Graphics")
|
||||
@@ -0,0 +1,26 @@
|
||||
/*********************************************************************
|
||||
* \file main.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
|
||||
|
||||
::benchmark::Initialize(&argc, argv);
|
||||
if (::benchmark::ReportUnrecognizedArguments(argc, argv))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
::benchmark::RunSpecifiedBenchmarks();
|
||||
::benchmark::Shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
||||
-8
@@ -1,8 +0,0 @@
|
||||
namespace Flat.Bigfoot;
|
||||
|
||||
table BenchAssetLeaf
|
||||
{
|
||||
payload: [ubyte];
|
||||
}
|
||||
|
||||
root_type BenchAssetLeaf;
|
||||
-40
@@ -1,40 +0,0 @@
|
||||
/*********************************************************************
|
||||
* \file BenchAssetLeaf.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHASSETLEAF_HPP
|
||||
#define BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHASSETLEAF_HPP
|
||||
#include <Engine/Asset/Asset.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetLeaf_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct BenchAssetLeafTraits
|
||||
{
|
||||
using FLAT = ::Flat::Bigfoot::BenchAssetLeaf;
|
||||
};
|
||||
|
||||
/*
|
||||
* A leaf asset with a variable-size byte payload - stands in for a self-contained game asset (a texture,
|
||||
* a mesh, ...) so BigFile/Sasquatch benchmarks measure real Asset<T> Pack()/Unpack() round-trips instead
|
||||
* of hand-rolled blobs.
|
||||
*/
|
||||
class BenchAssetLeaf: public Asset<BenchAssetLeafTraits>
|
||||
{
|
||||
public:
|
||||
BenchAssetLeaf() = default;
|
||||
|
||||
BenchAssetLeaf(const BenchAssetLeaf& p_asset) = delete;
|
||||
BenchAssetLeaf(BenchAssetLeaf&& p_asset) = default;
|
||||
|
||||
~BenchAssetLeaf() = default;
|
||||
|
||||
BenchAssetLeaf& operator=(const BenchAssetLeaf& p_asset) = delete;
|
||||
BenchAssetLeaf& operator=(BenchAssetLeaf&& p_asset) = default;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
-192
@@ -1,192 +0,0 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_BENCHASSETLEAF_FLAT_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_BENCHASSETLEAF_FLAT_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
struct BenchAssetLeaf;
|
||||
struct BenchAssetLeafBuilder;
|
||||
struct BenchAssetLeafT;
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchAssetLeafTypeTable();
|
||||
|
||||
struct BenchAssetLeafT : public ::flatbuffers::NativeTable {
|
||||
typedef BenchAssetLeaf TableType;
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchAssetLeafT";
|
||||
}
|
||||
eastl::vector<uint8_t> payload{};
|
||||
};
|
||||
|
||||
struct BenchAssetLeaf FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef BenchAssetLeafT NativeTableType;
|
||||
typedef BenchAssetLeafBuilder Builder;
|
||||
struct Traits;
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return BenchAssetLeafTypeTable();
|
||||
}
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchAssetLeaf";
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
VT_PAYLOAD = 4
|
||||
};
|
||||
const ::flatbuffers::Vector<uint8_t> *payload() const {
|
||||
return GetPointer<const ::flatbuffers::Vector<uint8_t> *>(VT_PAYLOAD);
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyOffset(verifier, VT_PAYLOAD) &&
|
||||
verifier.VerifyVector(payload()) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
BenchAssetLeafT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(BenchAssetLeafT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<BenchAssetLeaf> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetLeafT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct BenchAssetLeafBuilder {
|
||||
typedef BenchAssetLeaf Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_payload(::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload) {
|
||||
fbb_.AddOffset(BenchAssetLeaf::VT_PAYLOAD, payload);
|
||||
}
|
||||
explicit BenchAssetLeafBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<BenchAssetLeaf> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<BenchAssetLeaf>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetLeaf> CreateBenchAssetLeaf(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
::flatbuffers::Offset<::flatbuffers::Vector<uint8_t>> payload = 0) {
|
||||
BenchAssetLeafBuilder builder_(_fbb);
|
||||
builder_.add_payload(payload);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BenchAssetLeaf::Traits {
|
||||
using type = BenchAssetLeaf;
|
||||
static auto constexpr Create = CreateBenchAssetLeaf;
|
||||
};
|
||||
|
||||
::flatbuffers::Offset<BenchAssetLeaf> CreateBenchAssetLeaf(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetLeafT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline BenchAssetLeafT *BenchAssetLeaf::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<BenchAssetLeafT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void BenchAssetLeaf::UnPackTo(BenchAssetLeafT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = payload(); if (_e) { _o->payload.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->payload.begin()); } }
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetLeaf> CreateBenchAssetLeaf(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetLeafT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return BenchAssetLeaf::Pack(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetLeaf> BenchAssetLeaf::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetLeafT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BenchAssetLeafT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _payload = _fbb.CreateVector(_o->payload.data(), _o->payload.size());
|
||||
return Flat::Bigfoot::CreateBenchAssetLeaf(
|
||||
_fbb,
|
||||
_payload);
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchAssetLeafTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_UCHAR, 1, -1 }
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 1, type_codes, nullptr, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchAssetLeaf *GetBenchAssetLeaf(const void *buf) {
|
||||
return ::flatbuffers::GetRoot<Flat::Bigfoot::BenchAssetLeaf>(buf);
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchAssetLeaf *GetSizePrefixedBenchAssetLeaf(const void *buf) {
|
||||
return ::flatbuffers::GetSizePrefixedRoot<Flat::Bigfoot::BenchAssetLeaf>(buf);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifyBenchAssetLeafBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifyBuffer<Flat::Bigfoot::BenchAssetLeaf>(nullptr);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifySizePrefixedBenchAssetLeafBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifySizePrefixedBuffer<Flat::Bigfoot::BenchAssetLeaf>(nullptr);
|
||||
}
|
||||
|
||||
inline const char *BenchAssetLeafExtension() {
|
||||
return "bfbs";
|
||||
}
|
||||
|
||||
inline void FinishBenchAssetLeafBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchAssetLeaf> root) {
|
||||
fbb.Finish(root);
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedBenchAssetLeafBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchAssetLeaf> root) {
|
||||
fbb.FinishSizePrefixed(root);
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchAssetLeafT> UnPackBenchAssetLeaf(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchAssetLeafT>(GetBenchAssetLeaf(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchAssetLeafT> UnPackSizePrefixedBenchAssetLeaf(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchAssetLeafT>(GetSizePrefixedBenchAssetLeaf(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_BENCHASSETLEAF_FLAT_BIGFOOT_H_
|
||||
-10
@@ -1,10 +0,0 @@
|
||||
include "Engine/Asset/Reference.fbs";
|
||||
|
||||
namespace Flat.Bigfoot;
|
||||
|
||||
table BenchAssetRoot
|
||||
{
|
||||
leaf: HardReference (native_inline, bigfoot_ref: "::Bigfoot::BenchAssetLeaf");
|
||||
}
|
||||
|
||||
root_type BenchAssetRoot;
|
||||
-40
@@ -1,40 +0,0 @@
|
||||
/*********************************************************************
|
||||
* \file BenchAssetRoot.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHASSETROOT_HPP
|
||||
#define BIGFOOT_ASSETSFORBENCHMARKING_ASSET_BENCHASSETROOT_HPP
|
||||
#include <Engine/Asset/Asset.hpp>
|
||||
|
||||
#include <AssetsForBenchmarking/Asset/BenchAssetRoot_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct BenchAssetRootTraits
|
||||
{
|
||||
using FLAT = ::Flat::Bigfoot::BenchAssetRoot;
|
||||
};
|
||||
|
||||
/*
|
||||
* A small "pointer" asset holding a HardReference to a BenchAssetLeaf - stands in for e.g. a Material
|
||||
* referencing a Texture, so LoadAsset's recursive HardReference walk is actually exercised (a
|
||||
* BenchAssetLeaf alone never triggers it).
|
||||
*/
|
||||
class BenchAssetRoot: public Asset<BenchAssetRootTraits>
|
||||
{
|
||||
public:
|
||||
BenchAssetRoot() = default;
|
||||
|
||||
BenchAssetRoot(const BenchAssetRoot& p_asset) = delete;
|
||||
BenchAssetRoot(BenchAssetRoot&& p_asset) = default;
|
||||
|
||||
~BenchAssetRoot() = default;
|
||||
|
||||
BenchAssetRoot& operator=(const BenchAssetRoot& p_asset) = delete;
|
||||
BenchAssetRoot& operator=(BenchAssetRoot&& p_asset) = default;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
-221
@@ -1,221 +0,0 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_BENCHASSETROOT_FLAT_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_BENCHASSETROOT_FLAT_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "System/UUID/UUID.hpp"
|
||||
#include "Engine/Asset/Reference.hpp"
|
||||
#include "Engine/Asset/Reference_generated.hpp"
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
struct BenchAssetRoot;
|
||||
struct BenchAssetRootBuilder;
|
||||
struct BenchAssetRootT;
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
namespace Bigfoot {
|
||||
class BenchAssetLeaf;
|
||||
} // namespace Bigfoot
|
||||
|
||||
namespace flatbuffers {
|
||||
Flat::Bigfoot::HardReference PackHardReferenceBenchAssetLeaf(const ::Bigfoot::HardReference<::Bigfoot::BenchAssetLeaf>& p_asset);
|
||||
::Bigfoot::HardReference<::Bigfoot::BenchAssetLeaf> UnPackHardReferenceBenchAssetLeaf(const Flat::Bigfoot::HardReference& p_asset);
|
||||
} // namespace flatbuffers
|
||||
|
||||
namespace Flat {
|
||||
namespace Bigfoot {
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchAssetRootTypeTable();
|
||||
|
||||
struct BenchAssetRootT : public ::flatbuffers::NativeTable {
|
||||
typedef BenchAssetRoot TableType;
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchAssetRootT";
|
||||
}
|
||||
::Bigfoot::HardReference<::Bigfoot::BenchAssetLeaf> leaf{};
|
||||
};
|
||||
|
||||
struct BenchAssetRoot FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
typedef BenchAssetRootT NativeTableType;
|
||||
typedef BenchAssetRootBuilder Builder;
|
||||
struct Traits;
|
||||
static const ::flatbuffers::TypeTable *MiniReflectTypeTable() {
|
||||
return BenchAssetRootTypeTable();
|
||||
}
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.BenchAssetRoot";
|
||||
}
|
||||
enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE {
|
||||
VT_LEAF = 4
|
||||
};
|
||||
const Flat::Bigfoot::HardReference *leaf() const {
|
||||
return GetStruct<const Flat::Bigfoot::HardReference *>(VT_LEAF);
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
VerifyField<Flat::Bigfoot::HardReference>(verifier, VT_LEAF, 1) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
BenchAssetRootT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
void UnPackTo(BenchAssetRootT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
static ::flatbuffers::Offset<BenchAssetRoot> Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
};
|
||||
|
||||
struct BenchAssetRootBuilder {
|
||||
typedef BenchAssetRoot Table;
|
||||
::flatbuffers::FlatBufferBuilder &fbb_;
|
||||
::flatbuffers::uoffset_t start_;
|
||||
void add_leaf(const Flat::Bigfoot::HardReference *leaf) {
|
||||
fbb_.AddStruct(BenchAssetRoot::VT_LEAF, leaf);
|
||||
}
|
||||
explicit BenchAssetRootBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
}
|
||||
::flatbuffers::Offset<BenchAssetRoot> Finish() {
|
||||
const auto end = fbb_.EndTable(start_);
|
||||
auto o = ::flatbuffers::Offset<BenchAssetRoot>(end);
|
||||
return o;
|
||||
}
|
||||
};
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetRoot> CreateBenchAssetRoot(
|
||||
::flatbuffers::FlatBufferBuilder &_fbb,
|
||||
const Flat::Bigfoot::HardReference *leaf = nullptr) {
|
||||
BenchAssetRootBuilder builder_(_fbb);
|
||||
builder_.add_leaf(leaf);
|
||||
return builder_.Finish();
|
||||
}
|
||||
|
||||
struct BenchAssetRoot::Traits {
|
||||
using type = BenchAssetRoot;
|
||||
static auto constexpr Create = CreateBenchAssetRoot;
|
||||
};
|
||||
|
||||
::flatbuffers::Offset<BenchAssetRoot> CreateBenchAssetRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr);
|
||||
|
||||
inline BenchAssetRootT *BenchAssetRoot::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
auto _o = std::make_unique<BenchAssetRootT>();
|
||||
UnPackTo(_o.get(), _resolver);
|
||||
return _o.release();
|
||||
}
|
||||
|
||||
inline void BenchAssetRoot::UnPackTo(BenchAssetRootT *_o, const ::flatbuffers::resolver_function_t *_resolver) const {
|
||||
(void)_o;
|
||||
(void)_resolver;
|
||||
{ auto _e = leaf(); if (_e) _o->leaf = ::flatbuffers::UnPackHardReferenceBenchAssetLeaf(*_e); }
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetRoot> CreateBenchAssetRoot(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetRootT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
return BenchAssetRoot::Pack(_fbb, _o, _rehasher);
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<BenchAssetRoot> BenchAssetRoot::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const BenchAssetRootT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
(void)_rehasher;
|
||||
(void)_o;
|
||||
struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const BenchAssetRootT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va;
|
||||
auto _leaf = ::flatbuffers::PackHardReferenceBenchAssetLeaf(_o->leaf);
|
||||
return Flat::Bigfoot::CreateBenchAssetRoot(
|
||||
_fbb,
|
||||
&_leaf);
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *BenchAssetRootTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Flat::Bigfoot::HardReferenceTypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 1, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchAssetRoot *GetBenchAssetRoot(const void *buf) {
|
||||
return ::flatbuffers::GetRoot<Flat::Bigfoot::BenchAssetRoot>(buf);
|
||||
}
|
||||
|
||||
inline const Flat::Bigfoot::BenchAssetRoot *GetSizePrefixedBenchAssetRoot(const void *buf) {
|
||||
return ::flatbuffers::GetSizePrefixedRoot<Flat::Bigfoot::BenchAssetRoot>(buf);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifyBenchAssetRootBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifyBuffer<Flat::Bigfoot::BenchAssetRoot>(nullptr);
|
||||
}
|
||||
|
||||
template <bool B = false>
|
||||
inline bool VerifySizePrefixedBenchAssetRootBuffer(
|
||||
::flatbuffers::VerifierTemplate<B> &verifier) {
|
||||
return verifier.template VerifySizePrefixedBuffer<Flat::Bigfoot::BenchAssetRoot>(nullptr);
|
||||
}
|
||||
|
||||
inline const char *BenchAssetRootExtension() {
|
||||
return "bfbs";
|
||||
}
|
||||
|
||||
inline void FinishBenchAssetRootBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchAssetRoot> root) {
|
||||
fbb.Finish(root);
|
||||
}
|
||||
|
||||
inline void FinishSizePrefixedBenchAssetRootBuffer(
|
||||
::flatbuffers::FlatBufferBuilder &fbb,
|
||||
::flatbuffers::Offset<Flat::Bigfoot::BenchAssetRoot> root) {
|
||||
fbb.FinishSizePrefixed(root);
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchAssetRootT> UnPackBenchAssetRoot(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchAssetRootT>(GetBenchAssetRoot(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
inline eastl::unique_ptr<Flat::Bigfoot::BenchAssetRootT> UnPackSizePrefixedBenchAssetRoot(
|
||||
const void *buf,
|
||||
const ::flatbuffers::resolver_function_t *res = nullptr) {
|
||||
return eastl::unique_ptr<Flat::Bigfoot::BenchAssetRootT>(GetSizePrefixedBenchAssetRoot(buf)->UnPack(res));
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
} // namespace Flat
|
||||
|
||||
namespace flatbuffers {
|
||||
#ifndef FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHASSETLEAF
|
||||
#define FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHASSETLEAF
|
||||
inline Flat::Bigfoot::HardReference PackHardReferenceBenchAssetLeaf(const ::Bigfoot::HardReference<::Bigfoot::BenchAssetLeaf>& p_asset) { return {Pack(p_asset.GetUUID())}; }
|
||||
inline ::Bigfoot::HardReference<::Bigfoot::BenchAssetLeaf> UnPackHardReferenceBenchAssetLeaf(const Flat::Bigfoot::HardReference& p_asset) { return {UnPack(p_asset.uuid())}; }
|
||||
#endif // FLATBUFFERS_BIGFOOT_REF_HARDREFERENCEBENCHASSETLEAF
|
||||
} // namespace flatbuffers
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_BENCHASSETROOT_FLAT_BIGFOOT_H_
|
||||
@@ -1 +0,0 @@
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/AssetsForBenchmarking)
|
||||
@@ -0,0 +1,92 @@
|
||||
/*********************************************************************
|
||||
* \file Graph.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Utils/Algorithm/Graph.hpp>
|
||||
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
using Random = effolkronium::random_static;
|
||||
|
||||
class LayeredTopologicalSortFixture: public benchmark::Fixture
|
||||
{
|
||||
protected:
|
||||
/*
|
||||
* Nodes are grouped into layers, and every node in a layer depends on up to DEPENDENCY_MAX_COUNT
|
||||
* distinct nodes randomly picked from the previous layer.
|
||||
*/
|
||||
void SetUp(benchmark::State& state) override
|
||||
{
|
||||
Random::seed(0x5EEDU);
|
||||
|
||||
const auto nodeCount = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
m_graph.clear();
|
||||
m_nodes.clear();
|
||||
m_graph.reserve(nodeCount);
|
||||
m_nodes.reserve(nodeCount);
|
||||
|
||||
for (std::uint32_t node = 0; node < nodeCount; ++node)
|
||||
{
|
||||
m_nodes.insert(node);
|
||||
eastl::vector<std::uint32_t>& edges = m_graph[node];
|
||||
|
||||
const std::uint32_t layerStart = (node / NODE_COUNT_PER_LAYER) * NODE_COUNT_PER_LAYER;
|
||||
if (layerStart == 0)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
|
||||
const std::uint32_t previousLayerStart = layerStart - NODE_COUNT_PER_LAYER;
|
||||
ankerl::unordered_dense::set<std::uint32_t> picked;
|
||||
for (std::uint32_t i = 0; i < DEPENDENCY_MAX_COUNT; ++i)
|
||||
{
|
||||
const std::uint32_t dependency = Random::get<std::uint32_t>(previousLayerStart, layerStart - 1);
|
||||
if (picked.insert(dependency).second)
|
||||
{
|
||||
edges.push_back(dependency);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static constexpr std::uint32_t NODE_COUNT_PER_LAYER = 64;
|
||||
static constexpr std::uint32_t DEPENDENCY_MAX_COUNT = 4;
|
||||
|
||||
ankerl::unordered_dense::map<std::uint32_t, eastl::vector<std::uint32_t>> m_graph;
|
||||
ankerl::unordered_dense::set<std::uint32_t> m_nodes;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BENCHMARK_DEFINE_F(LayeredTopologicalSortFixture, LayeredTopologicalSortBench)(benchmark::State& state)
|
||||
{
|
||||
const auto nodeCount = static_cast<std::uint32_t>(state.range(0));
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
eastl::vector<eastl::vector<std::uint32_t>> waves;
|
||||
eastl::vector<std::uint32_t> cyclicNodes;
|
||||
benchmark::DoNotOptimize(LayeredTopologicalSort(m_graph, m_nodes, waves, cyclicNodes));
|
||||
benchmark::DoNotOptimize(waves);
|
||||
benchmark::ClobberMemory();
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * nodeCount);
|
||||
}
|
||||
|
||||
BENCHMARK_REGISTER_F(LayeredTopologicalSortFixture, LayeredTopologicalSortBench)
|
||||
->Name("Bigfoot::LayeredTopologicalSort")
|
||||
->Arg(512)
|
||||
->Arg(8192)
|
||||
->Arg(262'144)
|
||||
->Arg(4'194'304);
|
||||
} // namespace Bigfoot
|
||||
@@ -2,4 +2,4 @@ get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName}Benchmarks)
|
||||
|
||||
bigfoot_create_package_benchmarks(
|
||||
"")
|
||||
"Bigfoot/Benchmarks")
|
||||
+11
-6
@@ -2,16 +2,17 @@
|
||||
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <benchmark/benchmark.h>
|
||||
#include <effolkronium/random.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <random>
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
#include <vector>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
using Random = effolkronium::random_static;
|
||||
|
||||
struct MyComplexStruct
|
||||
{
|
||||
std::uint32_t m_actualValueForBench = 0; // field summed by the Iterate benchmark
|
||||
@@ -137,6 +138,7 @@ void Insert(benchmark::State& state)
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(MyComplexStruct)));
|
||||
}
|
||||
|
||||
template<class ADAPTOR>
|
||||
@@ -147,7 +149,7 @@ void Remove(benchmark::State& state)
|
||||
ADAPTOR adaptor;
|
||||
std::vector<typename ADAPTOR::Key> keys;
|
||||
keys.reserve(count);
|
||||
std::mt19937 rng(0x5EEDU);
|
||||
Random::seed(0x5EEDU);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
@@ -158,7 +160,7 @@ void Remove(benchmark::State& state)
|
||||
{
|
||||
keys.push_back(adaptor.Add(MyComplexStruct {i}));
|
||||
}
|
||||
std::shuffle(keys.begin(), keys.end(), rng);
|
||||
Random::shuffle(keys);
|
||||
state.ResumeTiming();
|
||||
|
||||
for (const typename ADAPTOR::Key key: keys)
|
||||
@@ -170,6 +172,7 @@ void Remove(benchmark::State& state)
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(MyComplexStruct)));
|
||||
}
|
||||
|
||||
template<class ADAPTOR>
|
||||
@@ -184,8 +187,8 @@ void Get(benchmark::State& state)
|
||||
{
|
||||
keys.push_back(adaptor.Add(MyComplexStruct {i}));
|
||||
}
|
||||
std::mt19937 rng(0x5EEDU);
|
||||
std::shuffle(keys.begin(), keys.end(), rng);
|
||||
Random::seed(0x5EEDU);
|
||||
Random::shuffle(keys);
|
||||
|
||||
for (auto _: state)
|
||||
{
|
||||
@@ -201,6 +204,7 @@ void Get(benchmark::State& state)
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(MyComplexStruct)));
|
||||
}
|
||||
|
||||
template<class ADAPTOR>
|
||||
@@ -226,6 +230,7 @@ void Iterate(benchmark::State& state)
|
||||
}
|
||||
|
||||
state.SetItemsProcessed(state.iterations() * count);
|
||||
state.SetBytesProcessed(static_cast<std::int64_t>(state.iterations() * count * sizeof(MyComplexStruct)));
|
||||
}
|
||||
|
||||
#define BIGFOOT_REGISTER_BENCHMARKS(ADAPTOR, NAME) \
|
||||
@@ -0,0 +1,26 @@
|
||||
/*********************************************************************
|
||||
* \file main.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <benchmark/benchmark.h>
|
||||
|
||||
int main(int argc, char** argv)
|
||||
{
|
||||
BIGFOOT_NOT_OPTIMIZED_ONLY(::Bigfoot::Singleton<::Bigfoot::Log>::Lifetime m_lifetime);
|
||||
|
||||
::benchmark::Initialize(&argc, argv);
|
||||
if (::benchmark::ReportUnrecognizedArguments(argc, argv))
|
||||
{
|
||||
return 1;
|
||||
}
|
||||
|
||||
::benchmark::RunSpecifiedBenchmarks();
|
||||
::benchmark::Shutdown();
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -1,6 +1,4 @@
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Utils)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/System)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Engine)
|
||||
if(BIGFOOT_TOOL_MODE)
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Tools)
|
||||
endif()
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/Graphics)
|
||||
@@ -0,0 +1,63 @@
|
||||
/*********************************************************************
|
||||
* \file AssetBase.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date April 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/AssetBase.hpp>
|
||||
|
||||
#include <Engine/Asset/Reference_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
void AssetBase::HardReferenceVisitor::Field([[maybe_unused]] size_t p_fieldIndex,
|
||||
[[maybe_unused]] size_t p_setIndex,
|
||||
const flatbuffers::ElementaryType p_type,
|
||||
const bool p_isVector,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
[[maybe_unused]] const char* p_name,
|
||||
const std::uint8_t* p_val)
|
||||
{
|
||||
if (!p_isVector)
|
||||
{
|
||||
Visit(p_type, p_typeTable, p_val);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetBase::HardReferenceVisitor::Element([[maybe_unused]] size_t p_index,
|
||||
const flatbuffers::ElementaryType p_type,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
const std::uint8_t* p_val)
|
||||
{
|
||||
Visit(p_type, p_typeTable, p_val);
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<UUID> AssetBase::HardReferenceVisitor::GetUUIDs() const
|
||||
{
|
||||
eastl::vector<UUID> uuids;
|
||||
uuids.reserve(m_uuids.size());
|
||||
std::copy(m_uuids.begin(), m_uuids.end(), eastl::back_inserter(uuids));
|
||||
return uuids;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetBase::HardReferenceVisitor::Visit(const flatbuffers::ElementaryType p_type,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
const std::uint8_t* p_val)
|
||||
{
|
||||
if (p_val == nullptr || p_type != flatbuffers::ET_SEQUENCE ||
|
||||
p_typeTable != ::Flat::Bigfoot::HardReference::MiniReflectTypeTable())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
const ::Flat::Bigfoot::HardReference* hardReference = reinterpret_cast<const ::Flat::Bigfoot::HardReference*>(
|
||||
p_val);
|
||||
m_uuids.emplace(flatbuffers::UnPack(hardReference->uuid()));
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,188 @@
|
||||
/*********************************************************************
|
||||
* \file AssetContainer.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
ContainerHandle::ContainerHandle(AssetContainerBase* p_assetContainer, const UUID p_uuid):
|
||||
m_assetContainer(p_assetContainer),
|
||||
m_uuid(p_uuid)
|
||||
{
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
std::uint32_t ContainerHandle::GetHardRefCount() const
|
||||
{
|
||||
return m_hardRefCount;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void ContainerHandle::IncrementHardRefCount()
|
||||
{
|
||||
if (m_hardRefCount == 0)
|
||||
{
|
||||
m_assetContainer->CancelRemoval(m_uuid);
|
||||
}
|
||||
++m_hardRefCount;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void ContainerHandle::DecrementHardRefCount()
|
||||
{
|
||||
--m_hardRefCount;
|
||||
if (m_hardRefCount == 0)
|
||||
{
|
||||
m_assetContainer->QueueForRemoval(m_uuid);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
std::uint32_t ContainerHandle::GetSoftRefCount() const
|
||||
{
|
||||
return m_softRefCount;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void ContainerHandle::IncrementSoftRefCount()
|
||||
{
|
||||
++m_softRefCount;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void ContainerHandle::DecrementSoftRefCount()
|
||||
{
|
||||
--m_softRefCount;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
AssetBase* ContainerHandle::GetAsset()
|
||||
{
|
||||
return m_asset;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
const AssetBase* ContainerHandle::GetAsset() const
|
||||
{
|
||||
return m_asset;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void ContainerHandle::SetAsset(AssetBase* p_asset)
|
||||
{
|
||||
m_asset = p_asset;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool AssetContainerBase::Has(const UUID& p_uuid) const
|
||||
{
|
||||
const Entry* entry = FindEntry(p_uuid);
|
||||
return entry != nullptr && entry->m_assetSlotKey.Valid();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
ContainerHandle* AssetContainerBase::AcquireContainerHandle(const UUID& p_uuid)
|
||||
{
|
||||
return GetOrCreateEntry(p_uuid).m_handle;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetContainerBase::Remove(const UUID& p_uuid)
|
||||
{
|
||||
if (Entry* entry = FindEntry(p_uuid); entry != nullptr)
|
||||
{
|
||||
if (entry->m_assetSlotKey.Valid())
|
||||
{
|
||||
entry->m_handle->SetAsset(nullptr);
|
||||
RemoveAsset(entry->m_assetSlotKey);
|
||||
entry->m_assetSlotKey = SlotMapKey {};
|
||||
}
|
||||
m_handles.Remove(entry->m_handleSlotKey);
|
||||
m_uuidToEntry.erase(p_uuid);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetContainerBase::QueueForRemoval(const UUID& p_uuid)
|
||||
{
|
||||
m_pendingRemovalUuids.push_back(p_uuid);
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetContainerBase::CancelRemoval(const UUID& p_uuid)
|
||||
{
|
||||
auto* const pendingIt = eastl::find(m_pendingRemovalUuids.begin(), m_pendingRemovalUuids.end(), p_uuid);
|
||||
if (pendingIt != m_pendingRemovalUuids.end())
|
||||
{
|
||||
m_pendingRemovalUuids.erase_unsorted(pendingIt);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetContainerBase::ProcessPendingRemovals()
|
||||
{
|
||||
eastl::vector<UUID> toRemove;
|
||||
toRemove.swap(m_pendingRemovalUuids);
|
||||
|
||||
for (const UUID& uuid: toRemove)
|
||||
{
|
||||
Remove(uuid);
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool AssetContainerBase::IsMarkedForRemove(const UUID& p_uuid)
|
||||
{
|
||||
return eastl::find(m_pendingRemovalUuids.begin(), m_pendingRemovalUuids.end(), p_uuid) !=
|
||||
m_pendingRemovalUuids.end();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
AssetContainerBase::Entry* AssetContainerBase::FindEntry(const UUID& p_uuid)
|
||||
{
|
||||
const auto entryIt = m_uuidToEntry.find(p_uuid);
|
||||
return entryIt != m_uuidToEntry.end() ? &entryIt->second : nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
const AssetContainerBase::Entry* AssetContainerBase::FindEntry(const UUID& p_uuid) const
|
||||
{
|
||||
const auto entryIt = m_uuidToEntry.find(p_uuid);
|
||||
return entryIt != m_uuidToEntry.end() ? &entryIt->second : nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
AssetContainerBase::Entry& AssetContainerBase::GetOrCreateEntry(const UUID& p_uuid)
|
||||
{
|
||||
auto [entryIt, inserted] = m_uuidToEntry.try_emplace(p_uuid);
|
||||
if (inserted)
|
||||
{
|
||||
entryIt->second.m_handleSlotKey = m_handles.Insert(this, p_uuid);
|
||||
entryIt->second.m_handle = m_handles.Get(entryIt->second.m_handleSlotKey);
|
||||
}
|
||||
|
||||
return entryIt->second;
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,86 @@
|
||||
/*********************************************************************
|
||||
* \file AssetLibrary.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
AssetContainerBase* AssetLibrary::GetAssetContainer(const AssetTypeID p_typeID)
|
||||
{
|
||||
if (const auto container = m_assetContainers.find(p_typeID); container != m_assetContainers.end())
|
||||
{
|
||||
return container->second;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
const AssetContainerBase* AssetLibrary::GetAssetContainer(const AssetTypeID p_typeID) const
|
||||
{
|
||||
if (const auto container = m_assetContainers.find(p_typeID); container != m_assetContainers.end())
|
||||
{
|
||||
return container->second;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
const AssetContainerBase* AssetLibrary::GetAssetContainer(const UUID& p_uuid) const
|
||||
{
|
||||
for (const auto [typeId, container]: m_assetContainers)
|
||||
{
|
||||
if (container->Has(p_uuid))
|
||||
{
|
||||
return container;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
AssetContainerBase* AssetLibrary::GetAssetContainer(const UUID& p_uuid)
|
||||
{
|
||||
for (const auto [typeId, container]: m_assetContainers)
|
||||
{
|
||||
if (container->Has(p_uuid))
|
||||
{
|
||||
return container;
|
||||
}
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool AssetLibrary::IsLoaded(const UUID& p_uuid) const
|
||||
{
|
||||
return GetAssetContainer(p_uuid) != nullptr;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void AssetLibrary::ProcessPendingRemovals()
|
||||
{
|
||||
for (const auto [typeId, container]: m_assetContainers)
|
||||
{
|
||||
container->ProcessPendingRemovals();
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void SetActiveAssetLibrary(AssetLibrary* p_assetLibrary)
|
||||
{
|
||||
g_activeAssetLibrary = p_assetLibrary;
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,851 @@
|
||||
/*********************************************************************
|
||||
* \file BigFile.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date October 2025
|
||||
*********************************************************************/
|
||||
#include <Engine/BigFile/BigFile.hpp>
|
||||
|
||||
#include <Engine/EngineAssertHandler.hpp>
|
||||
|
||||
#include <Utils/Format.hpp>
|
||||
|
||||
#include <EASTL/algorithm.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
#ifdef BIGFOOT_TOOLMODE
|
||||
BigFile::BigFile(const File& p_file)
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_open_v2(p_file.ToAbsolute().GetPath().data(), &m_db, SQLITE_OPEN_READWRITE, nullptr);
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
result == SQLITE_OK,
|
||||
"Failed to open BigFile {} DB: {}",
|
||||
p_file.ToAbsolute().GetPath(),
|
||||
sqlite3_errmsg(m_db));
|
||||
|
||||
[[maybe_unused]]
|
||||
const int synchronousResult = sqlite3_exec(m_db, "PRAGMA synchronous = NORMAL;", nullptr, nullptr, nullptr);
|
||||
ASSERT(EngineAssertHandler,
|
||||
synchronousResult == SQLITE_OK,
|
||||
"Failed to set synchronous pragma: {}",
|
||||
sqlite3_errmsg(m_db));
|
||||
|
||||
[[maybe_unused]]
|
||||
const int foreignKeysResult = sqlite3_exec(m_db, "PRAGMA foreign_keys = ON;", nullptr, nullptr, nullptr);
|
||||
ASSERT(EngineAssertHandler,
|
||||
foreignKeysResult == SQLITE_OK,
|
||||
"Failed to set foreign_keys pragma: {}",
|
||||
sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::BeginTransaction()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_exec(m_db, "BEGIN TRANSACTION;", nullptr, nullptr, nullptr);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to begin transaction: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::CommitTransaction()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_exec(m_db, "COMMIT TRANSACTION;", nullptr, nullptr, nullptr);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to commit: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::RollbackTransaction()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_exec(m_db, "ROLLBACK TRANSACTION;", nullptr, nullptr, nullptr);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to rollback: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Clear()
|
||||
{
|
||||
BeginTransaction();
|
||||
|
||||
BigFile::Request {*this, "DELETE FROM AssetHardReference;"}.Execute();
|
||||
BigFile::Request {*this, "DELETE FROM Asset;"}.Execute();
|
||||
BigFile::Request {*this, "DELETE FROM AssetMetadata;"}.Execute();
|
||||
|
||||
CommitTransaction();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::~BigFile()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_close_v2(m_db);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to close BigFile DB: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<std::byte> BigFile::GetAssetFlatbuffer(const UUID& p_uuid) const
|
||||
{
|
||||
BigFile::Request assetRequest {*this, "SELECT Asset FROM Asset WHERE UUID = ?1;"};
|
||||
assetRequest.Bind(1, p_uuid.ToBytes());
|
||||
|
||||
if (!assetRequest.Step())
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
const eastl::span<const std::byte> flatbuffer = assetRequest.Get(0);
|
||||
return eastl::vector<std::byte> {flatbuffer.begin(), flatbuffer.end()};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<eastl::vector<std::byte>> BigFile::GetAssetFlatbuffers(const eastl::span<const UUID> p_uuids) const
|
||||
{
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers(p_uuids.size());
|
||||
|
||||
if (p_uuids.empty())
|
||||
{
|
||||
return flatbuffers;
|
||||
}
|
||||
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<std::size_t>> uuidToIndices;
|
||||
uuidToIndices.reserve(p_uuids.size());
|
||||
for (std::size_t i = 0; i < p_uuids.size(); ++i)
|
||||
{
|
||||
uuidToIndices[p_uuids[i]].push_back(i);
|
||||
}
|
||||
|
||||
eastl::vector<UUID> distinctUUIDs;
|
||||
distinctUUIDs.reserve(uuidToIndices.size());
|
||||
for (const auto& [uuid, indices]: uuidToIndices)
|
||||
{
|
||||
distinctUUIDs.push_back(uuid);
|
||||
}
|
||||
|
||||
constexpr std::size_t PARAMS_PER_ROW = 1;
|
||||
const std::size_t maxRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t chunkStart = 0; chunkStart < distinctUUIDs.size(); chunkStart += maxRowsPerStatement)
|
||||
{
|
||||
const std::size_t chunkSize = eastl::min(maxRowsPerStatement, distinctUUIDs.size() - chunkStart);
|
||||
|
||||
eastl::string placeholders;
|
||||
placeholders.reserve(chunkSize * 2);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
placeholders += ", ";
|
||||
}
|
||||
placeholders += "?";
|
||||
}
|
||||
|
||||
const eastl::string sql = Format("SELECT UUID, Asset FROM Asset WHERE UUID IN ({});", placeholders);
|
||||
|
||||
BigFile::Request assetRequest {*this, sql};
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
assetRequest.Bind(static_cast<std::uint32_t>(i + 1), distinctUUIDs[chunkStart + i].ToBytes());
|
||||
}
|
||||
|
||||
while (assetRequest.Step())
|
||||
{
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawUUID {
|
||||
static_cast<std::span<const std::byte>>(assetRequest.Get(0))};
|
||||
const UUID uuid {rawUUID};
|
||||
|
||||
const auto indicesIt = uuidToIndices.find(uuid);
|
||||
ASSERT(EngineAssertHandler,
|
||||
indicesIt != uuidToIndices.end(),
|
||||
"Returned UUID {} not found in requested UUIDs",
|
||||
uuid);
|
||||
|
||||
const eastl::span<const std::byte> flatbuffer = assetRequest.Get(1);
|
||||
|
||||
for (const std::size_t index: indicesIt->second)
|
||||
{
|
||||
flatbuffers[index].assign(flatbuffer.begin(), flatbuffer.end());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return flatbuffers;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<UUID> BigFile::GetAssetHardReferences(const UUID& p_uuid) const
|
||||
{
|
||||
BigFile::Request hardReferencesRequest {*this, "SELECT HardReference FROM AssetHardReference WHERE UUID = ?1;"};
|
||||
hardReferencesRequest.Bind(1, p_uuid.ToBytes());
|
||||
|
||||
eastl::vector<UUID> hardReferences;
|
||||
while (hardReferencesRequest.Step())
|
||||
{
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawUUID {
|
||||
static_cast<std::span<const std::byte>>(hardReferencesRequest.Get(0))};
|
||||
hardReferences.emplace_back(rawUUID);
|
||||
}
|
||||
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<eastl::vector<UUID>> BigFile::GetAssetsHardReferences(eastl::span<const UUID> p_uuids) const
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences(p_uuids.size());
|
||||
|
||||
if (p_uuids.empty())
|
||||
{
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<std::size_t>> uuidToIndices;
|
||||
uuidToIndices.reserve(p_uuids.size());
|
||||
for (std::size_t i = 0; i < p_uuids.size(); ++i)
|
||||
{
|
||||
uuidToIndices[p_uuids[i]].push_back(i);
|
||||
}
|
||||
|
||||
eastl::vector<UUID> distinctUUIDs;
|
||||
distinctUUIDs.reserve(uuidToIndices.size());
|
||||
for (const auto& [uuid, indices]: uuidToIndices)
|
||||
{
|
||||
distinctUUIDs.push_back(uuid);
|
||||
}
|
||||
|
||||
constexpr std::size_t PARAMS_PER_ROW = 1;
|
||||
const std::size_t maxRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t chunkStart = 0; chunkStart < distinctUUIDs.size(); chunkStart += maxRowsPerStatement)
|
||||
{
|
||||
const std::size_t chunkSize = eastl::min(maxRowsPerStatement, distinctUUIDs.size() - chunkStart);
|
||||
|
||||
eastl::string placeholders;
|
||||
placeholders.reserve(chunkSize * 2);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
placeholders += ", ";
|
||||
}
|
||||
placeholders += "?";
|
||||
}
|
||||
|
||||
const eastl::string sql = Format("SELECT UUID, HardReference FROM AssetHardReference WHERE UUID IN ({});",
|
||||
placeholders);
|
||||
|
||||
BigFile::Request hardReferencesRequest {*this, sql};
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
hardReferencesRequest.Bind(static_cast<std::uint32_t>(i + 1), distinctUUIDs[chunkStart + i].ToBytes());
|
||||
}
|
||||
|
||||
while (hardReferencesRequest.Step())
|
||||
{
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawOwnerUUID {
|
||||
static_cast<std::span<const std::byte>>(hardReferencesRequest.Get(0))};
|
||||
const UUID ownerUUID {rawOwnerUUID};
|
||||
|
||||
const auto indicesIt = uuidToIndices.find(ownerUUID);
|
||||
ASSERT(EngineAssertHandler,
|
||||
indicesIt != uuidToIndices.end(),
|
||||
"Returned UUID {} not found in requested UUIDs",
|
||||
ownerUUID);
|
||||
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawHardReference {
|
||||
static_cast<std::span<const std::byte>>(hardReferencesRequest.Get(1))};
|
||||
|
||||
for (const std::size_t index: indicesIt->second)
|
||||
{
|
||||
hardReferences[index].emplace_back(rawHardReference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::optional<BigFile::AssetTime> BigFile::GetAssetTime(const UUID& p_uuid) const
|
||||
{
|
||||
BigFile::Request timeRequest {*this, "SELECT CreateTime, ModificationTime FROM AssetMetadata WHERE UUID = ?1;"};
|
||||
timeRequest.Bind(1, p_uuid.ToBytes());
|
||||
|
||||
if (!timeRequest.Step())
|
||||
{
|
||||
return eastl::nullopt;
|
||||
}
|
||||
|
||||
return AssetTime {.m_creationTime = Time {static_cast<std::uint64_t>(timeRequest.Get(0))},
|
||||
.m_modificationTime = Time {static_cast<std::uint64_t>(timeRequest.Get(1))}};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<eastl::optional<BigFile::AssetTime>> BigFile::GetAssetsTime(const eastl::span<const UUID> p_uuids) const
|
||||
{
|
||||
eastl::vector<eastl::optional<AssetTime>> times(p_uuids.size());
|
||||
|
||||
if (p_uuids.empty())
|
||||
{
|
||||
return times;
|
||||
}
|
||||
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<std::size_t>> uuidToIndices;
|
||||
uuidToIndices.reserve(p_uuids.size());
|
||||
for (std::size_t i = 0; i < p_uuids.size(); ++i)
|
||||
{
|
||||
uuidToIndices[p_uuids[i]].push_back(i);
|
||||
}
|
||||
|
||||
eastl::vector<UUID> distinctUUIDs;
|
||||
distinctUUIDs.reserve(uuidToIndices.size());
|
||||
for (const auto& [uuid, indices]: uuidToIndices)
|
||||
{
|
||||
distinctUUIDs.push_back(uuid);
|
||||
}
|
||||
|
||||
constexpr std::size_t PARAMS_PER_ROW = 1;
|
||||
const std::size_t maxRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t chunkStart = 0; chunkStart < distinctUUIDs.size(); chunkStart += maxRowsPerStatement)
|
||||
{
|
||||
const std::size_t chunkSize = eastl::min(maxRowsPerStatement, distinctUUIDs.size() - chunkStart);
|
||||
|
||||
eastl::string placeholders;
|
||||
placeholders.reserve(chunkSize * 2);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
placeholders += ", ";
|
||||
}
|
||||
placeholders += "?";
|
||||
}
|
||||
|
||||
const eastl::string sql = Format(
|
||||
"SELECT UUID, CreateTime, ModificationTime FROM AssetMetadata WHERE UUID IN ({});",
|
||||
placeholders);
|
||||
|
||||
BigFile::Request timeRequest {*this, sql};
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
timeRequest.Bind(static_cast<std::uint32_t>(i + 1), distinctUUIDs[chunkStart + i].ToBytes());
|
||||
}
|
||||
|
||||
while (timeRequest.Step())
|
||||
{
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawUUID {
|
||||
static_cast<std::span<const std::byte>>(timeRequest.Get(0))};
|
||||
const UUID uuid {rawUUID};
|
||||
|
||||
const auto indicesIt = uuidToIndices.find(uuid);
|
||||
ASSERT(EngineAssertHandler,
|
||||
indicesIt != uuidToIndices.end(),
|
||||
"Returned UUID {} not found in requested UUIDs",
|
||||
uuid);
|
||||
|
||||
const AssetTime assetTime {.m_creationTime = Time {static_cast<std::uint64_t>(timeRequest.Get(1))},
|
||||
.m_modificationTime = Time {static_cast<std::uint64_t>(timeRequest.Get(2))}};
|
||||
|
||||
for (const std::size_t index: indicesIt->second)
|
||||
{
|
||||
times[index] = assetTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return times;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::SaveAssetFlatbuffer(const UUID& p_uuid,
|
||||
const eastl::span<const std::byte> p_flatbuffer,
|
||||
const eastl::span<const UUID> p_hardReferences)
|
||||
{
|
||||
BeginTransaction();
|
||||
|
||||
BigFile::Request metadataRequest {*this,
|
||||
"INSERT INTO AssetMetadata (UUID) VALUES (?1) "
|
||||
"ON CONFLICT(UUID) DO NOTHING;"};
|
||||
metadataRequest.Bind(1, p_uuid.ToBytes());
|
||||
metadataRequest.Execute();
|
||||
|
||||
BigFile::Request assetRequest {*this,
|
||||
"INSERT INTO Asset (UUID, Asset) VALUES (?1, ?2) "
|
||||
"ON CONFLICT(UUID) DO UPDATE SET Asset = excluded.Asset;"};
|
||||
assetRequest.Bind(1, p_uuid.ToBytes());
|
||||
assetRequest.Bind(2, p_flatbuffer);
|
||||
assetRequest.Execute();
|
||||
|
||||
BigFile::Request deleteHardReferencesRequest {*this, "DELETE FROM AssetHardReference WHERE UUID = ?1;"};
|
||||
deleteHardReferencesRequest.Bind(1, p_uuid.ToBytes());
|
||||
deleteHardReferencesRequest.Execute();
|
||||
|
||||
constexpr std::size_t HARDREF_PARAMS_PER_ROW = 2;
|
||||
constexpr std::size_t HARDREF_PLACEHOLDER_RESERVE_CHARS_PER_ROW = 8;
|
||||
const std::size_t maxHardRefRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
HARDREF_PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t chunkStart = 0; chunkStart < p_hardReferences.size(); chunkStart += maxHardRefRowsPerStatement)
|
||||
{
|
||||
const std::size_t chunkSize = eastl::min(maxHardRefRowsPerStatement, p_hardReferences.size() - chunkStart);
|
||||
|
||||
eastl::string hardReferencePlaceholders;
|
||||
hardReferencePlaceholders.reserve(chunkSize * HARDREF_PLACEHOLDER_RESERVE_CHARS_PER_ROW);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
hardReferencePlaceholders += ", ";
|
||||
}
|
||||
hardReferencePlaceholders += "(?, ?)";
|
||||
}
|
||||
|
||||
const eastl::string hardReferenceSQL = Format("INSERT INTO AssetHardReference (UUID, HardReference) VALUES {} "
|
||||
"ON CONFLICT(UUID, HardReference) DO NOTHING;",
|
||||
hardReferencePlaceholders);
|
||||
|
||||
BigFile::Request hardReferenceRequest {*this, hardReferenceSQL};
|
||||
std::uint32_t bindIndex = 1;
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
hardReferenceRequest.Bind(bindIndex++, p_uuid.ToBytes());
|
||||
hardReferenceRequest.Bind(bindIndex++, p_hardReferences[chunkStart + i].ToBytes());
|
||||
}
|
||||
hardReferenceRequest.Execute();
|
||||
}
|
||||
|
||||
CommitTransaction();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::SaveAssetFlatbuffers(const eastl::span<const UUID> p_uuids,
|
||||
const eastl::span<const eastl::vector<std::byte>> p_flatbuffers,
|
||||
const eastl::span<const eastl::vector<UUID>> p_hardReferences)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
p_uuids.size() == p_flatbuffers.size() && p_uuids.size() == p_hardReferences.size(),
|
||||
"p_metadatas and p_flatbuffers and p_hardReferences must have the same size");
|
||||
|
||||
if (p_uuids.empty())
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
BeginTransaction();
|
||||
|
||||
constexpr std::size_t METADATA_PARAMS_PER_ROW = 4;
|
||||
constexpr std::size_t METADATA_PLACEHOLDER_RESERVE_CHARS_PER_ROW = 14;
|
||||
constexpr std::size_t ASSET_PLACEHOLDER_RESERVE_CHARS_PER_ROW = 8;
|
||||
const std::size_t maxRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
METADATA_PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t chunkStart = 0; chunkStart < p_uuids.size(); chunkStart += maxRowsPerStatement)
|
||||
{
|
||||
const std::size_t chunkSize = eastl::min(maxRowsPerStatement, p_uuids.size() - chunkStart);
|
||||
|
||||
eastl::string metadataPlaceholders;
|
||||
metadataPlaceholders.reserve(chunkSize * METADATA_PLACEHOLDER_RESERVE_CHARS_PER_ROW);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
metadataPlaceholders += ", ";
|
||||
}
|
||||
metadataPlaceholders += "(?)";
|
||||
}
|
||||
|
||||
const eastl::string metadataSQL = Format(
|
||||
"INSERT INTO AssetMetadata (UUID) VALUES {} ON CONFLICT(UUID) DO NOTHING;",
|
||||
metadataPlaceholders);
|
||||
|
||||
BigFile::Request metadataRequest {*this, metadataSQL};
|
||||
std::uint32_t metadataBindIndex = 1;
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
metadataRequest.Bind(metadataBindIndex++, p_uuids[chunkStart + i].ToBytes());
|
||||
}
|
||||
metadataRequest.Execute();
|
||||
|
||||
eastl::string assetPlaceholders;
|
||||
assetPlaceholders.reserve(chunkSize * ASSET_PLACEHOLDER_RESERVE_CHARS_PER_ROW);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
assetPlaceholders += ", ";
|
||||
}
|
||||
assetPlaceholders += "(?, ?)";
|
||||
}
|
||||
|
||||
const eastl::string assetSQL = Format(
|
||||
"INSERT INTO Asset (UUID, Asset) VALUES {} ON CONFLICT(UUID) DO UPDATE SET Asset = excluded.Asset;",
|
||||
assetPlaceholders);
|
||||
|
||||
BigFile::Request assetRequest {*this, assetSQL};
|
||||
std::uint32_t assetBindIndex = 1;
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
assetRequest.Bind(assetBindIndex++, p_uuids[chunkStart + i].ToBytes());
|
||||
assetRequest.Bind(assetBindIndex++, p_flatbuffers[chunkStart + i]);
|
||||
}
|
||||
assetRequest.Execute();
|
||||
|
||||
// Replace hard references for every asset in this chunk with its current set.
|
||||
eastl::string deleteInPlaceholders;
|
||||
deleteInPlaceholders.reserve(chunkSize * 3);
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
deleteInPlaceholders += ", ";
|
||||
}
|
||||
deleteInPlaceholders += "?";
|
||||
}
|
||||
|
||||
const eastl::string deleteHardReferencesSQL = Format("DELETE FROM AssetHardReference WHERE UUID IN ({});",
|
||||
deleteInPlaceholders);
|
||||
|
||||
BigFile::Request deleteHardReferencesRequest {*this, deleteHardReferencesSQL};
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
deleteHardReferencesRequest.Bind(static_cast<std::uint32_t>(i + 1), p_uuids[chunkStart + i].ToBytes());
|
||||
}
|
||||
deleteHardReferencesRequest.Execute();
|
||||
|
||||
eastl::vector<eastl::pair<UUID, UUID>> hardReferencePairs;
|
||||
for (std::size_t i = 0; i < chunkSize; ++i)
|
||||
{
|
||||
for (const UUID& hardReference: p_hardReferences[chunkStart + i])
|
||||
{
|
||||
hardReferencePairs.emplace_back(p_uuids[chunkStart + i], hardReference);
|
||||
}
|
||||
}
|
||||
|
||||
constexpr std::size_t HARDREF_PARAMS_PER_ROW = 2;
|
||||
constexpr std::size_t HARDREF_PLACEHOLDER_RESERVE_CHARS_PER_ROW = 8;
|
||||
const std::size_t maxHardRefRowsPerStatement = static_cast<std::size_t>(
|
||||
sqlite3_limit(m_db, SQLITE_LIMIT_VARIABLE_NUMBER, -1)) /
|
||||
HARDREF_PARAMS_PER_ROW;
|
||||
|
||||
for (std::size_t hardRefChunkStart = 0; hardRefChunkStart < hardReferencePairs.size();
|
||||
hardRefChunkStart += maxHardRefRowsPerStatement)
|
||||
{
|
||||
const std::size_t hardRefChunkSize = eastl::min(maxHardRefRowsPerStatement,
|
||||
hardReferencePairs.size() - hardRefChunkStart);
|
||||
|
||||
eastl::string hardReferencePlaceholders;
|
||||
hardReferencePlaceholders.reserve(hardRefChunkSize * HARDREF_PLACEHOLDER_RESERVE_CHARS_PER_ROW);
|
||||
for (std::size_t i = 0; i < hardRefChunkSize; ++i)
|
||||
{
|
||||
if (i > 0)
|
||||
{
|
||||
hardReferencePlaceholders += ", ";
|
||||
}
|
||||
hardReferencePlaceholders += "(?, ?)";
|
||||
}
|
||||
|
||||
const eastl::string hardReferenceSQL = Format(
|
||||
"INSERT INTO AssetHardReference (UUID, HardReference) VALUES {} "
|
||||
"ON CONFLICT(UUID, HardReference) DO NOTHING;",
|
||||
hardReferencePlaceholders);
|
||||
|
||||
BigFile::Request hardReferenceRequest {*this, hardReferenceSQL};
|
||||
std::uint32_t bindIndex = 1;
|
||||
for (std::size_t i = 0; i < hardRefChunkSize; ++i)
|
||||
{
|
||||
const auto& [assetUUID, hardReference] = hardReferencePairs[hardRefChunkStart + i];
|
||||
hardReferenceRequest.Bind(bindIndex++, assetUUID.ToBytes());
|
||||
hardReferenceRequest.Bind(bindIndex++, hardReference.ToBytes());
|
||||
}
|
||||
hardReferenceRequest.Execute();
|
||||
}
|
||||
}
|
||||
|
||||
CommitTransaction();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool BigFile::Has(const UUID& p_uuid) const
|
||||
{
|
||||
BigFile::Request request {*this, "SELECT 1 FROM AssetMetadata WHERE UUID = ?1;"};
|
||||
request.Bind(1, p_uuid.ToBytes());
|
||||
|
||||
return request.Step();
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Request(const BigFile& p_bigFile, const eastl::string_view p_request):
|
||||
m_db(p_bigFile.m_db)
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_prepare_v2(m_db,
|
||||
p_request.data(),
|
||||
static_cast<int>(p_request.size()),
|
||||
&m_statement,
|
||||
nullptr);
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
result == SQLITE_OK,
|
||||
"Failed to create statement from BigFile DB: {}",
|
||||
sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const std::int32_t p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_int(m_statement, static_cast<int>(p_index), p_value);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const std::uint32_t p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_int(m_statement, static_cast<int>(p_index), static_cast<int>(p_value));
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const std::int64_t p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_int64(m_statement, static_cast<int>(p_index), p_value);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const std::uint64_t p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_int64(m_statement, static_cast<int>(p_index), std::bit_cast<std::int64_t>(p_value));
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const float p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_double(m_statement, static_cast<int>(p_index), p_value);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const double p_value)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_double(m_statement, static_cast<int>(p_index), p_value);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index, const eastl::string_view p_value, const CopyValue p_copy)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_text(m_statement,
|
||||
static_cast<int>(p_index),
|
||||
p_value.data(),
|
||||
static_cast<int>(p_value.size()),
|
||||
p_copy ? SQLITE_TRANSIENT : SQLITE_STATIC);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void BigFile::Request::Bind(const std::uint32_t p_index,
|
||||
const eastl::span<const std::byte> p_value,
|
||||
const CopyValue p_copy)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
(p_index >= 1U) && (p_index <= static_cast<std::uint32_t>(sqlite3_bind_parameter_count(m_statement))),
|
||||
"Invalid index for statement");
|
||||
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_bind_blob(m_statement,
|
||||
static_cast<int>(p_index),
|
||||
p_value.data(),
|
||||
static_cast<int>(p_value.size()),
|
||||
p_copy ? SQLITE_TRANSIENT : SQLITE_STATIC);
|
||||
ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to bind value for statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool BigFile::Request::Step()
|
||||
{
|
||||
const int result = sqlite3_step(m_statement);
|
||||
ASSERT(EngineAssertHandler,
|
||||
(result == SQLITE_DONE) || (result == SQLITE_ROW),
|
||||
"Failed to step through the statement: {}",
|
||||
sqlite3_errmsg(m_db));
|
||||
|
||||
return result == SQLITE_ROW;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
std::uint32_t BigFile::Request::Execute()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_step(m_statement);
|
||||
ASSERT(EngineAssertHandler, (result == SQLITE_DONE), "Failed to execute the statement: {}", sqlite3_errmsg(m_db));
|
||||
|
||||
return sqlite3_changes(m_db);
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::Column(const Request& p_request, const std::uint32_t p_index):
|
||||
m_statement(p_request.m_statement),
|
||||
m_index(p_index)
|
||||
{
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator std::int32_t() const
|
||||
{
|
||||
return sqlite3_column_int(m_statement, static_cast<int>(m_index));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator std::uint32_t() const
|
||||
{
|
||||
return sqlite3_column_int(m_statement, static_cast<int>(m_index));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator std::int64_t() const
|
||||
{
|
||||
return sqlite3_column_int64(m_statement, static_cast<int>(m_index));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator std::uint64_t() const
|
||||
{
|
||||
return std::bit_cast<std::uint64_t>(sqlite3_column_int64(m_statement, static_cast<int>(m_index)));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator float() const
|
||||
{
|
||||
return static_cast<float>(sqlite3_column_double(m_statement, static_cast<int>(m_index)));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator double() const
|
||||
{
|
||||
return sqlite3_column_double(m_statement, static_cast<int>(m_index));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator eastl::string_view() const
|
||||
{
|
||||
return eastl::string_view {
|
||||
reinterpret_cast<const char*>(sqlite3_column_text(m_statement, static_cast<int>(m_index))),
|
||||
static_cast<std::size_t>(sqlite3_column_bytes(m_statement, static_cast<int>(m_index)))};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator eastl::span<const std::byte>() const
|
||||
{
|
||||
return eastl::span<const std::byte> {
|
||||
static_cast<const std::byte*>(sqlite3_column_blob(m_statement, static_cast<int>(m_index))),
|
||||
static_cast<std::size_t>(sqlite3_column_bytes(m_statement, static_cast<int>(m_index)))};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column::operator std::span<const std::byte>() const
|
||||
{
|
||||
return std::span<const std::byte> {
|
||||
static_cast<const std::byte*>(sqlite3_column_blob(m_statement, static_cast<int>(m_index))),
|
||||
static_cast<std::size_t>(sqlite3_column_bytes(m_statement, static_cast<int>(m_index)))};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::Column BigFile::Request::Get(const std::uint32_t p_index) const
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
p_index < static_cast<std::uint32_t>(sqlite3_column_count(m_statement)),
|
||||
"Invalid index for column!");
|
||||
return {*this, p_index};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
BigFile::Request::~Request()
|
||||
{
|
||||
[[maybe_unused]]
|
||||
const int result = sqlite3_finalize(m_statement);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, result == SQLITE_OK, "Failed to finalize statement: {}", sqlite3_errmsg(m_db));
|
||||
}
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,38 @@
|
||||
PRAGMA journal_mode=WAL;
|
||||
|
||||
CREATE TABLE IF NOT EXISTS AssetMetadata (
|
||||
UUID BLOB NOT NULL,
|
||||
|
||||
CreateTime INTEGER NOT NULL DEFAULT(CAST(unixepoch('subsec') * 1000000 AS INTEGER)),
|
||||
ModificationTime INTEGER NOT NULL DEFAULT(CAST(unixepoch('subsec') * 1000000 AS INTEGER)),
|
||||
|
||||
PRIMARY KEY(UUID)
|
||||
) WITHOUT ROWID;
|
||||
|
||||
CREATE TABLE IF NOT EXISTS Asset (
|
||||
UUID BLOB NOT NULL,
|
||||
|
||||
Asset BLOB NOT NULL,
|
||||
|
||||
PRIMARY KEY(UUID),
|
||||
FOREIGN KEY(UUID) REFERENCES AssetMetadata(UUID) ON DELETE CASCADE
|
||||
) WITHOUT ROWID;
|
||||
|
||||
CREATE TRIGGER IF NOT EXISTS Asset_UpdateTime
|
||||
AFTER UPDATE OF Asset ON Asset FOR EACH ROW
|
||||
BEGIN
|
||||
UPDATE AssetMetadata
|
||||
SET ModificationTime = CAST(unixepoch('subsec') * 1000000 AS INTEGER)
|
||||
WHERE UUID = NEW.UUID;
|
||||
END;
|
||||
|
||||
CREATE TABLE IF NOT EXISTS AssetHardReference (
|
||||
UUID BLOB NOT NULL,
|
||||
HardReference BLOB NOT NULL,
|
||||
|
||||
PRIMARY KEY(UUID, HardReference),
|
||||
FOREIGN KEY(UUID) REFERENCES AssetMetadata(UUID)
|
||||
ON DELETE CASCADE
|
||||
);
|
||||
|
||||
CREATE INDEX IF NOT EXISTS AssetHardReference_ReferencedUUID ON AssetHardReference(HardReference);
|
||||
@@ -21,4 +21,4 @@ bigfoot_create_package_lib(
|
||||
"${PrivateDependencies}"
|
||||
"${BigfootPublicDependencies}"
|
||||
"${BigfootPrivateDependencies}"
|
||||
"")
|
||||
"Bigfoot/Libs")
|
||||
+4
-4
@@ -1,15 +1,15 @@
|
||||
/*********************************************************************
|
||||
* \file AssetLibrary.cpp
|
||||
* \file DataAccessor.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/DataAccessor/DataAccessor.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
void SetActiveAssetLibrary(AssetLibrary* p_assetLibrary)
|
||||
void SetDataAccessor(DataAccessor* p_dataAccessor)
|
||||
{
|
||||
g_activeAssetLibrary = p_assetLibrary;
|
||||
g_dataAccessor = p_dataAccessor;
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
-1
@@ -10,7 +10,6 @@ table AssetHeader
|
||||
name: string (required, id: 1);
|
||||
type_id: AssetTypeID (required, native_inline, id: 2);
|
||||
type_name: string (required, id: 3);
|
||||
version: uint = 0 (id: 4);
|
||||
}
|
||||
|
||||
table Asset
|
||||
@@ -0,0 +1,218 @@
|
||||
/*********************************************************************
|
||||
* \file Asset.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date April 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_ASSET_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_ASSET_HPP
|
||||
#include <Engine/Asset/AssetBase.hpp>
|
||||
#include <Engine/Asset/AssetConcepts.hpp>
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/EngineAssertHandler.hpp>
|
||||
|
||||
#include <Engine/Asset/Asset_generated.hpp>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <flatbuffers/minireflect.h>
|
||||
#include <rapidhash.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
template<class ASSET>
|
||||
requires AssetTraits<ASSET>
|
||||
class Asset: public AssetBase
|
||||
{
|
||||
public:
|
||||
using FLAT_ASSET = ASSET::FLAT;
|
||||
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* Will default initialize header
|
||||
*
|
||||
*/
|
||||
Asset()
|
||||
{
|
||||
m_header.type_id = GetTypeID();
|
||||
m_header.type_name = eastl::string {GetTypeName()};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the header of the asset
|
||||
*
|
||||
* \return The header of the asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const ::Flat::Bigfoot::AssetHeaderT& GetHeader() const override
|
||||
{
|
||||
return m_header;
|
||||
}
|
||||
|
||||
/**
|
||||
* Set the name of the asset
|
||||
*
|
||||
* \param p_name The name of the asset
|
||||
*/
|
||||
void SetName(const eastl::string_view p_name)
|
||||
{
|
||||
m_header.name = p_name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the asset
|
||||
*
|
||||
* \return The asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const FLAT_ASSET::NativeTableType& GetAsset() const
|
||||
{
|
||||
return m_asset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the asset
|
||||
*
|
||||
* \return The asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
FLAT_ASSET::NativeTableType& GetAsset()
|
||||
{
|
||||
return m_asset;
|
||||
}
|
||||
|
||||
/**
|
||||
* Unpack a flatbuffer to the asset
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer to unpack
|
||||
*/
|
||||
void Unpack(const eastl::span<const std::byte> p_flatbuffer) override
|
||||
{
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
flatbuffers::Verifier verifier {reinterpret_cast<const std::uint8_t*>(p_flatbuffer.data()),
|
||||
p_flatbuffer.size()};
|
||||
const bool assetVerified = ::Flat::Bigfoot::VerifyAssetBuffer(verifier);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, assetVerified, "Given asset could not be verified!");
|
||||
#endif
|
||||
|
||||
const ::Flat::Bigfoot::Asset* asset = flatbuffers::GetRoot<::Flat::Bigfoot::Asset>(p_flatbuffer.data());
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
flatbuffers::Verifier innerAssetVerifier {asset->inner_asset()->data(), asset->inner_asset()->size()};
|
||||
const bool innerAssetVerified = innerAssetVerifier.VerifyBuffer<FLAT_ASSET>();
|
||||
CRITICAL_ASSERT(EngineAssertHandler, innerAssetVerified, "Given asset could not be verified!");
|
||||
#endif
|
||||
|
||||
asset->header()->UnPackTo(&m_header);
|
||||
flatbuffers::GetRoot<FLAT_ASSET>(asset->inner_asset()->data())->UnPackTo(&m_asset, nullptr);
|
||||
}
|
||||
|
||||
/**
|
||||
* Pack the asset to a flatbuffer
|
||||
*
|
||||
* \return The packed asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<std::byte> Pack() const override
|
||||
{
|
||||
flatbuffers::FlatBufferBuilder innerAssetFbb;
|
||||
innerAssetFbb.Finish(FLAT_ASSET::Pack(innerAssetFbb, &m_asset));
|
||||
|
||||
flatbuffers::FlatBufferBuilder assetFbb;
|
||||
const auto header = ::Flat::Bigfoot::AssetHeader::Pack(assetFbb, &m_header);
|
||||
const auto innerAsset = assetFbb.CreateVector(innerAssetFbb.GetBufferPointer(), innerAssetFbb.GetSize());
|
||||
assetFbb.Finish(::Flat::Bigfoot::CreateAsset(assetFbb, header, innerAsset));
|
||||
|
||||
return eastl::vector<std::byte> {
|
||||
reinterpret_cast<std::byte*>(assetFbb.GetBufferPointer()),
|
||||
reinterpret_cast<std::byte*>(assetFbb.GetBufferPointer() + assetFbb.GetSize())};
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the HardReferences the flatbuffer has
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer
|
||||
* \return The UUIDs of the HardReferences
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> GetHardReferences(const eastl::span<const std::byte> p_flatbuffer) const override
|
||||
{
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
flatbuffers::Verifier verifier {reinterpret_cast<const std::uint8_t*>(p_flatbuffer.data()),
|
||||
p_flatbuffer.size()};
|
||||
const bool assetVerified = ::Flat::Bigfoot::VerifyAssetBuffer(verifier);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, assetVerified, "Given asset could not be verified!");
|
||||
#endif
|
||||
|
||||
const ::Flat::Bigfoot::Asset* asset = flatbuffers::GetRoot<::Flat::Bigfoot::Asset>(p_flatbuffer.data());
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
flatbuffers::Verifier innerAssetVerifier {asset->inner_asset()->data(), asset->inner_asset()->size()};
|
||||
const bool innerAssetVerified = innerAssetVerifier.VerifyBuffer<FLAT_ASSET>();
|
||||
CRITICAL_ASSERT(EngineAssertHandler, innerAssetVerified, "Given asset could not be verified!");
|
||||
#endif
|
||||
|
||||
HardReferenceVisitor visitor;
|
||||
|
||||
flatbuffers::IterateFlatBuffer(asset->inner_asset()->data(), FLAT_ASSET::MiniReflectTypeTable(), &visitor);
|
||||
return visitor.GetUUIDs();
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the AssetTypeID
|
||||
*
|
||||
* \return The AssetTypeIPD
|
||||
*/
|
||||
[[nodiscard]]
|
||||
static AssetTypeID GetTypeID()
|
||||
{
|
||||
static const AssetTypeID typeID = rapidhash(FLAT_ASSET::GetFullyQualifiedName(),
|
||||
std::strlen(FLAT_ASSET::GetFullyQualifiedName()));
|
||||
return typeID;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the type name
|
||||
*
|
||||
* \return The type name
|
||||
*/
|
||||
[[nodiscard]]
|
||||
static eastl::string_view GetTypeName()
|
||||
{
|
||||
return FLAT_ASSET::GetFullyQualifiedName();
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* The asset
|
||||
*/
|
||||
FLAT_ASSET::NativeTableType m_asset;
|
||||
/**
|
||||
* The asset header
|
||||
*/
|
||||
::Flat::Bigfoot::AssetHeaderT m_header;
|
||||
};
|
||||
|
||||
/**
|
||||
* Create an asset and insert it into its corresponding AssetContainer
|
||||
*
|
||||
* \tparam ASSET The Asset type
|
||||
* \return The created asset, nullptr if no AssetContainer is registered for ASSET
|
||||
*/
|
||||
template<class ASSET>
|
||||
requires AssetType<ASSET>
|
||||
[[nodiscard]]
|
||||
ASSET* CreateAsset()
|
||||
{
|
||||
AssetContainerBase* container = g_activeAssetLibrary->GetAssetContainer(ASSET::GetTypeID());
|
||||
CRITICAL_ASSERT(EngineAssertHandler, container != nullptr, "No AssetContainer registered for this asset type!");
|
||||
|
||||
ContainerHandle* handle = container->Insert();
|
||||
return static_cast<ASSET*>(handle->GetAsset());
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,111 @@
|
||||
/*********************************************************************
|
||||
* \file AssetBase.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date April 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_ASSETBASE_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_ASSETBASE_HPP
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <Engine/Asset/Asset_generated.hpp>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <flatbuffers/minireflect.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class AssetBase
|
||||
{
|
||||
public:
|
||||
virtual ~AssetBase() = default;
|
||||
|
||||
/**
|
||||
* Get the header of the asset
|
||||
*
|
||||
* \return The header of the asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual const ::Flat::Bigfoot::AssetHeaderT& GetHeader() const = 0;
|
||||
|
||||
/**
|
||||
* Get the HardReferences the flatbuffer has
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer
|
||||
* \return The UUIDs of the HardReferences
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<UUID> GetHardReferences(const eastl::span<const std::byte> p_flatbuffer) const = 0;
|
||||
|
||||
/**
|
||||
* Unpack a flatbuffer to the asset
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer to unpack
|
||||
*/
|
||||
virtual void Unpack(const eastl::span<const std::byte> p_flatbuffer) = 0;
|
||||
|
||||
/**
|
||||
* Pack the asset to a flatbuffer
|
||||
*
|
||||
* \return The packed asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<std::byte> Pack() const = 0;
|
||||
|
||||
AssetBase(const AssetBase& p_asset) = delete;
|
||||
AssetBase& operator=(const AssetBase& p_asset) = delete;
|
||||
|
||||
protected:
|
||||
AssetBase() = default;
|
||||
|
||||
AssetBase(AssetBase&& p_asset) = default;
|
||||
|
||||
AssetBase& operator=(AssetBase&& p_asset) = default;
|
||||
|
||||
class HardReferenceVisitor: public flatbuffers::IterationVisitor
|
||||
{
|
||||
public:
|
||||
void Field(size_t p_fieldIndex,
|
||||
size_t p_setIndex,
|
||||
const flatbuffers::ElementaryType p_type,
|
||||
const bool p_isVector,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
const char* p_name,
|
||||
const std::uint8_t* p_val) override;
|
||||
|
||||
void Element(size_t p_index,
|
||||
const flatbuffers::ElementaryType p_type,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
const std::uint8_t* p_val) override;
|
||||
|
||||
/**
|
||||
* Get the visited HardReference
|
||||
*
|
||||
* \return The visited HardReferences
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> GetUUIDs() const;
|
||||
|
||||
private:
|
||||
/**
|
||||
* Visit an element in the flatbuffer
|
||||
*
|
||||
* \param p_type The element type
|
||||
* \param p_typeTable The element typetable
|
||||
* \param p_val The element
|
||||
*/
|
||||
void Visit(const flatbuffers::ElementaryType p_type,
|
||||
const flatbuffers::TypeTable* p_typeTable,
|
||||
const std::uint8_t* p_val);
|
||||
|
||||
/**
|
||||
* The HardReferences visited so far
|
||||
*/
|
||||
ankerl::unordered_dense::set<UUID> m_uuids;
|
||||
};
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,43 @@
|
||||
/*********************************************************************
|
||||
* \file AssetConcepts.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_ASSETCONCEPTS_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_ASSETCONCEPTS_HPP
|
||||
#include <Engine/Asset/AssetTypeID.hpp>
|
||||
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <flatbuffers/minireflect.h>
|
||||
|
||||
#include <concepts>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class AssetBase;
|
||||
|
||||
/**
|
||||
* The traits struct passed to Asset<TRAITS> (e.g. AssetATraits).
|
||||
* Must name the generated flatbuffers table type for the asset.
|
||||
*/
|
||||
template<class TRAITS>
|
||||
concept AssetTraits = requires {
|
||||
typename TRAITS::FLAT;
|
||||
typename TRAITS::FLAT::NativeTableType;
|
||||
{ TRAITS::FLAT::GetFullyQualifiedName() } -> std::convertible_to<const char*>;
|
||||
{ TRAITS::FLAT::MiniReflectTypeTable() } -> std::convertible_to<const flatbuffers::TypeTable*>;
|
||||
};
|
||||
|
||||
/**
|
||||
* A concrete Asset type (e.g. AssetA), usable with AssetContainer, AssetLibrary and References.
|
||||
*/
|
||||
template<class ASSET>
|
||||
concept AssetType = std::derived_from<ASSET, AssetBase> && !std::same_as<ASSET, AssetBase> &&
|
||||
requires(const ASSET& p_asset) {
|
||||
{ ASSET::GetTypeID() } -> std::convertible_to<AssetTypeID>;
|
||||
{ p_asset.GetHeader().uuid } -> std::convertible_to<UUID>;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
@@ -0,0 +1,364 @@
|
||||
/*********************************************************************
|
||||
* \file AssetContainer.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date May 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_ASSETCONTAINER_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_ASSETCONTAINER_HPP
|
||||
#include <Engine/Asset/AssetBase.hpp>
|
||||
#include <Engine/Asset/AssetConcepts.hpp>
|
||||
#include <Engine/EngineAssertHandler.hpp>
|
||||
|
||||
#include <Utils/Containers/SlotMap.hpp>
|
||||
|
||||
#include <ankerl/unordered_dense.h>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class AssetContainerBase;
|
||||
|
||||
/**
|
||||
* An indirection that allows References to immediately get the asset, without fetching the actual container
|
||||
*/
|
||||
class ContainerHandle
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* \param p_assetContainer The originating assetcontainer
|
||||
* \param p_uuid The UUID of tha asset
|
||||
*/
|
||||
ContainerHandle(AssetContainerBase* p_assetContainer, const UUID p_uuid);
|
||||
|
||||
/*
|
||||
* Get the HardRef count
|
||||
*
|
||||
* \return The HardRef count.
|
||||
*/
|
||||
[[nodiscard]]
|
||||
std::uint32_t GetHardRefCount() const;
|
||||
|
||||
/*
|
||||
* Increment the HardRef count
|
||||
*
|
||||
*/
|
||||
void IncrementHardRefCount();
|
||||
|
||||
/*
|
||||
* Decrement the HardRef count
|
||||
*
|
||||
*/
|
||||
void DecrementHardRefCount();
|
||||
|
||||
/*
|
||||
* Get the SoftRef count
|
||||
*
|
||||
* \return The SoftRef count.
|
||||
*/
|
||||
[[nodiscard]]
|
||||
std::uint32_t GetSoftRefCount() const;
|
||||
|
||||
/*
|
||||
* Increment the SoftRef count
|
||||
*
|
||||
*/
|
||||
void IncrementSoftRefCount();
|
||||
|
||||
/*
|
||||
* Decrement the SoftRef count
|
||||
*
|
||||
*/
|
||||
void DecrementSoftRefCount();
|
||||
|
||||
/*
|
||||
* Get the Asset
|
||||
*
|
||||
* \return The asset, can be nullptr
|
||||
*/
|
||||
[[nodiscard]]
|
||||
AssetBase* GetAsset();
|
||||
|
||||
/*
|
||||
* Get the Asset
|
||||
*
|
||||
* \return The asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const AssetBase* GetAsset() const;
|
||||
|
||||
/*
|
||||
* Set the asset
|
||||
*
|
||||
* \param p_asset The asset
|
||||
*/
|
||||
void SetAsset(AssetBase* p_asset);
|
||||
|
||||
private:
|
||||
/*
|
||||
* The HardRef count
|
||||
*/
|
||||
std::uint32_t m_hardRefCount = 0;
|
||||
|
||||
/*
|
||||
* The SoftRef count
|
||||
*/
|
||||
std::uint32_t m_softRefCount = 0;
|
||||
|
||||
/*
|
||||
* The asset
|
||||
*/
|
||||
AssetBase* m_asset = nullptr;
|
||||
|
||||
/**
|
||||
* The asset container
|
||||
*/
|
||||
AssetContainerBase* m_assetContainer = nullptr;
|
||||
|
||||
/**
|
||||
* The UUID of the asset
|
||||
*/
|
||||
UUID m_uuid = UUID::NULL_UUID;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
class AssetContainerBase
|
||||
{
|
||||
using SlotMap = StableSlotMap<ContainerHandle>;
|
||||
using SlotMapKey = SlotMap::SlotMapKey;
|
||||
|
||||
public:
|
||||
virtual ~AssetContainerBase() = default;
|
||||
|
||||
/*
|
||||
* Inserts an Asset to the AssetContainer
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer to unpack to the asset
|
||||
* \return The handle of the inserted asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual ContainerHandle* Insert(const eastl::span<const std::byte> p_flatbuffer) = 0;
|
||||
|
||||
/*
|
||||
* Inserts an Asset to the AssetContainer
|
||||
*
|
||||
* \return The handle of the inserted asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual ContainerHandle* Insert() = 0;
|
||||
|
||||
/*
|
||||
* Check if an Asset is in the AssetContainer or not
|
||||
*
|
||||
* \param p_uuid The UUID to check
|
||||
* \return True if in AssetContainer, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool Has(const UUID& p_uuid) const;
|
||||
|
||||
/*
|
||||
* Acquires a ContainerHandle for a given UUID
|
||||
* Will create it if it does not exists
|
||||
*
|
||||
* \param p_uuid The UUID to get ContainerHandle for
|
||||
* \return A ContainerHandle for the UUID
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ContainerHandle* AcquireContainerHandle(const UUID& p_uuid);
|
||||
|
||||
/*
|
||||
* Remove an Asset from the AssetContainer
|
||||
*
|
||||
* \param p_uuid The UUID to remove
|
||||
*/
|
||||
void Remove(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Add an asset to be removed
|
||||
*
|
||||
* \param p_uuid UUID of the asset to remove
|
||||
*/
|
||||
void QueueForRemoval(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Remove an asset from the pending remove queue
|
||||
*
|
||||
* \param p_uuid UUID of the asset to cancel removal
|
||||
*/
|
||||
void CancelRemoval(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Process the assets that have been marked for remove
|
||||
*
|
||||
*/
|
||||
void ProcessPendingRemovals();
|
||||
|
||||
[[nodiscard]]
|
||||
bool IsMarkedForRemove(const UUID& p_uuid);
|
||||
|
||||
AssetContainerBase& operator=(const AssetContainerBase& p_container) = delete;
|
||||
AssetContainerBase& operator=(AssetContainerBase&& p_container) = delete;
|
||||
|
||||
AssetContainerBase(const AssetContainerBase& p_container) = delete;
|
||||
AssetContainerBase(AssetContainerBase&& p_container) = delete;
|
||||
|
||||
protected:
|
||||
struct Entry
|
||||
{
|
||||
/*
|
||||
* SlotMapKey to the handle
|
||||
*/
|
||||
SlotMapKey m_handleSlotKey;
|
||||
|
||||
/*
|
||||
* SlotMapKey to the asset
|
||||
*/
|
||||
SlotMapKey m_assetSlotKey;
|
||||
|
||||
/*
|
||||
* The handle itself, cached to avoid a SlotMap lookup on every access
|
||||
*/
|
||||
ContainerHandle* m_handle = nullptr;
|
||||
};
|
||||
|
||||
AssetContainerBase() = default;
|
||||
|
||||
/*
|
||||
* Finds an entry matching the Asset
|
||||
*
|
||||
* \param p_uuid The UUID to find
|
||||
* \return Pointer to an Entry, nullptr otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
Entry* FindEntry(const UUID& p_uuid);
|
||||
|
||||
/*
|
||||
* Finds an entry matching the Asset
|
||||
*
|
||||
* \param p_uuid The UUID to find
|
||||
* \return Pointer to an Entry, nullptr otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const Entry* FindEntry(const UUID& p_uuid) const;
|
||||
|
||||
/*
|
||||
* Finds an entry matching the Asset
|
||||
* Creates it if it does not exist
|
||||
*
|
||||
* \param p_uuid The UUID to find
|
||||
* \return The entry matching the Asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
Entry& GetOrCreateEntry(const UUID& p_uuid);
|
||||
|
||||
/*
|
||||
* Remove an asset
|
||||
*
|
||||
* \param p_key The key to the asset
|
||||
*/
|
||||
virtual void RemoveAsset(SlotMapKey p_slotKey) = 0;
|
||||
|
||||
private:
|
||||
/*
|
||||
* HandleContainers
|
||||
*/
|
||||
SlotMap m_handles;
|
||||
|
||||
/*
|
||||
* Every Asset added to the map
|
||||
*/
|
||||
ankerl::unordered_dense::map<UUID, Entry> m_uuidToEntry;
|
||||
|
||||
/**
|
||||
* Assets queued for removal
|
||||
*/
|
||||
eastl::vector<UUID> m_pendingRemovalUuids;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
template<class ASSET>
|
||||
requires AssetType<ASSET>
|
||||
class AssetContainer: public AssetContainerBase
|
||||
{
|
||||
using SlotMap = StableSlotMap<ASSET>;
|
||||
using SlotMapKey = SlotMap::SlotMapKey;
|
||||
|
||||
public:
|
||||
/*
|
||||
* Inserts an Asset to the AssetContainer
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer to unpack to the asset
|
||||
* \return The handle of the inserted asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ContainerHandle* Insert(const eastl::span<const std::byte> p_flatbuffer) override
|
||||
{
|
||||
return InsertInternal(&p_flatbuffer);
|
||||
}
|
||||
|
||||
/*
|
||||
* Inserts an Asset to the AssetContainer
|
||||
*
|
||||
* \return The handle of the inserted asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ContainerHandle* Insert() override
|
||||
{
|
||||
return InsertInternal(nullptr);
|
||||
}
|
||||
|
||||
private:
|
||||
/*
|
||||
* Inserts an Asset to the AssetContainer, unpacking it from a flatbuffer if given one
|
||||
*
|
||||
* \param p_flatbuffer The flatbuffer to unpack to the asset, nullptr to default-construct the asset
|
||||
* \return The handle of the inserted asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ContainerHandle* InsertInternal(const eastl::span<const std::byte>* p_flatbuffer)
|
||||
{
|
||||
SlotMapKey slotKey = m_assets.Insert();
|
||||
ASSET* asset = m_assets.Get(slotKey);
|
||||
if (p_flatbuffer != nullptr)
|
||||
{
|
||||
asset->Unpack(*p_flatbuffer);
|
||||
}
|
||||
|
||||
Entry& entry = GetOrCreateEntry(asset->GetHeader().uuid);
|
||||
if (entry.m_assetSlotKey.Valid())
|
||||
{
|
||||
m_assets.Remove(slotKey);
|
||||
slotKey = entry.m_assetSlotKey;
|
||||
}
|
||||
else
|
||||
{
|
||||
entry.m_assetSlotKey = slotKey;
|
||||
entry.m_handle->SetAsset(asset);
|
||||
}
|
||||
|
||||
return entry.m_handle;
|
||||
}
|
||||
|
||||
/*
|
||||
* Remove an asset
|
||||
*
|
||||
* \param p_key The key to the asset
|
||||
*/
|
||||
void RemoveAsset(SlotMapKey p_key) override
|
||||
{
|
||||
m_assets.Remove(p_key);
|
||||
}
|
||||
|
||||
/*
|
||||
* The assets
|
||||
*/
|
||||
SlotMap m_assets;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+9
-1
@@ -19,6 +19,14 @@
|
||||
return AssetType::GetTypeID(); \
|
||||
} \
|
||||
AssetContainer<AssetType> g_containerFor##AssetName; \
|
||||
const bool g_insertedContainerFor##AssetName = g_assetLibrary.Insert(&g_containerFor##AssetName); \
|
||||
bool RegisterAssetContainerFor##AssetName() \
|
||||
{ \
|
||||
const bool inserted = g_assetLibrary->Insert(&g_containerFor##AssetName); \
|
||||
CRITICAL_ASSERT(EngineAssertHandler, \
|
||||
inserted, \
|
||||
"AssetTypeID collision or duplicate registration for asset type '" #AssetName "'"); \
|
||||
return inserted; \
|
||||
} \
|
||||
const bool g_insertedContainerFor##AssetName = RegisterAssetContainerFor##AssetName(); \
|
||||
}
|
||||
#endif
|
||||
@@ -0,0 +1,192 @@
|
||||
/*********************************************************************
|
||||
* \file AssetLibrary.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date July 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_ASSETLIBRARY_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_ASSETLIBRARY_HPP
|
||||
#include <Engine/Asset/AssetConcepts.hpp>
|
||||
#include <Engine/Asset/AssetContainer.hpp>
|
||||
#include <Engine/Asset/AssetTypeID.hpp>
|
||||
|
||||
#include <Utils/LazyGlobal.hpp>
|
||||
|
||||
#include <ankerl/unordered_dense.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class AssetLibrary
|
||||
{
|
||||
public:
|
||||
AssetLibrary() = default;
|
||||
|
||||
AssetLibrary(const AssetLibrary& p_library) = default;
|
||||
AssetLibrary(AssetLibrary&& p_library) = delete;
|
||||
|
||||
/**
|
||||
* Insert an AssetContainer pointer to the library
|
||||
*
|
||||
* \tparam ASSET The Asset type
|
||||
* \param p_assetContainer The asset container
|
||||
* \return The AssetContainer for the Asset type. Nullptr if not found
|
||||
*/
|
||||
template<class ASSET>
|
||||
requires AssetType<ASSET>
|
||||
[[nodiscard]]
|
||||
bool Insert(AssetContainer<ASSET>* p_assetContainer)
|
||||
{
|
||||
static const AssetTypeID typeID = ASSET::GetTypeID();
|
||||
if (m_assetContainers.contains(typeID))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
const auto inserted = m_assetContainers.emplace(typeID, p_assetContainer);
|
||||
|
||||
return inserted.second;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the AssetContainer for a given AssetType
|
||||
*
|
||||
* \param p_typeID The asset type ID
|
||||
* \return The AssetContainer for the AssetType. Nullptr if not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
AssetContainerBase* GetAssetContainer(const AssetTypeID p_typeID);
|
||||
|
||||
/**
|
||||
* Get the AssetContainer for a given AssetType
|
||||
*
|
||||
* \param p_typeID The asset type ID
|
||||
* \return The AssetContainer for the AssetType. Nullptr if not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const AssetContainerBase* GetAssetContainer(const AssetTypeID p_typeID) const;
|
||||
|
||||
/**
|
||||
* Get the AssetContainer for a given UUID
|
||||
*
|
||||
* \param p_uuid The asset
|
||||
* \return The AssetContainer for the UUID. Nullptr if not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const AssetContainerBase* GetAssetContainer(const UUID& p_uuid) const;
|
||||
|
||||
/**
|
||||
* Get the AssetContainer for a given UUID
|
||||
*
|
||||
* \param p_uuid The asset
|
||||
* \return The AssetContainer for the UUID. Nullptr if not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
AssetContainerBase* GetAssetContainer(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Check if an Asset is already loaded in the library
|
||||
*
|
||||
* \param p_uuid The asset to check
|
||||
* \return True if already loaded, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool IsLoaded(const UUID& p_uuid) const;
|
||||
|
||||
/**
|
||||
* Loop through the AssetContainers to remove the pending assets marked for removal
|
||||
*
|
||||
*/
|
||||
void ProcessPendingRemovals();
|
||||
|
||||
AssetLibrary& operator=(const AssetLibrary& p_library) = default;
|
||||
AssetLibrary& operator=(AssetLibrary&& p_library) = delete;
|
||||
|
||||
~AssetLibrary() = default;
|
||||
|
||||
private:
|
||||
// All the asset containers
|
||||
ankerl::unordered_dense::map<AssetTypeID, AssetContainerBase*> m_assetContainers;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
// The global asset library for Bigfoot
|
||||
inline LazyGlobal<AssetLibrary> g_assetLibrary;
|
||||
|
||||
class ActiveAssetLibrary
|
||||
{
|
||||
public:
|
||||
ActiveAssetLibrary& operator=(AssetLibrary* p_assetLibrary)
|
||||
{
|
||||
Get() = p_assetLibrary;
|
||||
return *this;
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
AssetLibrary* operator->() const
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
[[nodiscard]]
|
||||
operator AssetLibrary*() const
|
||||
{
|
||||
return Get();
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Get the ActiveAssetLibrary
|
||||
*
|
||||
* \return The ActiveAssetLibrary
|
||||
*/
|
||||
[[nodiscard]]
|
||||
static AssetLibrary*& Get()
|
||||
{
|
||||
static AssetLibrary* activeLibrary = g_assetLibrary;
|
||||
return activeLibrary;
|
||||
}
|
||||
};
|
||||
|
||||
inline ActiveAssetLibrary g_activeAssetLibrary;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
/*
|
||||
* Set the active asset library
|
||||
*
|
||||
* \param p_assetLibrary The asset library to set g_activeAssetLibrary to.
|
||||
*/
|
||||
void SetActiveAssetLibrary(AssetLibrary* p_assetLibrary);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
class ScopedActiveAssetLibrary
|
||||
{
|
||||
public:
|
||||
ScopedActiveAssetLibrary(AssetLibrary* p_assetLibrary):
|
||||
m_previous(g_activeAssetLibrary)
|
||||
{
|
||||
SetActiveAssetLibrary(p_assetLibrary);
|
||||
}
|
||||
|
||||
ScopedActiveAssetLibrary(const ScopedActiveAssetLibrary& p_scopedActiveAssetLibrary) = delete;
|
||||
ScopedActiveAssetLibrary(ScopedActiveAssetLibrary&& p_scopedActiveAssetLibrary) = delete;
|
||||
|
||||
~ScopedActiveAssetLibrary()
|
||||
{
|
||||
SetActiveAssetLibrary(m_previous);
|
||||
}
|
||||
|
||||
ScopedActiveAssetLibrary& operator=(const ScopedActiveAssetLibrary& p_scopedActiveAssetLibrary) = delete;
|
||||
ScopedActiveAssetLibrary& operator=(ScopedActiveAssetLibrary&& p_scopedActiveAssetLibrary) = delete;
|
||||
|
||||
private:
|
||||
/*
|
||||
* The previously active asset library.
|
||||
*/
|
||||
AssetLibrary* m_previous = nullptr;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+2
-5
@@ -15,13 +15,10 @@ using AssetTypeID = std::uint64_t;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
namespace Flat
|
||||
{
|
||||
namespace Bigfoot
|
||||
namespace Flat::Bigfoot
|
||||
{
|
||||
struct AssetTypeID;
|
||||
}
|
||||
} // namespace Flat
|
||||
} // namespace Flat::Bigfoot
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
+6
-21
@@ -53,7 +53,6 @@ struct AssetHeaderT : public ::flatbuffers::NativeTable {
|
||||
eastl::string name{};
|
||||
::Bigfoot::AssetTypeID type_id{};
|
||||
eastl::string type_name{};
|
||||
uint32_t version = 0;
|
||||
};
|
||||
|
||||
struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
@@ -70,8 +69,7 @@ struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
VT_UUID = 4,
|
||||
VT_NAME = 6,
|
||||
VT_TYPE_ID = 8,
|
||||
VT_TYPE_NAME = 10,
|
||||
VT_VERSION = 12
|
||||
VT_TYPE_NAME = 10
|
||||
};
|
||||
const Flat::Bigfoot::UUID *uuid() const {
|
||||
return GetStruct<const Flat::Bigfoot::UUID *>(VT_UUID);
|
||||
@@ -85,9 +83,6 @@ struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
const ::flatbuffers::String *type_name() const {
|
||||
return GetPointer<const ::flatbuffers::String *>(VT_TYPE_NAME);
|
||||
}
|
||||
uint32_t version() const {
|
||||
return GetField<uint32_t>(VT_VERSION, 0);
|
||||
}
|
||||
template <bool B = false>
|
||||
bool Verify(::flatbuffers::VerifierTemplate<B> &verifier) const {
|
||||
return VerifyTableStart(verifier) &&
|
||||
@@ -97,7 +92,6 @@ struct AssetHeader FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table {
|
||||
VerifyFieldRequired<Flat::Bigfoot::AssetTypeID>(verifier, VT_TYPE_ID, 8) &&
|
||||
VerifyOffsetRequired(verifier, VT_TYPE_NAME) &&
|
||||
verifier.VerifyString(type_name()) &&
|
||||
VerifyField<uint32_t>(verifier, VT_VERSION, 4) &&
|
||||
verifier.EndTable();
|
||||
}
|
||||
AssetHeaderT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const;
|
||||
@@ -121,9 +115,6 @@ struct AssetHeaderBuilder {
|
||||
void add_type_name(::flatbuffers::Offset<::flatbuffers::String> type_name) {
|
||||
fbb_.AddOffset(AssetHeader::VT_TYPE_NAME, type_name);
|
||||
}
|
||||
void add_version(uint32_t version) {
|
||||
fbb_.AddElement<uint32_t>(AssetHeader::VT_VERSION, version, 0);
|
||||
}
|
||||
explicit AssetHeaderBuilder(::flatbuffers::FlatBufferBuilder &_fbb)
|
||||
: fbb_(_fbb) {
|
||||
start_ = fbb_.StartTable();
|
||||
@@ -144,10 +135,8 @@ inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(
|
||||
const Flat::Bigfoot::UUID *uuid = nullptr,
|
||||
::flatbuffers::Offset<::flatbuffers::String> name = 0,
|
||||
const Flat::Bigfoot::AssetTypeID *type_id = nullptr,
|
||||
::flatbuffers::Offset<::flatbuffers::String> type_name = 0,
|
||||
uint32_t version = 0) {
|
||||
::flatbuffers::Offset<::flatbuffers::String> type_name = 0) {
|
||||
AssetHeaderBuilder builder_(_fbb);
|
||||
builder_.add_version(version);
|
||||
builder_.add_type_name(type_name);
|
||||
builder_.add_type_id(type_id);
|
||||
builder_.add_name(name);
|
||||
@@ -167,7 +156,7 @@ struct AssetT : public ::flatbuffers::NativeTable {
|
||||
static FLATBUFFERS_CONSTEXPR_CPP11 const char *GetFullyQualifiedName() {
|
||||
return "Flat.Bigfoot.AssetT";
|
||||
}
|
||||
eastl::unique_ptr<Flat::Bigfoot::AssetHeaderT> header{};
|
||||
eastl::unique_ptr<Flat::Bigfoot::AssetHeaderT> header{new Flat::Bigfoot::AssetHeaderT()};
|
||||
eastl::vector<uint8_t> inner_asset{};
|
||||
AssetT() = default;
|
||||
AssetT(const AssetT &o);
|
||||
@@ -262,7 +251,6 @@ inline void AssetHeader::UnPackTo(AssetHeaderT *_o, const ::flatbuffers::resolve
|
||||
{ auto _e = name(); if (_e) _o->name = eastl::string(_e->c_str(), _e->size()); }
|
||||
{ auto _e = type_id(); if (_e) _o->type_id = ::flatbuffers::UnPack(*_e); }
|
||||
{ auto _e = type_name(); if (_e) _o->type_name = eastl::string(_e->c_str(), _e->size()); }
|
||||
{ auto _e = version(); _o->version = _e; }
|
||||
}
|
||||
|
||||
inline ::flatbuffers::Offset<AssetHeader> CreateAssetHeader(::flatbuffers::FlatBufferBuilder &_fbb, const AssetHeaderT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) {
|
||||
@@ -277,14 +265,12 @@ inline ::flatbuffers::Offset<AssetHeader> AssetHeader::Pack(::flatbuffers::FlatB
|
||||
auto _name = _fbb.CreateString(_o->name);
|
||||
auto _type_id = ::flatbuffers::Pack(_o->type_id);
|
||||
auto _type_name = _fbb.CreateString(_o->type_name);
|
||||
auto _version = _o->version;
|
||||
return Flat::Bigfoot::CreateAssetHeader(
|
||||
_fbb,
|
||||
&_uuid,
|
||||
_name,
|
||||
&_type_id,
|
||||
_type_name,
|
||||
_version);
|
||||
_type_name);
|
||||
}
|
||||
|
||||
inline AssetT::AssetT(const AssetT &o)
|
||||
@@ -332,15 +318,14 @@ inline const ::flatbuffers::TypeTable *AssetHeaderTypeTable() {
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 0 },
|
||||
{ ::flatbuffers::ET_STRING, 0, -1 },
|
||||
{ ::flatbuffers::ET_SEQUENCE, 0, 1 },
|
||||
{ ::flatbuffers::ET_STRING, 0, -1 },
|
||||
{ ::flatbuffers::ET_UINT, 0, -1 }
|
||||
{ ::flatbuffers::ET_STRING, 0, -1 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Flat::Bigfoot::UUIDTypeTable,
|
||||
Flat::Bigfoot::AssetTypeIDTypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_TABLE, 5, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
::flatbuffers::ST_TABLE, 4, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
+65
-49
@@ -6,11 +6,11 @@
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ASSET_REFERENCE_HPP
|
||||
#define BIGFOOT_ENGINE_ASSET_REFERENCE_HPP
|
||||
#include <Engine/Asset/AssetConcepts.hpp>
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <type_traits>
|
||||
#include <utility>
|
||||
|
||||
namespace Bigfoot
|
||||
@@ -18,25 +18,45 @@ namespace Bigfoot
|
||||
template<class ASSET>
|
||||
AssetTypeID GetAssetTypeID();
|
||||
|
||||
template<>
|
||||
AssetTypeID GetAssetTypeID<AssetBase>() = delete;
|
||||
|
||||
template<class DERIVED, class ASSET>
|
||||
class ReferenceBase
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Get the UUID of the reference
|
||||
*
|
||||
* \return The UUID of the reference
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const UUID& GetUUID() const
|
||||
{
|
||||
return m_uuid;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the asset
|
||||
*
|
||||
* \return The asset, nullptr if it is not loaded
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const ASSET* Get() const
|
||||
{
|
||||
static_assert(AssetType<ASSET>, "ASSET must derive from AssetBase (and not be AssetBase itself)");
|
||||
return m_handle ? static_cast<const ASSET*>(m_handle->GetAsset()) : nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the asset
|
||||
*
|
||||
* \return The asset, nullptr if it is not loaded
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ASSET* Get()
|
||||
{
|
||||
static_assert(AssetType<ASSET>, "ASSET must derive from AssetBase (and not be AssetBase itself)");
|
||||
return m_handle ? static_cast<ASSET*>(m_handle->GetAsset()) : nullptr;
|
||||
}
|
||||
|
||||
@@ -74,7 +94,9 @@ class ReferenceBase
|
||||
return m_uuid == p_reference.m_uuid;
|
||||
}
|
||||
|
||||
protected:
|
||||
private:
|
||||
friend DERIVED;
|
||||
|
||||
ReferenceBase() = default;
|
||||
|
||||
ReferenceBase(const UUID& p_uuid):
|
||||
@@ -96,7 +118,11 @@ class ReferenceBase
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Get the associated handle container for the asset
|
||||
* Register the reference inside the handle
|
||||
*
|
||||
*/
|
||||
void Acquire()
|
||||
{
|
||||
if (!m_uuid)
|
||||
@@ -104,45 +130,44 @@ class ReferenceBase
|
||||
return;
|
||||
}
|
||||
|
||||
// AssetBase has no AssetContainer of its own (it's not a concrete, loadable type): a
|
||||
// Hard/SoftReference<AssetBase> can point at an asset of any type, so its container has to be
|
||||
// found from the UUID alone rather than via the usual static GetAssetTypeID<ASSET>() lookup. This
|
||||
// only finds assets that are already loaded somewhere - see AssetLibrary::FindContainerForUUID.
|
||||
AssetContainerBase* assetContainer;
|
||||
if constexpr (std::is_same_v<ASSET, AssetBase>)
|
||||
{
|
||||
assetContainer = g_activeAssetLibrary->FindContainerForUUID(m_uuid);
|
||||
}
|
||||
else
|
||||
{
|
||||
assetContainer = g_activeAssetLibrary->GetAssetContainer(GetAssetTypeID<ASSET>());
|
||||
}
|
||||
|
||||
if (assetContainer)
|
||||
if (AssetContainerBase* assetContainer = g_activeAssetLibrary->GetAssetContainer(GetAssetTypeID<ASSET>()))
|
||||
{
|
||||
if (!m_handle)
|
||||
{
|
||||
m_handle = assetContainer->AcquireContainerHandle(m_uuid);
|
||||
}
|
||||
DERIVED::IncrementCount(*m_handle);
|
||||
DERIVED::OnCountIncremented(m_uuid, *m_handle);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister the reference from the handle
|
||||
*
|
||||
*/
|
||||
void Release()
|
||||
{
|
||||
if (m_handle)
|
||||
{
|
||||
DERIVED::DecrementCount(*m_handle);
|
||||
DERIVED::OnCountDecremented(m_uuid, *m_handle);
|
||||
m_handle = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* The UUID
|
||||
*/
|
||||
UUID m_uuid = UUID::NULL_UUID;
|
||||
|
||||
/**
|
||||
* Handle for the asset
|
||||
*/
|
||||
ContainerHandle* m_handle = nullptr;
|
||||
};
|
||||
|
||||
/*
|
||||
* Owning reference
|
||||
* Keeps the asset alive
|
||||
*/
|
||||
template<class ASSET>
|
||||
class HardReference: public ReferenceBase<HardReference<ASSET>, ASSET>
|
||||
{
|
||||
@@ -157,34 +182,26 @@ class HardReference: public ReferenceBase<HardReference<ASSET>, ASSET>
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Increment the hard ref count of the handle
|
||||
*
|
||||
* \param p_handle The handle for the asset
|
||||
*/
|
||||
static void IncrementCount(ContainerHandle& p_handle)
|
||||
{
|
||||
p_handle.IncrementHardRefCount();
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrement the hard ref count of the handle
|
||||
*
|
||||
* \param p_handle The handle for the asset
|
||||
*/
|
||||
static void DecrementCount(ContainerHandle& p_handle)
|
||||
{
|
||||
p_handle.DecrementHardRefCount();
|
||||
}
|
||||
|
||||
// Registers p_uuid as a candidate for SerializationManager::RemoveUnreferencedAssets once the last
|
||||
// HardReference pointing at it is released - instead of that having to scan every loaded asset to
|
||||
// find the ones nothing holds a HardReference to anymore.
|
||||
static void OnCountDecremented(const UUID& p_uuid, const ContainerHandle& p_handle)
|
||||
{
|
||||
if (p_handle.GetHardRefCount() == 0)
|
||||
{
|
||||
g_activeAssetLibrary->MarkUnreferenced(p_uuid);
|
||||
}
|
||||
}
|
||||
|
||||
// A new HardReference to p_uuid means it's no longer a candidate for removal, even if it was
|
||||
// previously marked (its count had reached zero before, but has since been acquired again).
|
||||
static void OnCountIncremented(const UUID& p_uuid, const ContainerHandle&)
|
||||
{
|
||||
g_activeAssetLibrary->UnmarkUnreferenced(p_uuid);
|
||||
}
|
||||
|
||||
friend Base;
|
||||
};
|
||||
|
||||
@@ -202,27 +219,26 @@ class SoftReference: public ReferenceBase<SoftReference<ASSET>, ASSET>
|
||||
}
|
||||
|
||||
private:
|
||||
/**
|
||||
* Increment the soft ref count of the handle
|
||||
*
|
||||
* \param p_handle The handle for the asset
|
||||
*/
|
||||
static void IncrementCount(ContainerHandle& p_handle)
|
||||
{
|
||||
p_handle.IncrementSoftRefCount();
|
||||
}
|
||||
|
||||
/**
|
||||
* Decrement the hard ref count of the handle
|
||||
*
|
||||
* \param p_handle The handle for the asset
|
||||
*/
|
||||
static void DecrementCount(ContainerHandle& p_handle)
|
||||
{
|
||||
p_handle.DecrementSoftRefCount();
|
||||
}
|
||||
|
||||
// SoftReferences don't keep an asset alive, so releasing one is never a reason to consider the asset
|
||||
// for removal.
|
||||
static void OnCountDecremented(const UUID&, const ContainerHandle&)
|
||||
{
|
||||
}
|
||||
|
||||
// SoftReferences don't affect removal eligibility - only HardReference does.
|
||||
static void OnCountIncremented(const UUID&, const ContainerHandle&)
|
||||
{
|
||||
}
|
||||
|
||||
friend Base;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
+122
-61
@@ -6,20 +6,24 @@
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_BIGFILE_BIGFILE_HPP
|
||||
#define BIGFOOT_ENGINE_BIGFILE_BIGFILE_HPP
|
||||
#include <System/File.hpp>
|
||||
#include <Engine/DataAccessor/DataAccessor.hpp>
|
||||
|
||||
#include <System/File/File.hpp>
|
||||
#include <System/Time/Time.hpp>
|
||||
|
||||
#include <Utils/TaggedType.hpp>
|
||||
|
||||
#include <EASTL/optional.h>
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <ankerl/unordered_dense.h>
|
||||
#include <EASTL/string_view.h>
|
||||
#include <sqlite3.h>
|
||||
|
||||
#include <string>
|
||||
#include <span>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class BigFile
|
||||
#ifdef BIGFOOT_TOOLMODE
|
||||
class BigFile: public DataAccessor
|
||||
{
|
||||
public:
|
||||
/**
|
||||
@@ -50,7 +54,107 @@ class BigFile
|
||||
*/
|
||||
void RollbackTransaction();
|
||||
|
||||
~BigFile();
|
||||
/**
|
||||
* Clear the BigFile
|
||||
*
|
||||
*/
|
||||
void Clear();
|
||||
|
||||
~BigFile() override;
|
||||
|
||||
/**
|
||||
* Get an Asset flatbuffer
|
||||
*
|
||||
* \param p_uuid The asset to get the flatbuffer of
|
||||
* \return The flatbuffer, or an empty vector if the asset was not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<std::byte> GetAssetFlatbuffer(const UUID& p_uuid) const override;
|
||||
|
||||
/**
|
||||
* Get several Asset flatbuffers
|
||||
*
|
||||
* \param p_uuids The assets to get the flatbuffers of
|
||||
* \return The flatbuffers that were found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<std::byte>> GetAssetFlatbuffers(eastl::span<const UUID> p_uuids) const override;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of a given asset
|
||||
*
|
||||
* \param p_uuid The asset to get the HardReferences of
|
||||
* \return The HardReferences of the asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> GetAssetHardReferences(const UUID& p_uuid) const override;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of given assets
|
||||
*
|
||||
* \param p_uuids The assets to get the HardReferences of
|
||||
* \return The HardReferences of the assets
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<UUID>> GetAssetsHardReferences(eastl::span<const UUID> p_uuids) const override;
|
||||
|
||||
struct AssetTime
|
||||
{
|
||||
Time m_creationTime;
|
||||
Time m_modificationTime;
|
||||
|
||||
[[nodiscard]]
|
||||
bool operator==(const AssetTime& p_other) const = default;
|
||||
};
|
||||
|
||||
/**
|
||||
* Get the creation and modification time of an asset
|
||||
*
|
||||
* \param p_uuid The asset to get the time of
|
||||
* \return The time of the asset, nullopt if the asset was not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::optional<AssetTime> GetAssetTime(const UUID& p_uuid) const;
|
||||
|
||||
/**
|
||||
* Get the creation and modification time of several assets
|
||||
*
|
||||
* \param p_uuids The assets to get the time of
|
||||
* \return The time of the assets. nullopt for assets not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::optional<AssetTime>> GetAssetsTime(eastl::span<const UUID> p_uuids) const;
|
||||
|
||||
/**
|
||||
* Save an asset
|
||||
*
|
||||
* \param p_uuid The UUID
|
||||
* \param p_flatbuffer The flatbuffer of the asset
|
||||
* \param p_hardReferences The HardReferences the asset points to
|
||||
*/
|
||||
void SaveAssetFlatbuffer(const UUID& p_uuid,
|
||||
const eastl::span<const std::byte> p_flatbuffer,
|
||||
const eastl::span<const UUID> p_hardReferences) override;
|
||||
|
||||
/**
|
||||
* Save several assets
|
||||
*
|
||||
* \param p_uuids The UUIDs
|
||||
* \param p_flatbuffers The flatbuffers of the assets, matching p_metadatas by index
|
||||
* \param p_hardReferences The HardReferences the asset points to
|
||||
*/
|
||||
void SaveAssetFlatbuffers(const eastl::span<const UUID> p_uuids,
|
||||
const eastl::span<const eastl::vector<std::byte>> p_flatbuffers,
|
||||
const eastl::span<const eastl::vector<UUID>> p_hardReferences) override;
|
||||
|
||||
/**
|
||||
* Check if the Asset exists
|
||||
*
|
||||
* \param p_uuid The asset to check
|
||||
* \param True if it exists, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool Has(const UUID& p_uuid) const override;
|
||||
|
||||
BigFile& operator=(const BigFile& p_bigFile) = delete;
|
||||
BigFile& operator=(BigFile&& p_bigFile) = delete;
|
||||
@@ -144,7 +248,7 @@ class BigFile
|
||||
/*
|
||||
* Step through the request
|
||||
*
|
||||
* \return True if the request can continue (get next row), false otherwise
|
||||
* \return True if a row is available to read via Get(), false once the statement is done
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool Step();
|
||||
@@ -152,7 +256,7 @@ class BigFile
|
||||
/*
|
||||
* Execute the request once
|
||||
*
|
||||
* The number of modified rows
|
||||
* \return The number of rows modified by the statement
|
||||
*/
|
||||
[[maybe_unused]]
|
||||
std::uint32_t Execute();
|
||||
@@ -168,14 +272,6 @@ class BigFile
|
||||
*/
|
||||
Column(const Request& p_request, const std::uint32_t p_index);
|
||||
|
||||
Column(const Column& p_column) = default;
|
||||
Column(Column&& p_column) = default;
|
||||
|
||||
~Column() = default;
|
||||
|
||||
Column& operator=(const Column& p_column) = default;
|
||||
Column& operator=(Column&& p_column) = default;
|
||||
|
||||
/*
|
||||
* Get value as a int32
|
||||
*
|
||||
@@ -232,6 +328,13 @@ class BigFile
|
||||
*/
|
||||
operator eastl::span<const std::byte>() const;
|
||||
|
||||
/*
|
||||
* Get value as a blob
|
||||
*
|
||||
* \return The value
|
||||
*/
|
||||
operator std::span<const std::byte>() const;
|
||||
|
||||
private:
|
||||
/*
|
||||
* The statement
|
||||
@@ -263,61 +366,19 @@ class BigFile
|
||||
*/
|
||||
sqlite3* m_db;
|
||||
|
||||
/*
|
||||
* The BigFile this statement was acquired from - kept only to return the statement to its pool
|
||||
* (see BigFile::ReleaseStatement) on destruction.
|
||||
*/
|
||||
const BigFile* m_owner;
|
||||
|
||||
/*
|
||||
* The query text this statement was prepared from - identifies which pool bucket to return it to.
|
||||
*/
|
||||
eastl::string_view m_queryText;
|
||||
|
||||
/*
|
||||
* The statement
|
||||
*/
|
||||
sqlite3_stmt* m_statement;
|
||||
sqlite3_stmt* m_statement = nullptr;
|
||||
};
|
||||
|
||||
private:
|
||||
/*
|
||||
* Borrows a compiled statement for p_query: an idle one from m_statementPool if one's available,
|
||||
* freshly prepared otherwise. Pooled per query text rather than cached as a single instance per text
|
||||
* because SerializationManager::LoadAsset recurses: a nested call for the same query text must get
|
||||
* its own statement, not reset the one an ancestor call further up the stack is still stepping
|
||||
* through.
|
||||
*
|
||||
* \param p_query The query text to get a statement for
|
||||
* \return A statement ready to bind and step, reset to its start state
|
||||
*/
|
||||
[[nodiscard]]
|
||||
sqlite3_stmt* AcquireStatement(const eastl::string_view p_query) const;
|
||||
|
||||
/*
|
||||
* Returns a statement borrowed via AcquireStatement to its pool, for the next AcquireStatement(p_query)
|
||||
* to reuse instead of recompiling.
|
||||
*
|
||||
* \param p_query The query text p_statement was acquired for
|
||||
* \param p_statement The statement to return
|
||||
*/
|
||||
void ReleaseStatement(const eastl::string_view p_query, sqlite3_stmt* p_statement) const;
|
||||
|
||||
/**
|
||||
* The BigFile DB
|
||||
*/
|
||||
sqlite3* m_db;
|
||||
|
||||
/*
|
||||
* Idle, already-compiled statements, keyed by their query text and reused by AcquireStatement/
|
||||
* ReleaseStatement instead of recompiling identical SQL on every BigFile::Request. Mutable: acquiring/
|
||||
* releasing a statement doesn't change what a BigFile logically contains, only this cache of it -
|
||||
* every BigFile::Request constructor takes a const BigFile&. Keyed by std::string rather than
|
||||
* eastl::string: no std::hash<eastl::string> specialization exists for ankerl::unordered_dense to key
|
||||
* off of, and this cache is purely a private implementation detail.
|
||||
*/
|
||||
mutable ankerl::unordered_dense::segmented_map<std::string, eastl::vector<sqlite3_stmt*>> m_statementPool;
|
||||
sqlite3* m_db = nullptr;
|
||||
};
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+3
@@ -9,6 +9,8 @@
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
|
||||
#if defined BIGFOOT_TOOLMODE
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
@@ -16,4 +18,5 @@ namespace Bigfoot
|
||||
*/
|
||||
constexpr eastl::string_view BIGFILE_@BIGFILE_NAME@_LOCATION {"@BIGFILE_LOCATION@"};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,145 @@
|
||||
/*********************************************************************
|
||||
* \file DataAccessor.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_DATAACCESSOR_DATAACCESSOR_HPP
|
||||
#define BIGFOOT_ENGINE_DATAACCESSOR_DATAACCESSOR_HPP
|
||||
#include <Engine/Asset/AssetTypeID.hpp>
|
||||
|
||||
#include <System/Time/Time.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/string.h>
|
||||
#include <EASTL/vector.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class DataAccessor
|
||||
{
|
||||
public:
|
||||
DataAccessor() = default;
|
||||
|
||||
DataAccessor(const DataAccessor& p_accessor) = default;
|
||||
DataAccessor(DataAccessor&& p_accessor) = default;
|
||||
|
||||
virtual ~DataAccessor() = default;
|
||||
|
||||
/**
|
||||
* Get an Asset flatbuffer
|
||||
*
|
||||
* \param p_uuid The asset to get the flatbuffer of
|
||||
* \return The flatbuffer, or an empty vector if the asset was not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<std::byte> GetAssetFlatbuffer(const UUID& p_uuid) const = 0;
|
||||
|
||||
/**
|
||||
* Get several Asset flatbuffers
|
||||
*
|
||||
* \param p_uuids The assets to get the flatbuffers of
|
||||
* \return The flatbuffers that were found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<eastl::vector<std::byte>> GetAssetFlatbuffers(eastl::span<const UUID> p_uuids) const = 0;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of a given asset
|
||||
*
|
||||
* \param p_uuid The asset to get the HardReferences of
|
||||
* \return The HardReferences of the asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<UUID> GetAssetHardReferences(const UUID& p_uuid) const = 0;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of given assets
|
||||
*
|
||||
* \param p_uuids The assets to get the HardReferences of
|
||||
* \return The HardReferences of the assets
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual eastl::vector<eastl::vector<UUID>> GetAssetsHardReferences(eastl::span<const UUID> p_uuids) const = 0;
|
||||
|
||||
/**
|
||||
* Save an asset
|
||||
*
|
||||
* \param p_uuid The UUID
|
||||
* \param p_flatbuffer The flatbuffer of the asset
|
||||
* \param p_hardReferences The HardReferences the asset points to
|
||||
*/
|
||||
virtual void SaveAssetFlatbuffer(const UUID& p_uuid,
|
||||
const eastl::span<const std::byte> p_flatbuffer,
|
||||
const eastl::span<const UUID> p_hardReferences) = 0;
|
||||
|
||||
/**
|
||||
* Save several assets
|
||||
*
|
||||
* \param p_uuids The UUIDs
|
||||
* \param p_flatbuffers The flatbuffers of the assets, matching p_metadatas by index
|
||||
* \param p_hardReferences The HardReferences the asset points to
|
||||
*/
|
||||
virtual void SaveAssetFlatbuffers(const eastl::span<const UUID> p_uuids,
|
||||
const eastl::span<const eastl::vector<std::byte>> p_flatbuffers,
|
||||
const eastl::span<const eastl::vector<UUID>> p_hardReferences) = 0;
|
||||
|
||||
/**
|
||||
* Check if the Asset exists
|
||||
*
|
||||
* \param p_uuid The asset to check
|
||||
* \param True if it exists, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual bool Has(const UUID& p_uuid) const = 0;
|
||||
|
||||
DataAccessor& operator=(const DataAccessor& p_accessor) = default;
|
||||
DataAccessor& operator=(DataAccessor&& p_accessor) = default;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
// The global data accessor for Bigfoot
|
||||
inline DataAccessor* g_dataAccessor = nullptr;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
/*
|
||||
* Set the data accessor
|
||||
*
|
||||
* \param p_dataAccessor The data accessor to set g_dataAccessor to.
|
||||
*/
|
||||
void SetDataAccessor(DataAccessor* p_dataAccessor);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
class ScopedDataAccessor
|
||||
{
|
||||
public:
|
||||
ScopedDataAccessor(DataAccessor* p_dataAccessor):
|
||||
m_previous(g_dataAccessor)
|
||||
{
|
||||
SetDataAccessor(p_dataAccessor);
|
||||
}
|
||||
|
||||
ScopedDataAccessor(const ScopedDataAccessor& p_scopedDataAccessor) = delete;
|
||||
ScopedDataAccessor(ScopedDataAccessor&& p_scopedDataAccessor) = delete;
|
||||
|
||||
~ScopedDataAccessor()
|
||||
{
|
||||
SetDataAccessor(m_previous);
|
||||
}
|
||||
|
||||
ScopedDataAccessor& operator=(const ScopedDataAccessor& p_scopedDataAccessor) = delete;
|
||||
ScopedDataAccessor& operator=(ScopedDataAccessor&& p_scopedDataAccessor) = delete;
|
||||
|
||||
private:
|
||||
/*
|
||||
* The previous data accessor.
|
||||
*/
|
||||
DataAccessor* m_previous = nullptr;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+3
-3
@@ -6,11 +6,11 @@
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
|
||||
#define BIGFOOT_ENGINE_ENGINEASSERTHANDLER_HPP
|
||||
#include <Engine/EngineLogger_generated.hpp>
|
||||
|
||||
#include <Utils/Assert/AssertHandler.hpp>
|
||||
|
||||
#if defined BIGFOOT_NOT_OPTIMIZED
|
||||
#include <Engine/EngineLogger_generated.hpp>
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
+1
-1
@@ -15,7 +15,7 @@ namespace Bigfoot
|
||||
/*
|
||||
* Logger
|
||||
*/
|
||||
inline Log::LoggerInfo ENGINE_LOGGER {"ENGINE_LOGGER", Flat::LogLevel::Trace};
|
||||
inline Log::LoggerInfo ENGINE_LOGGER { .m_name = "ENGINE_LOGGER", .m_level = LogLevel::Trace};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,243 @@
|
||||
/*********************************************************************
|
||||
* \file Sasquatch.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_SASQUATCH_SASQUATCH_HPP
|
||||
#define BIGFOOT_ENGINE_SASQUATCH_SASQUATCH_HPP
|
||||
#include <Engine/DataAccessor/DataAccessor.hpp>
|
||||
|
||||
#include <System/File/File.hpp>
|
||||
#include <System/File/MemoryMappedFile.hpp>
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
#include <EASTL/vector.h>
|
||||
#include <ankerl/unordered_dense.h>
|
||||
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
#include <type_traits>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct SasquatchHeader
|
||||
{
|
||||
static constexpr std::uint32_t MAGIC = 0x53515443; // 'SQTC'
|
||||
static constexpr std::uint32_t VERSION = 1;
|
||||
|
||||
std::uint32_t m_magic = MAGIC;
|
||||
std::uint32_t m_version = VERSION;
|
||||
std::uint64_t m_assetCount = 0;
|
||||
};
|
||||
|
||||
static_assert(std::is_trivially_copyable_v<SasquatchHeader>);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
struct SasquatchEntry
|
||||
{
|
||||
std::array<std::byte, UUID::UUID_BYTE_SIZE> m_uuid {};
|
||||
|
||||
std::size_t m_assetOffset = 0;
|
||||
std::size_t m_assetSize = 0;
|
||||
|
||||
std::size_t m_hardReferencesOffset = 0;
|
||||
std::size_t m_hardReferencesSize = 0;
|
||||
};
|
||||
|
||||
static_assert(std::is_trivially_copyable_v<SasquatchEntry>);
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
#if defined(BIGFOOT_TOOLMODE) || defined(BIGFOOT_BUILD_TESTS) || defined(BIGFOOT_BUILD_BENCHMARKS)
|
||||
class SasquatchWriter
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Constructor
|
||||
* Writes the header
|
||||
*
|
||||
* \param p_file The file to write
|
||||
* \param p_assetCount The number of assets that will be written
|
||||
* \param p_totalFlatbufferBytes The sum of the sizes of every flatbuffer that will be written
|
||||
* \param p_totalHardReferencesBytes The sum of the sizes of every asset hardreferences that will be written
|
||||
*/
|
||||
SasquatchWriter(const File& p_file,
|
||||
const std::uint64_t p_assetCount,
|
||||
const std::size_t p_totalFlatbufferBytes,
|
||||
const std::size_t p_totalHardReferencesBytes);
|
||||
|
||||
SasquatchWriter(const SasquatchWriter& p_writer) = delete;
|
||||
SasquatchWriter(SasquatchWriter&& p_writer) = delete;
|
||||
|
||||
/**
|
||||
* Destructor
|
||||
* Writes the entries
|
||||
*
|
||||
*/
|
||||
~SasquatchWriter();
|
||||
|
||||
/**
|
||||
* Writes an asset to the file.
|
||||
*
|
||||
* \param p_uuid The UUID of the asset
|
||||
* \param p_flatbuffer The flatbuffer of the asset
|
||||
*/
|
||||
void WriteAsset(const UUID& p_uuid,
|
||||
eastl::span<const std::byte> p_flatbuffer,
|
||||
eastl::span<const UUID> p_hardReferences);
|
||||
|
||||
SasquatchWriter& operator=(const SasquatchWriter& p_writer) = delete;
|
||||
SasquatchWriter& operator=(SasquatchWriter&& p_writer) = delete;
|
||||
|
||||
private:
|
||||
static constexpr std::uint64_t PREFETCH_BYTES = 4ULL * 1024 * 1024;
|
||||
|
||||
/**
|
||||
* The number of assets expected
|
||||
*/
|
||||
std::uint64_t m_assetCount;
|
||||
|
||||
/**
|
||||
* How far into m_file has already been prefetched
|
||||
*/
|
||||
std::size_t m_prefetchedUpTo = 0;
|
||||
|
||||
/**
|
||||
* Current write position in the data region
|
||||
*/
|
||||
std::size_t m_currentDataOffset;
|
||||
|
||||
/**
|
||||
* The Sasquatch file being written, mapped at its final size
|
||||
*/
|
||||
WritableMemoryMappedFile m_file;
|
||||
|
||||
/**
|
||||
* The entries
|
||||
*/
|
||||
eastl::vector<SasquatchEntry> m_entries;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
class Sasquatch: public DataAccessor
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Constructor
|
||||
*
|
||||
* \param p_file The sasquatch file
|
||||
*/
|
||||
Sasquatch(const File& p_file);
|
||||
|
||||
Sasquatch(const Sasquatch& p_sasquatch) = delete;
|
||||
Sasquatch(Sasquatch&& p_sasquatch) = delete;
|
||||
|
||||
~Sasquatch() override = default;
|
||||
|
||||
/**
|
||||
* Get the header
|
||||
*
|
||||
* \return The header
|
||||
*/
|
||||
[[nodiscard]]
|
||||
const SasquatchHeader& GetHeader() const;
|
||||
|
||||
/**
|
||||
* Get an Asset flatbuffer
|
||||
*
|
||||
* \param p_uuid The asset to get the flatbuffer of
|
||||
* \return The flatbuffer, or an empty vector if the asset was not found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<std::byte> GetAssetFlatbuffer(const UUID& p_uuid) const override;
|
||||
|
||||
/**
|
||||
* Get several Asset flatbuffers
|
||||
*
|
||||
* \param p_uuids The assets to get the flatbuffers of
|
||||
* \return The flatbuffers that were found
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<std::byte>> GetAssetFlatbuffers(eastl::span<const UUID> p_uuids) const override;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of a given asset
|
||||
*
|
||||
* \param p_uuid The asset to get the HardReferences of
|
||||
* \return The HardReferences of the asset
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> GetAssetHardReferences(const UUID& p_uuid) const override;
|
||||
|
||||
/**
|
||||
* Get the HardReferences of given assets
|
||||
*
|
||||
* \param p_uuids The assets to get the HardReferences of
|
||||
* \return The HardReferences of the assets
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<eastl::vector<UUID>> GetAssetsHardReferences(eastl::span<const UUID> p_uuids) const override;
|
||||
|
||||
/**
|
||||
* Sasquatch is read-only: this will always fail
|
||||
*
|
||||
*/
|
||||
void SaveAssetFlatbuffer(const UUID& p_uuid,
|
||||
eastl::span<const std::byte> p_flatbuffer,
|
||||
eastl::span<const UUID> p_hardReferences) override;
|
||||
|
||||
/**
|
||||
* Sasquatch is read-only: this will always fail
|
||||
*
|
||||
*/
|
||||
void SaveAssetFlatbuffers(const eastl::span<const UUID> p_uuids,
|
||||
eastl::span<const eastl::vector<std::byte>> p_flatbuffers,
|
||||
eastl::span<const eastl::vector<UUID>> p_hardReferences) override;
|
||||
|
||||
/**
|
||||
* Check if the Asset exists
|
||||
*
|
||||
* \param p_uuid The asset to check
|
||||
* \param True if it exists, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool Has(const UUID& p_uuid) const override;
|
||||
|
||||
Sasquatch& operator=(const Sasquatch& p_sasquatch) = delete;
|
||||
Sasquatch& operator=(Sasquatch&& p_sasquatch) = delete;
|
||||
|
||||
private:
|
||||
struct Entry
|
||||
{
|
||||
std::size_t m_assetOffset = 0;
|
||||
std::size_t m_assetSize = 0;
|
||||
|
||||
std::size_t m_hardReferencesOffset = 0;
|
||||
std::size_t m_hardReferencesSize = 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* The Sasquatch file
|
||||
*/
|
||||
MemoryMappedFile m_file;
|
||||
|
||||
/**
|
||||
* The sasquatch header
|
||||
*/
|
||||
SasquatchHeader m_header;
|
||||
|
||||
/**
|
||||
* UUID to entry
|
||||
*/
|
||||
ankerl::unordered_dense::map<UUID, Entry> m_entries;
|
||||
};
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,22 @@
|
||||
@AUTO_GENERATED_COMMENT@
|
||||
|
||||
/*********************************************************************
|
||||
* \file SasquatchInfo.generated.hpp
|
||||
*
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_@SASQUATCH_NAME@_SASQUATCHINFO_GENERATED_HPP
|
||||
#define BIGFOOT_@SASQUATCH_NAME@_SASQUATCHINFO_GENERATED_HPP
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
|
||||
#if defined BIGFOOT_GAME
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
* Sasquatch location
|
||||
*/
|
||||
constexpr eastl::string_view SASQUATCH_@SASQUATCH_NAME@_LOCATION {"@SASQUATCH_LOCATION@"};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,54 @@
|
||||
/*********************************************************************
|
||||
* \file SerializationManager.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_ENGINE_SERIALIZATIONMANAGER_SERIALIZATIONMANAGER_HPP
|
||||
#define BIGFOOT_ENGINE_SERIALIZATIONMANAGER_SERIALIZATIONMANAGER_HPP
|
||||
#include <System/UUID/UUID.hpp>
|
||||
|
||||
#include <EASTL/span.h>
|
||||
|
||||
namespace Bigfoot::SerializationManager
|
||||
{
|
||||
/**
|
||||
* Load an Asset, along with every HardReference it transitively points to
|
||||
* Already loaded assets are skipped. Assets that are part of a cyclic dependency are left unloaded
|
||||
*
|
||||
* \param p_uuid The asset to load
|
||||
*/
|
||||
void LoadAsset(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Load several Assets, along with every HardReference they transitively point to
|
||||
* Already loaded assets are skipped. Assets that are part of a cyclic dependency are left unloaded
|
||||
*
|
||||
* \param p_uuids The assets to load
|
||||
*/
|
||||
void LoadAssets(const eastl::span<const UUID> p_uuids);
|
||||
|
||||
#ifdef BIGFOOT_TOOLMODE
|
||||
/**
|
||||
* Save an Asset
|
||||
* Fails without saving if a cyclic dependency is detected starting from this asset
|
||||
*
|
||||
* \param p_uuid The asset to save
|
||||
* \return True if the asset was saved, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool SaveAsset(const UUID& p_uuid);
|
||||
|
||||
/**
|
||||
* Save several Assets
|
||||
* Fails without saving any of them if a cyclic dependency is detected starting from any of them
|
||||
*
|
||||
* \param p_uuids The assets to save
|
||||
* \return True if the assets were saved, false otherwise
|
||||
*/
|
||||
[[nodiscard]]
|
||||
bool SaveAssets(const eastl::span<const UUID> p_uuids);
|
||||
#endif
|
||||
} // namespace Bigfoot::SerializationManager
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,266 @@
|
||||
/*********************************************************************
|
||||
* \file Sasquatch.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/Sasquatch/Sasquatch.hpp>
|
||||
|
||||
#include <Engine/EngineAssertHandler.hpp>
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
#if defined(BIGFOOT_TOOLMODE) || defined(BIGFOOT_BUILD_TESTS) || defined(BIGFOOT_BUILD_BENCHMARKS)
|
||||
SasquatchWriter::SasquatchWriter(const File& p_file,
|
||||
const std::uint64_t p_assetCount,
|
||||
const std::size_t p_totalFlatbufferBytes,
|
||||
const std::size_t p_totalHardReferencesBytes):
|
||||
m_assetCount(p_assetCount),
|
||||
m_currentDataOffset(sizeof(SasquatchHeader) + (m_assetCount * sizeof(SasquatchEntry))),
|
||||
m_file(p_file,
|
||||
sizeof(SasquatchHeader) + (m_assetCount * sizeof(SasquatchEntry)) + p_totalFlatbufferBytes +
|
||||
p_totalHardReferencesBytes)
|
||||
{
|
||||
m_entries.reserve(m_assetCount);
|
||||
|
||||
SasquatchHeader header;
|
||||
header.m_assetCount = m_assetCount;
|
||||
|
||||
std::memcpy(m_file.GetData().data(), &header, sizeof(SasquatchHeader));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
SasquatchWriter::~SasquatchWriter()
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
m_entries.size() == m_assetCount,
|
||||
"SasquatchWriter expected {} assets, only {} were added",
|
||||
m_assetCount,
|
||||
m_entries.size());
|
||||
|
||||
m_file.Prefetch(sizeof(SasquatchHeader), m_entries.size() * sizeof(SasquatchEntry));
|
||||
|
||||
if (!m_entries.empty())
|
||||
{
|
||||
std::memcpy(m_file.GetData().data() + sizeof(SasquatchHeader),
|
||||
m_entries.data(),
|
||||
m_entries.size() * sizeof(SasquatchEntry));
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void SasquatchWriter::WriteAsset(const UUID& p_uuid,
|
||||
eastl::span<const std::byte> p_flatbuffer,
|
||||
eastl::span<const UUID> p_hardReferences)
|
||||
{
|
||||
ASSERT(EngineAssertHandler,
|
||||
m_entries.size() < m_assetCount,
|
||||
"SasquatchWriter can only hold {} assets",
|
||||
m_assetCount);
|
||||
|
||||
const std::size_t offset = m_currentDataOffset;
|
||||
|
||||
const eastl::span<std::byte> data = m_file.GetData();
|
||||
ASSERT(EngineAssertHandler,
|
||||
offset + p_flatbuffer.size() + (p_hardReferences.size() * UUID::UUID_BYTE_SIZE) <= data.size(),
|
||||
"SasquatchWriter can only write {} bytes",
|
||||
data.size());
|
||||
|
||||
const std::size_t writeEnd = offset + p_flatbuffer.size() + (p_hardReferences.size() * UUID::UUID_BYTE_SIZE);
|
||||
if (writeEnd > m_prefetchedUpTo)
|
||||
{
|
||||
const std::size_t prefetchEnd = std::min(writeEnd + PREFETCH_BYTES, data.size());
|
||||
m_file.Prefetch(m_prefetchedUpTo, prefetchEnd - m_prefetchedUpTo);
|
||||
m_prefetchedUpTo = prefetchEnd;
|
||||
}
|
||||
|
||||
SasquatchEntry entry;
|
||||
std::memcpy(entry.m_uuid.data(), p_uuid.ToBytes().data(), UUID::UUID_BYTE_SIZE);
|
||||
entry.m_assetOffset = offset;
|
||||
entry.m_assetSize = p_flatbuffer.size();
|
||||
entry.m_hardReferencesOffset = entry.m_assetOffset + entry.m_assetSize;
|
||||
entry.m_hardReferencesSize = p_hardReferences.size() * UUID::UUID_BYTE_SIZE;
|
||||
|
||||
std::memcpy(data.data() + entry.m_assetOffset, p_flatbuffer.data(), entry.m_assetSize);
|
||||
|
||||
for (std::uint32_t i = 0; i < p_hardReferences.size(); ++i)
|
||||
{
|
||||
const std::span<const std::byte, UUID::UUID_BYTE_SIZE> rawUUID = p_hardReferences[i].ToBytes();
|
||||
std::memcpy(data.data() + entry.m_hardReferencesOffset + (static_cast<std::size_t>(i) * UUID::UUID_BYTE_SIZE),
|
||||
rawUUID.data(),
|
||||
UUID::UUID_BYTE_SIZE);
|
||||
}
|
||||
|
||||
m_currentDataOffset += entry.m_assetSize + entry.m_hardReferencesSize;
|
||||
m_entries.push_back(entry);
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
Sasquatch::Sasquatch(const File& p_file):
|
||||
m_file(p_file)
|
||||
{
|
||||
const eastl::span<const std::byte> data = m_file.GetData();
|
||||
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
data.size() >= sizeof(SasquatchHeader),
|
||||
"Sasquatch file {} is smaller than its header",
|
||||
p_file.GetPath());
|
||||
|
||||
std::memcpy(&m_header, data.data(), sizeof(SasquatchHeader));
|
||||
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
m_header.m_magic == SasquatchHeader::MAGIC,
|
||||
"Sasquatch file {} has an invalid magic number (got {} / expected {})",
|
||||
p_file.GetPath(),
|
||||
m_header.m_magic,
|
||||
SasquatchHeader::MAGIC);
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
m_header.m_version == SasquatchHeader::VERSION,
|
||||
"Sasquatch file {} has an unsupported version (got {} / expected {})",
|
||||
p_file.GetPath(),
|
||||
m_header.m_version,
|
||||
SasquatchHeader::VERSION);
|
||||
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
data.size() >= sizeof(SasquatchHeader) + (m_header.m_assetCount * sizeof(SasquatchEntry)),
|
||||
"Sasquatch file {} index is truncated (got {} / expected at least {})",
|
||||
p_file.GetPath(),
|
||||
data.size(),
|
||||
sizeof(SasquatchHeader) + (m_header.m_assetCount * sizeof(SasquatchEntry)));
|
||||
|
||||
eastl::vector<SasquatchEntry> entries(m_header.m_assetCount);
|
||||
if (!entries.empty())
|
||||
{
|
||||
std::memcpy(entries.data(), data.data() + sizeof(SasquatchHeader), entries.size() * sizeof(SasquatchEntry));
|
||||
}
|
||||
|
||||
m_entries.reserve(m_header.m_assetCount);
|
||||
for (const SasquatchEntry& entry: entries)
|
||||
{
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
entry.m_assetOffset + entry.m_assetSize + entry.m_hardReferencesSize <= data.size(),
|
||||
"Sasquatch file {} has an out-of-bounds asset entry",
|
||||
p_file.GetPath());
|
||||
|
||||
m_entries.emplace(UUID {entry.m_uuid},
|
||||
Entry {.m_assetOffset = entry.m_assetOffset,
|
||||
.m_assetSize = entry.m_assetSize,
|
||||
.m_hardReferencesOffset = entry.m_hardReferencesOffset,
|
||||
.m_hardReferencesSize = entry.m_hardReferencesSize});
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
const SasquatchHeader& Sasquatch::GetHeader() const
|
||||
{
|
||||
return m_header;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<std::byte> Sasquatch::GetAssetFlatbuffer(const UUID& p_uuid) const
|
||||
{
|
||||
const auto entryIt = m_entries.find(p_uuid);
|
||||
if (entryIt == m_entries.end())
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
const eastl::span<const std::byte> data = m_file.GetData();
|
||||
const eastl::span<const std::byte> bytes {data.data() + entryIt->second.m_assetOffset,
|
||||
static_cast<std::size_t>(entryIt->second.m_assetSize)};
|
||||
return eastl::vector<std::byte> {bytes.begin(), bytes.end()};
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<eastl::vector<std::byte>> Sasquatch::GetAssetFlatbuffers(const eastl::span<const UUID> p_uuids) const
|
||||
{
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
flatbuffers.reserve(p_uuids.size());
|
||||
|
||||
for (const UUID& uuid: p_uuids)
|
||||
{
|
||||
flatbuffers.push_back(GetAssetFlatbuffer(uuid));
|
||||
}
|
||||
|
||||
return flatbuffers;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<UUID> Sasquatch::GetAssetHardReferences(const UUID& p_uuid) const
|
||||
{
|
||||
eastl::vector<UUID> hardReferences;
|
||||
|
||||
const auto entryIt = m_entries.find(p_uuid);
|
||||
if (entryIt == m_entries.end())
|
||||
{
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
const eastl::span<const std::byte> data = m_file.GetData();
|
||||
const eastl::span<const std::byte> bytes {data.data() + entryIt->second.m_hardReferencesOffset,
|
||||
static_cast<std::size_t>(entryIt->second.m_hardReferencesSize)};
|
||||
|
||||
const std::size_t hardReferenceCount = bytes.size() / UUID::UUID_BYTE_SIZE;
|
||||
hardReferences.reserve(hardReferenceCount);
|
||||
|
||||
for (std::size_t i = 0; i < hardReferenceCount; ++i)
|
||||
{
|
||||
std::array<std::byte, UUID::UUID_BYTE_SIZE> rawUUID;
|
||||
std::memcpy(rawUUID.data(), bytes.data() + (i * UUID::UUID_BYTE_SIZE), UUID::UUID_BYTE_SIZE);
|
||||
hardReferences.emplace_back(rawUUID);
|
||||
}
|
||||
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
eastl::vector<eastl::vector<UUID>> Sasquatch::GetAssetsHardReferences(eastl::span<const UUID> p_uuids) const
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
hardReferences.reserve(p_uuids.size());
|
||||
|
||||
for (const UUID& uuid: p_uuids)
|
||||
{
|
||||
hardReferences.push_back(GetAssetHardReferences(uuid));
|
||||
}
|
||||
|
||||
return hardReferences;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void Sasquatch::SaveAssetFlatbuffer([[maybe_unused]] const UUID& p_uuid,
|
||||
[[maybe_unused]] eastl::span<const std::byte> p_flatbuffer,
|
||||
[[maybe_unused]] eastl::span<const UUID> p_hardReferences)
|
||||
{
|
||||
ASSERT(EngineAssertHandler, false, "Sasquatch is read-only, it cannot save assets");
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void Sasquatch::SaveAssetFlatbuffers([[maybe_unused]] const eastl::span<const UUID> p_uuids,
|
||||
[[maybe_unused]] eastl::span<const eastl::vector<std::byte>> p_flatbuffers,
|
||||
[[maybe_unused]] eastl::span<const eastl::vector<UUID>> p_hardReferences)
|
||||
{
|
||||
ASSERT(EngineAssertHandler, false, "Sasquatch is read-only, it cannot save assets");
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool Sasquatch::Has(const UUID& p_uuid) const
|
||||
{
|
||||
return m_entries.contains(p_uuid);
|
||||
}
|
||||
#endif
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1,249 @@
|
||||
/*********************************************************************
|
||||
* \file SerializationManager.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date August 2026
|
||||
*********************************************************************/
|
||||
#include <Engine/SerializationManager/SerializationManager.hpp>
|
||||
|
||||
#include <Engine/Asset/AssetLibrary.hpp>
|
||||
#include <Engine/DataAccessor/DataAccessor.hpp>
|
||||
|
||||
#include <Utils/Algorithm/Graph.hpp>
|
||||
|
||||
#include <ankerl/unordered_dense.h>
|
||||
|
||||
namespace Bigfoot::SerializationManager
|
||||
{
|
||||
/*
|
||||
* Build the transitive HardReference graph reachable from p_roots
|
||||
*
|
||||
* \param p_roots The assets to start the discovery from
|
||||
* \param p_discovered Every discovered asset that isn't already loaded, including p_roots
|
||||
* \return Every asset's HardReferences
|
||||
*/
|
||||
[[nodiscard]]
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<UUID>> BuildDependencyGraph(
|
||||
const eastl::span<const UUID> p_roots,
|
||||
ankerl::unordered_dense::set<UUID>& p_discovered)
|
||||
{
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<UUID>> graph;
|
||||
|
||||
eastl::vector<UUID> toQuery;
|
||||
toQuery.reserve(p_roots.size());
|
||||
for (const UUID& uuid: p_roots)
|
||||
{
|
||||
if (!g_activeAssetLibrary->IsLoaded(uuid) && p_discovered.insert(uuid).second)
|
||||
{
|
||||
toQuery.push_back(uuid);
|
||||
}
|
||||
}
|
||||
|
||||
while (!toQuery.empty())
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> hardReferencesBatch = g_dataAccessor->GetAssetsHardReferences(toQuery);
|
||||
|
||||
eastl::vector<UUID> nextToQuery;
|
||||
for (std::size_t i = 0; i < toQuery.size(); ++i)
|
||||
{
|
||||
eastl::vector<UUID>& hardReferences = graph[toQuery[i]];
|
||||
hardReferences = std::move(hardReferencesBatch[i]);
|
||||
|
||||
for (const UUID& hardReference: hardReferences)
|
||||
{
|
||||
if (!g_activeAssetLibrary->IsLoaded(hardReference) && p_discovered.insert(hardReference).second)
|
||||
{
|
||||
nextToQuery.push_back(hardReference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
toQuery = std::move(nextToQuery);
|
||||
}
|
||||
|
||||
return graph;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void LoadAssets(const eastl::span<const UUID> p_uuids)
|
||||
{
|
||||
ankerl::unordered_dense::set<UUID> discovered;
|
||||
const ankerl::unordered_dense::map<UUID, eastl::vector<UUID>> graph = BuildDependencyGraph(p_uuids, discovered);
|
||||
|
||||
// Assets that are part of a cyclic HardReference dependency are left out of waves and simply never loaded.
|
||||
eastl::vector<eastl::vector<UUID>> waves;
|
||||
eastl::vector<UUID> cyclicUuids;
|
||||
std::ignore = LayeredTopologicalSort(graph, discovered, waves, cyclicUuids);
|
||||
BIGFOOT_LOG_ERROR_IF(!cyclicUuids.empty(),
|
||||
ENGINE_LOGGER,
|
||||
"Cyclic HardReference dependency detected while loading assets, involved UUIDs: {}",
|
||||
cyclicUuids);
|
||||
|
||||
// Waves are loaded one after another since a wave's assets may HardReference the previous wave's; within a
|
||||
// wave, every asset is independent of the others, so this is where loading could later be parallelized.
|
||||
for (const eastl::vector<UUID>& wave: waves)
|
||||
{
|
||||
const eastl::vector<eastl::vector<std::byte>> assetFlatbuffers = g_dataAccessor->GetAssetFlatbuffers(wave);
|
||||
for (std::size_t i = 0; i < wave.size(); ++i)
|
||||
{
|
||||
const eastl::vector<std::byte>& flatbuffer = assetFlatbuffers[i];
|
||||
if (flatbuffer.empty())
|
||||
{
|
||||
BIGFOOT_LOG_ERROR(ENGINE_LOGGER, "Asset {} could not be found while loading, skipping it", wave[i]);
|
||||
continue;
|
||||
}
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
flatbuffers::Verifier verifier {reinterpret_cast<const std::uint8_t*>(flatbuffer.data()),
|
||||
flatbuffer.size()};
|
||||
const bool assetVerified = ::Flat::Bigfoot::VerifyAssetBuffer(verifier);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, assetVerified, "Given asset could not be verified!");
|
||||
#endif
|
||||
|
||||
const ::Flat::Bigfoot::Asset* asset = flatbuffers::GetRoot<::Flat::Bigfoot::Asset>(flatbuffer.data());
|
||||
|
||||
AssetContainerBase* container = g_activeAssetLibrary->GetAssetContainer(
|
||||
flatbuffers::UnPack(*asset->header()->type_id()));
|
||||
CRITICAL_ASSERT(EngineAssertHandler,
|
||||
container != nullptr,
|
||||
"No AssetContainer registered for asset {}",
|
||||
wave[i]);
|
||||
std::ignore = container->Insert(flatbuffer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
void LoadAsset(const UUID& p_uuid)
|
||||
{
|
||||
LoadAssets(eastl::span<const UUID> {&p_uuid, 1});
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
#ifdef BIGFOOT_TOOLMODE
|
||||
/*
|
||||
* Finds the cyclic dependencies that may exist in Assets
|
||||
*
|
||||
* \param p_uuids The assets we want to explore
|
||||
* \param p_hardReferences The HardReferences of p_uuids, matching by index
|
||||
* \return Every UUID caught in a cyclic dependency
|
||||
*/
|
||||
[[nodiscard]]
|
||||
eastl::vector<UUID> FindCyclicDependencies(const eastl::span<const UUID> p_uuids,
|
||||
const eastl::span<const eastl::vector<UUID>> p_hardReferences)
|
||||
{
|
||||
ankerl::unordered_dense::map<UUID, eastl::vector<UUID>> graph;
|
||||
ankerl::unordered_dense::set<UUID> discovered;
|
||||
|
||||
eastl::vector<UUID> toQuery;
|
||||
for (std::size_t i = 0; i < p_uuids.size(); ++i)
|
||||
{
|
||||
discovered.insert(p_uuids[i]);
|
||||
graph[p_uuids[i]] = p_hardReferences[i];
|
||||
}
|
||||
for (const eastl::vector<UUID>& hardReferences: p_hardReferences)
|
||||
{
|
||||
for (const UUID& hardReference: hardReferences)
|
||||
{
|
||||
if (discovered.insert(hardReference).second)
|
||||
{
|
||||
toQuery.push_back(hardReference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (!toQuery.empty())
|
||||
{
|
||||
eastl::vector<eastl::vector<UUID>> hardReferencesBatch = g_dataAccessor->GetAssetsHardReferences(toQuery);
|
||||
|
||||
eastl::vector<UUID> nextToQuery;
|
||||
for (std::size_t i = 0; i < toQuery.size(); ++i)
|
||||
{
|
||||
eastl::vector<UUID>& hardReferences = graph[toQuery[i]];
|
||||
hardReferences = std::move(hardReferencesBatch[i]);
|
||||
|
||||
for (const UUID& hardReference: hardReferences)
|
||||
{
|
||||
if (discovered.insert(hardReference).second)
|
||||
{
|
||||
nextToQuery.push_back(hardReference);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
toQuery = std::move(nextToQuery);
|
||||
}
|
||||
|
||||
eastl::vector<eastl::vector<UUID>> waves;
|
||||
eastl::vector<UUID> cyclicUuids;
|
||||
std::ignore = LayeredTopologicalSort(graph, discovered, waves, cyclicUuids);
|
||||
return cyclicUuids;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool SaveAsset(const UUID& p_uuid)
|
||||
{
|
||||
AssetContainerBase* container = g_activeAssetLibrary->GetAssetContainer(p_uuid);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, container != nullptr, "No AssetContainer registered for asset {}", p_uuid);
|
||||
const AssetBase* asset = container->AcquireContainerHandle(p_uuid)->GetAsset();
|
||||
|
||||
const eastl::vector<std::byte> flatbuffer = asset->Pack();
|
||||
const eastl::vector<UUID> hardReferences = asset->GetHardReferences(flatbuffer);
|
||||
|
||||
const eastl::vector<UUID> cyclicUuids = FindCyclicDependencies(
|
||||
eastl::span<const UUID> {&p_uuid, 1},
|
||||
eastl::span<const eastl::vector<UUID>> {&hardReferences, 1});
|
||||
BIGFOOT_LOG_ERROR_IF(!cyclicUuids.empty(),
|
||||
ENGINE_LOGGER,
|
||||
"Cyclic HardReference dependency detected while saving asset {}, involved UUIDs: {}",
|
||||
p_uuid,
|
||||
cyclicUuids);
|
||||
if (!cyclicUuids.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
g_dataAccessor->SaveAssetFlatbuffer(p_uuid, flatbuffer, hardReferences);
|
||||
return true;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
bool SaveAssets(const eastl::span<const UUID> p_uuids)
|
||||
{
|
||||
eastl::vector<eastl::vector<std::byte>> flatbuffers;
|
||||
eastl::vector<eastl::vector<UUID>> hardReferences;
|
||||
|
||||
flatbuffers.reserve(p_uuids.size());
|
||||
hardReferences.reserve(p_uuids.size());
|
||||
for (const UUID& uuid: p_uuids)
|
||||
{
|
||||
AssetContainerBase* container = g_activeAssetLibrary->GetAssetContainer(uuid);
|
||||
CRITICAL_ASSERT(EngineAssertHandler, container != nullptr, "No AssetContainer registered for asset {}", uuid);
|
||||
const AssetBase* asset = container->AcquireContainerHandle(uuid)->GetAsset();
|
||||
|
||||
const eastl::vector<std::byte> flatbuffer = asset->Pack();
|
||||
|
||||
flatbuffers.push_back(flatbuffer);
|
||||
hardReferences.push_back(asset->GetHardReferences(flatbuffer));
|
||||
}
|
||||
|
||||
const eastl::vector<UUID> cyclicUuids = FindCyclicDependencies(p_uuids, hardReferences);
|
||||
BIGFOOT_LOG_ERROR_IF(!cyclicUuids.empty(),
|
||||
ENGINE_LOGGER,
|
||||
"Cyclic HardReference dependency detected while saving assets, involved UUIDs: {}",
|
||||
cyclicUuids);
|
||||
if (!cyclicUuids.empty())
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
g_dataAccessor->SaveAssetFlatbuffers(p_uuids, flatbuffers, hardReferences);
|
||||
return true;
|
||||
}
|
||||
#endif
|
||||
} // namespace Bigfoot::SerializationManager
|
||||
@@ -0,0 +1,5 @@
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsInterface)
|
||||
if(${VULKAN})
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsVulkan)
|
||||
endif()
|
||||
add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/GraphicsCore)
|
||||
@@ -0,0 +1,18 @@
|
||||
get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName})
|
||||
|
||||
set(PublicDependencies)
|
||||
set(PrivateDependencies)
|
||||
set(BigfootPublicDependencies
|
||||
GraphicsVulkan
|
||||
Engine)
|
||||
set(BigfootPrivateDependencies)
|
||||
|
||||
bigfoot_create_package_lib(
|
||||
"${PublicDependencies}"
|
||||
"${PrivateDependencies}"
|
||||
"${BigfootPublicDependencies}"
|
||||
"${BigfootPrivateDependencies}"
|
||||
"Bigfoot/Libs/Graphics")
|
||||
|
||||
bigfoot_create_logger()
|
||||
@@ -0,0 +1,71 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsContext.cpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#include <GraphicsCore/GraphicsContext.hpp>
|
||||
|
||||
#include <GraphicsCore/GraphicsCoreAssertHandler.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
GraphicsContext::GraphicsContext(const GraphicsContextCreateInfo& p_createInfo)
|
||||
{
|
||||
m_instance = g_graphicsInstanceFactory->Create(p_createInfo.m_api,
|
||||
p_createInfo.m_applicationName,
|
||||
p_createInfo.m_applicationVersion);
|
||||
CRITICAL_ASSERT(GraphicsCoreAssertHandler,
|
||||
m_instance != nullptr,
|
||||
"No graphics instance registered for GraphicsAPI '{}'",
|
||||
EnumNameGraphicsAPI(p_createInfo.m_api));
|
||||
|
||||
m_surface = g_graphicsSurfaceFactory->Create(p_createInfo.m_api, *m_instance, p_createInfo.m_surfaceCreateInfo);
|
||||
CRITICAL_ASSERT(GraphicsCoreAssertHandler,
|
||||
m_surface != nullptr,
|
||||
"No graphics surface registered for GraphicsAPI '{}'",
|
||||
EnumNameGraphicsAPI(p_createInfo.m_api));
|
||||
|
||||
const DeviceCreateInfo deviceCreateInfo {p_createInfo.m_deviceNameHint, m_surface.get()};
|
||||
m_device = g_graphicsDeviceFactory->Create(p_createInfo.m_api, *m_instance, deviceCreateInfo);
|
||||
CRITICAL_ASSERT(GraphicsCoreAssertHandler,
|
||||
m_device != nullptr,
|
||||
"No graphics device registered for GraphicsAPI '{}'",
|
||||
EnumNameGraphicsAPI(p_createInfo.m_api));
|
||||
|
||||
const SwapchainCreateInfo swapchainCreateInfo {m_device.get(), m_surface.get(), p_createInfo.m_extent};
|
||||
m_swapchain = g_graphicsSwapchainFactory->Create(p_createInfo.m_api, swapchainCreateInfo);
|
||||
CRITICAL_ASSERT(GraphicsCoreAssertHandler,
|
||||
m_swapchain != nullptr,
|
||||
"No graphics swapchain registered for GraphicsAPI '{}'",
|
||||
EnumNameGraphicsAPI(p_createInfo.m_api));
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
GraphicsInstance& GraphicsContext::GetInstance() const
|
||||
{
|
||||
return *m_instance;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
GraphicsSurface& GraphicsContext::GetSurface() const
|
||||
{
|
||||
return *m_surface;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
GraphicsDevice& GraphicsContext::GetDevice() const
|
||||
{
|
||||
return *m_device;
|
||||
}
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
GraphicsSwapchain& GraphicsContext::GetSwapchain() const
|
||||
{
|
||||
return *m_swapchain;
|
||||
}
|
||||
} // namespace Bigfoot
|
||||
@@ -0,0 +1 @@
|
||||
#include <GraphicsCore/GraphicsCoreAssertHandler.hpp>
|
||||
@@ -0,0 +1,128 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsContext.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSCORE_GRAPHICSCONTEXT_HPP
|
||||
#define BIGFOOT_GRAPHICSCORE_GRAPHICSCONTEXT_HPP
|
||||
#include <GraphicsInterface/GraphicsDevice.hpp>
|
||||
#include <GraphicsInterface/GraphicsInstance.hpp>
|
||||
#include <GraphicsInterface/GraphicsSurface.hpp>
|
||||
#include <GraphicsInterface/GraphicsSwapchain.hpp>
|
||||
|
||||
#include <Utils/Version.hpp>
|
||||
|
||||
#include <GraphicsInterface/GraphicsAPI_generated.hpp>
|
||||
|
||||
#include <EASTL/string_view.h>
|
||||
#include <EASTL/unique_ptr.h>
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct GraphicsContextCreateInfo
|
||||
{
|
||||
/**
|
||||
* The graphics API to use
|
||||
*/
|
||||
GraphicsAPI m_api = GraphicsAPI::Vulkan;
|
||||
|
||||
/**
|
||||
* The name of the application
|
||||
*/
|
||||
eastl::string_view m_applicationName;
|
||||
|
||||
/**
|
||||
* The version of the application
|
||||
*/
|
||||
Version m_applicationVersion;
|
||||
|
||||
/**
|
||||
* The native window handles
|
||||
*/
|
||||
SurfaceCreateInfo m_surfaceCreateInfo;
|
||||
|
||||
/**
|
||||
* Pick a specific physical device by name.
|
||||
*/
|
||||
eastl::string_view m_deviceNameHint;
|
||||
|
||||
/**
|
||||
* The desired size of the swapchain images.
|
||||
*/
|
||||
glm::uvec2 m_extent = {};
|
||||
};
|
||||
|
||||
class GraphicsContext
|
||||
{
|
||||
public:
|
||||
/**
|
||||
* Constructor.
|
||||
*
|
||||
* \param p_createInfo The create info
|
||||
*/
|
||||
explicit GraphicsContext(const GraphicsContextCreateInfo& p_createInfo);
|
||||
|
||||
GraphicsContext(const GraphicsContext& p_context) = delete;
|
||||
GraphicsContext(GraphicsContext&& p_context) = delete;
|
||||
|
||||
GraphicsContext& operator=(const GraphicsContext& p_context) = delete;
|
||||
GraphicsContext& operator=(GraphicsContext&& p_context) = delete;
|
||||
|
||||
/**
|
||||
* Get the graphics instance
|
||||
*
|
||||
* \return The graphics instance
|
||||
*/
|
||||
[[nodiscard]]
|
||||
GraphicsInstance& GetInstance() const;
|
||||
|
||||
/**
|
||||
* Get the graphics surface
|
||||
*
|
||||
* \return The graphics surface
|
||||
*/
|
||||
[[nodiscard]]
|
||||
GraphicsSurface& GetSurface() const;
|
||||
|
||||
/**
|
||||
* Get the graphics device
|
||||
*
|
||||
* \return The graphics device
|
||||
*/
|
||||
[[nodiscard]]
|
||||
GraphicsDevice& GetDevice() const;
|
||||
|
||||
/**
|
||||
* Get the graphics swapchain
|
||||
*
|
||||
* \return The graphics swapchain
|
||||
*/
|
||||
[[nodiscard]]
|
||||
GraphicsSwapchain& GetSwapchain() const;
|
||||
|
||||
private:
|
||||
/**
|
||||
* The graphics instance.
|
||||
*/
|
||||
eastl::unique_ptr<GraphicsInstance> m_instance;
|
||||
|
||||
/**
|
||||
* The graphics surface.
|
||||
*/
|
||||
eastl::unique_ptr<GraphicsSurface> m_surface;
|
||||
|
||||
/**
|
||||
* The graphics device.
|
||||
*/
|
||||
eastl::unique_ptr<GraphicsDevice> m_device;
|
||||
|
||||
/**
|
||||
* The graphics swapchain.
|
||||
*/
|
||||
eastl::unique_ptr<GraphicsSwapchain> m_swapchain;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,20 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsCoreAssertHandler.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSCORE_GRAPHICSCOREASSERTHANDLER_HPP
|
||||
#define BIGFOOT_GRAPHICSCORE_GRAPHICSCOREASSERTHANDLER_HPP
|
||||
#include <Utils/Assert/AssertHandler.hpp>
|
||||
|
||||
#include <GraphicsCore/GraphicsCoreLogger_generated.hpp>
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
using GraphicsCoreAssertHandler = AssertHandler<GRAPHICSCORE_LOGGER>;
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
// AUTO-GENERATED DO NOT TOUCH
|
||||
|
||||
/*********************************************************************
|
||||
* \file GraphicsCoreLogger.generated.hpp
|
||||
*
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSCORELOGGER_GENERATED_HPP
|
||||
#define BIGFOOT_GRAPHICSCORELOGGER_GENERATED_HPP
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
|
||||
#if defined BIGFOOT_NOT_OPTIMIZED
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
* Logger
|
||||
*/
|
||||
inline Log::LoggerInfo GRAPHICSCORE_LOGGER { .m_name = "GRAPHICSCORE_LOGGER", .m_level = LogLevel::Trace};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,18 @@
|
||||
get_filename_component(PackageName ${CMAKE_CURRENT_SOURCE_DIR} NAME)
|
||||
project(${PackageName})
|
||||
|
||||
set(PublicDependencies
|
||||
glm::glm)
|
||||
set(PrivateDependencies)
|
||||
set(BigfootPublicDependencies
|
||||
Utils)
|
||||
set(BigfootPrivateDependencies)
|
||||
|
||||
bigfoot_create_package_lib(
|
||||
"${PublicDependencies}"
|
||||
"${PrivateDependencies}"
|
||||
"${BigfootPublicDependencies}"
|
||||
"${BigfootPrivateDependencies}"
|
||||
"Bigfoot/Libs/Graphics")
|
||||
|
||||
bigfoot_create_logger()
|
||||
@@ -0,0 +1 @@
|
||||
#include <GraphicsInterface/GraphicsInterfaceAssertHandler.hpp>
|
||||
@@ -0,0 +1,6 @@
|
||||
namespace Bigfoot;
|
||||
|
||||
enum GraphicsAPI: byte
|
||||
{
|
||||
Vulkan
|
||||
}
|
||||
+71
@@ -0,0 +1,71 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Bigfoot {
|
||||
|
||||
enum class GraphicsAPI : int8_t {
|
||||
Vulkan = 0,
|
||||
MIN = Vulkan,
|
||||
MAX = Vulkan
|
||||
};
|
||||
|
||||
inline const GraphicsAPI (&EnumValuesGraphicsAPI())[1] {
|
||||
static const GraphicsAPI values[] = {
|
||||
GraphicsAPI::Vulkan
|
||||
};
|
||||
return values;
|
||||
}
|
||||
|
||||
inline const char * const *EnumNamesGraphicsAPI() {
|
||||
static const char * const names[2] = {
|
||||
"Vulkan",
|
||||
nullptr
|
||||
};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameGraphicsAPI(GraphicsAPI e) {
|
||||
if (::flatbuffers::IsOutRange(e, GraphicsAPI::Vulkan, GraphicsAPI::Vulkan)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesGraphicsAPI()[index];
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *GraphicsAPITypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Bigfoot::GraphicsAPITypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_ENUM, 1, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_GRAPHICSAPI_BIGFOOT_H_
|
||||
@@ -0,0 +1,75 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsDevice.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSDEVICE_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSDEVICE_HPP
|
||||
#include <GraphicsInterface/GraphicsInstance.hpp>
|
||||
#include <GraphicsInterface/GraphicsQueue.hpp>
|
||||
#include <GraphicsInterface/GraphicsSurface.hpp>
|
||||
|
||||
#include <Utils/Factory.hpp>
|
||||
#include <Utils/LazyGlobal.hpp>
|
||||
|
||||
#include <GraphicsInterface/GraphicsAPI_generated.hpp>
|
||||
|
||||
#include <EASTL/functional.h>
|
||||
#include <EASTL/string_view.h>
|
||||
#include <EASTL/unique_ptr.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
|
||||
struct DeviceCreateInfo
|
||||
{
|
||||
/**
|
||||
* When empty, the most suitable discrete GPU is preferred.
|
||||
*/
|
||||
eastl::string_view m_deviceNameHint;
|
||||
|
||||
/**
|
||||
* The surface the device must be able to present to.
|
||||
*/
|
||||
const GraphicsSurface* m_surface = nullptr;
|
||||
};
|
||||
|
||||
class GraphicsDevice
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsDevice() = default;
|
||||
|
||||
/**
|
||||
* Get a queue of the given type
|
||||
*
|
||||
* \param p_type The kind of work the queue should support
|
||||
* \return The queue, or nullptr if the device has no queue of this type
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual const GraphicsQueue* GetQueue(GraphicsQueueType p_type) const = 0;
|
||||
|
||||
GraphicsDevice(const GraphicsDevice& p_device) = delete;
|
||||
GraphicsDevice(GraphicsDevice&& p_device) = delete;
|
||||
|
||||
GraphicsDevice& operator=(const GraphicsDevice& p_device) = delete;
|
||||
GraphicsDevice& operator=(GraphicsDevice&& p_device) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsDevice() = default;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
using GraphicsDeviceFactory =
|
||||
Factory<GraphicsDevice,
|
||||
GraphicsAPI,
|
||||
eastl::function<eastl::unique_ptr<GraphicsDevice>(const GraphicsInstance&, const DeviceCreateInfo&)>>;
|
||||
|
||||
/**
|
||||
* The global factory graphics libraries register themselves into, keyed by GraphicsAPI
|
||||
*/
|
||||
inline LazyGlobal<GraphicsDeviceFactory> g_graphicsDeviceFactory;
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,47 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsImage.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSIMAGE_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSIMAGE_HPP
|
||||
#include <GraphicsInterface/PixelFormat_generated.hpp>
|
||||
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class GraphicsImage
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsImage() = default;
|
||||
|
||||
/**
|
||||
* Get the pixel format of the image
|
||||
*
|
||||
* \return The image format
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual PixelFormat GetFormat() const = 0;
|
||||
|
||||
/**
|
||||
* Get the size of the image
|
||||
*
|
||||
* \return The image extent, in pixels
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual glm::uvec2 GetExtent() const = 0;
|
||||
|
||||
GraphicsImage(const GraphicsImage& p_image) = delete;
|
||||
GraphicsImage(GraphicsImage&& p_image) = delete;
|
||||
|
||||
GraphicsImage& operator=(const GraphicsImage& p_image) = delete;
|
||||
GraphicsImage& operator=(GraphicsImage&& p_image) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsImage() = default;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsInstance.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINSTANCE_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINSTANCE_HPP
|
||||
#include <Utils/Factory.hpp>
|
||||
#include <Utils/LazyGlobal.hpp>
|
||||
#include <Utils/Version.hpp>
|
||||
|
||||
#include <GraphicsInterface/GraphicsAPI_generated.hpp>
|
||||
|
||||
#include <EASTL/functional.h>
|
||||
#include <EASTL/string_view.h>
|
||||
#include <EASTL/unique_ptr.h>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class GraphicsInstance
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsInstance() = default;
|
||||
|
||||
GraphicsInstance(const GraphicsInstance& p_instance) = delete;
|
||||
GraphicsInstance(GraphicsInstance&& p_instance) = delete;
|
||||
|
||||
GraphicsInstance& operator=(const GraphicsInstance& p_instance) = delete;
|
||||
GraphicsInstance& operator=(GraphicsInstance&& p_instance) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsInstance() = default;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
using GraphicsInstanceFactory =
|
||||
Factory<GraphicsInstance,
|
||||
GraphicsAPI,
|
||||
eastl::function<eastl::unique_ptr<GraphicsInstance>(eastl::string_view, Version)>>;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
inline LazyGlobal<GraphicsInstanceFactory> g_graphicsInstanceFactory;
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+20
@@ -0,0 +1,20 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsInterfaceAssertHandler.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINTERFACEASSERTHANDLER_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSINTERFACEASSERTHANDLER_HPP
|
||||
#include <Utils/Assert/AssertHandler.hpp>
|
||||
|
||||
#include <GraphicsInterface/GraphicsInterfaceLogger_generated.hpp>
|
||||
|
||||
#ifdef BIGFOOT_NOT_OPTIMIZED
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
using GraphicsInterfaceAssertHandler = AssertHandler<GRAPHICSINTERFACE_LOGGER>;
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
// AUTO-GENERATED DO NOT TOUCH
|
||||
|
||||
/*********************************************************************
|
||||
* \file GraphicsInterfaceLogger.generated.hpp
|
||||
*
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACELOGGER_GENERATED_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACELOGGER_GENERATED_HPP
|
||||
#include <Utils/Log/LogMacros.hpp>
|
||||
|
||||
#if defined BIGFOOT_NOT_OPTIMIZED
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/*
|
||||
* Logger
|
||||
*/
|
||||
inline Log::LoggerInfo GRAPHICSINTERFACE_LOGGER { .m_name = "GRAPHICSINTERFACE_LOGGER", .m_level = LogLevel::Trace};
|
||||
} // namespace Bigfoot
|
||||
#endif
|
||||
#endif
|
||||
@@ -0,0 +1,37 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsQueue.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSQUEUE_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSQUEUE_HPP
|
||||
#include <GraphicsInterface/GraphicsQueueType_generated.hpp>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
class GraphicsQueue
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsQueue() = default;
|
||||
|
||||
/**
|
||||
* Get the kind of work this queue can be submitted
|
||||
*
|
||||
* \return The queue type
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual GraphicsQueueType GetType() const = 0;
|
||||
|
||||
GraphicsQueue(const GraphicsQueue& p_queue) = delete;
|
||||
GraphicsQueue(GraphicsQueue&& p_queue) = delete;
|
||||
|
||||
GraphicsQueue& operator=(const GraphicsQueue& p_queue) = delete;
|
||||
GraphicsQueue& operator=(GraphicsQueue&& p_queue) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsQueue() = default;
|
||||
};
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+9
@@ -0,0 +1,9 @@
|
||||
namespace Bigfoot;
|
||||
|
||||
enum GraphicsQueueType: byte
|
||||
{
|
||||
Graphics,
|
||||
Compute,
|
||||
Transfer,
|
||||
Present
|
||||
}
|
||||
+83
@@ -0,0 +1,83 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Bigfoot {
|
||||
|
||||
enum class GraphicsQueueType : int8_t {
|
||||
Graphics = 0,
|
||||
Compute = 1,
|
||||
Transfer = 2,
|
||||
Present = 3,
|
||||
MIN = Graphics,
|
||||
MAX = Present
|
||||
};
|
||||
|
||||
inline const GraphicsQueueType (&EnumValuesGraphicsQueueType())[4] {
|
||||
static const GraphicsQueueType values[] = {
|
||||
GraphicsQueueType::Graphics,
|
||||
GraphicsQueueType::Compute,
|
||||
GraphicsQueueType::Transfer,
|
||||
GraphicsQueueType::Present
|
||||
};
|
||||
return values;
|
||||
}
|
||||
|
||||
inline const char * const *EnumNamesGraphicsQueueType() {
|
||||
static const char * const names[5] = {
|
||||
"Graphics",
|
||||
"Compute",
|
||||
"Transfer",
|
||||
"Present",
|
||||
nullptr
|
||||
};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNameGraphicsQueueType(GraphicsQueueType e) {
|
||||
if (::flatbuffers::IsOutRange(e, GraphicsQueueType::Graphics, GraphicsQueueType::Present)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesGraphicsQueueType()[index];
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *GraphicsQueueTypeTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Bigfoot::GraphicsQueueTypeTypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_ENUM, 4, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_GRAPHICSQUEUETYPE_BIGFOOT_H_
|
||||
@@ -0,0 +1,70 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsSurface.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSURFACE_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSURFACE_HPP
|
||||
#include <GraphicsInterface/GraphicsInstance.hpp>
|
||||
|
||||
#include <Utils/Factory.hpp>
|
||||
#include <Utils/LazyGlobal.hpp>
|
||||
#include <Utils/TargetMacros.h>
|
||||
|
||||
#include <GraphicsInterface/GraphicsAPI_generated.hpp>
|
||||
|
||||
#include <EASTL/functional.h>
|
||||
#include <EASTL/unique_ptr.h>
|
||||
|
||||
#ifdef BIGFOOT_WINDOWS
|
||||
#include <Windows.h>
|
||||
#elif defined BIGFOOT_LINUX
|
||||
struct wl_display;
|
||||
struct wl_surface;
|
||||
#endif
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
/**
|
||||
* The native window handles needed to create a GraphicsSurface
|
||||
*/
|
||||
struct SurfaceCreateInfo
|
||||
{
|
||||
#ifdef BIGFOOT_WINDOWS
|
||||
HWND m_windowHandle = nullptr;
|
||||
HINSTANCE m_windowInstance = nullptr;
|
||||
#elif defined BIGFOOT_LINUX
|
||||
wl_display* m_display = nullptr;
|
||||
wl_surface* m_surface = nullptr;
|
||||
#endif
|
||||
};
|
||||
|
||||
class GraphicsSurface
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsSurface() = default;
|
||||
|
||||
GraphicsSurface(const GraphicsSurface& p_surface) = delete;
|
||||
GraphicsSurface(GraphicsSurface&& p_surface) = delete;
|
||||
|
||||
GraphicsSurface& operator=(const GraphicsSurface& p_surface) = delete;
|
||||
GraphicsSurface& operator=(GraphicsSurface&& p_surface) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsSurface() = default;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
using GraphicsSurfaceFactory =
|
||||
Factory<GraphicsSurface,
|
||||
GraphicsAPI,
|
||||
eastl::function<eastl::unique_ptr<GraphicsSurface>(const GraphicsInstance&, const SurfaceCreateInfo&)>>;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
inline LazyGlobal<GraphicsSurfaceFactory> g_graphicsSurfaceFactory;
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
+89
@@ -0,0 +1,89 @@
|
||||
/*********************************************************************
|
||||
* \file GraphicsSwapchain.hpp
|
||||
*
|
||||
* \author Romain BOULLARD
|
||||
* \date September 2026
|
||||
*********************************************************************/
|
||||
#ifndef BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSWAPCHAIN_HPP
|
||||
#define BIGFOOT_GRAPHICSINTERFACE_GRAPHICSSWAPCHAIN_HPP
|
||||
#include <GraphicsInterface/GraphicsDevice.hpp>
|
||||
#include <GraphicsInterface/GraphicsImage.hpp>
|
||||
#include <GraphicsInterface/GraphicsInstance.hpp>
|
||||
#include <GraphicsInterface/GraphicsSurface.hpp>
|
||||
|
||||
#include <Utils/Factory.hpp>
|
||||
#include <Utils/LazyGlobal.hpp>
|
||||
|
||||
#include <GraphicsInterface/GraphicsAPI_generated.hpp>
|
||||
|
||||
#include <EASTL/functional.h>
|
||||
#include <EASTL/unique_ptr.h>
|
||||
#include <glm/glm.hpp>
|
||||
|
||||
#include <cstdint>
|
||||
|
||||
namespace Bigfoot
|
||||
{
|
||||
struct SwapchainCreateInfo
|
||||
{
|
||||
/**
|
||||
* The device to create the swapchain from. Must be able to present to m_surface.
|
||||
*/
|
||||
const GraphicsDevice* m_device = nullptr;
|
||||
|
||||
/**
|
||||
* The surface the swapchain will present to.
|
||||
*/
|
||||
const GraphicsSurface* m_surface = nullptr;
|
||||
|
||||
/**
|
||||
* The desired size of the swapchain images.
|
||||
*/
|
||||
glm::uvec2 m_extent = {};
|
||||
};
|
||||
|
||||
class GraphicsSwapchain
|
||||
{
|
||||
public:
|
||||
virtual ~GraphicsSwapchain() = default;
|
||||
|
||||
/**
|
||||
* Get the number of images owned by the swapchain
|
||||
*
|
||||
* \return The image count
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual std::uint32_t GetImageCount() const = 0;
|
||||
|
||||
/**
|
||||
* Get one of the images owned by the swapchain
|
||||
*
|
||||
* \param p_index The index of the image to get.
|
||||
* \return The image
|
||||
*/
|
||||
[[nodiscard]]
|
||||
virtual const GraphicsImage& GetImage(std::uint32_t p_index) const = 0;
|
||||
|
||||
GraphicsSwapchain(const GraphicsSwapchain& p_swapchain) = delete;
|
||||
GraphicsSwapchain(GraphicsSwapchain&& p_swapchain) = delete;
|
||||
|
||||
GraphicsSwapchain& operator=(const GraphicsSwapchain& p_swapchain) = delete;
|
||||
GraphicsSwapchain& operator=(GraphicsSwapchain&& p_swapchain) = delete;
|
||||
|
||||
protected:
|
||||
GraphicsSwapchain() = default;
|
||||
};
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
using GraphicsSwapchainFactory =
|
||||
Factory<GraphicsSwapchain,
|
||||
GraphicsAPI,
|
||||
eastl::function<eastl::unique_ptr<GraphicsSwapchain>(const SwapchainCreateInfo&)>>;
|
||||
|
||||
/****************************************************************************************/
|
||||
|
||||
inline LazyGlobal<GraphicsSwapchainFactory> g_graphicsSwapchainFactory;
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,12 @@
|
||||
namespace Bigfoot;
|
||||
|
||||
enum PixelFormat: byte
|
||||
{
|
||||
Undefined,
|
||||
R8G8B8A8Unorm,
|
||||
R8G8B8A8Srgb,
|
||||
B8G8R8A8Unorm,
|
||||
B8G8R8A8Srgb,
|
||||
A2B10G10R10UnormPack32,
|
||||
R16G16B16A16Sfloat
|
||||
}
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
// automatically generated by the FlatBuffers compiler, do not modify
|
||||
|
||||
|
||||
#ifndef FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_H_
|
||||
#define FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_H_
|
||||
|
||||
#include "flatbuffers/flatbuffers.h"
|
||||
|
||||
// Ensure the included flatbuffers.h is the same version as when this file was
|
||||
// generated, otherwise it may not be compatible.
|
||||
static_assert(FLATBUFFERS_VERSION_MAJOR == 25 &&
|
||||
FLATBUFFERS_VERSION_MINOR == 12 &&
|
||||
FLATBUFFERS_VERSION_REVISION == 19,
|
||||
"Non-compatible flatbuffers version included");
|
||||
// Ensure the included flatbuffers.h is Bigfoot's fork - stock
|
||||
// flatbuffers (or a differently versioned Bigfoot fork) is not compatible.
|
||||
#ifndef FLATBUFFERS_BIGFOOT_VERSION
|
||||
#error "This file requires Bigfoot's flatbuffers fork - stock flatbuffers is not compatible"
|
||||
#endif
|
||||
static_assert(FLATBUFFERS_BIGFOOT_VERSION == 1,
|
||||
"Non-compatible Bigfoot flatbuffers fork version included");
|
||||
|
||||
#include "EASTL/unique_ptr.h"
|
||||
#include "EASTL/string.h"
|
||||
#include "EASTL/vector.h"
|
||||
|
||||
namespace Bigfoot {
|
||||
|
||||
enum class PixelFormat : int8_t {
|
||||
Undefined = 0,
|
||||
R8G8B8A8Unorm = 1,
|
||||
R8G8B8A8Srgb = 2,
|
||||
B8G8R8A8Unorm = 3,
|
||||
B8G8R8A8Srgb = 4,
|
||||
A2B10G10R10UnormPack32 = 5,
|
||||
R16G16B16A16Sfloat = 6,
|
||||
MIN = Undefined,
|
||||
MAX = R16G16B16A16Sfloat
|
||||
};
|
||||
|
||||
inline const PixelFormat (&EnumValuesPixelFormat())[7] {
|
||||
static const PixelFormat values[] = {
|
||||
PixelFormat::Undefined,
|
||||
PixelFormat::R8G8B8A8Unorm,
|
||||
PixelFormat::R8G8B8A8Srgb,
|
||||
PixelFormat::B8G8R8A8Unorm,
|
||||
PixelFormat::B8G8R8A8Srgb,
|
||||
PixelFormat::A2B10G10R10UnormPack32,
|
||||
PixelFormat::R16G16B16A16Sfloat
|
||||
};
|
||||
return values;
|
||||
}
|
||||
|
||||
inline const char * const *EnumNamesPixelFormat() {
|
||||
static const char * const names[8] = {
|
||||
"Undefined",
|
||||
"R8G8B8A8Unorm",
|
||||
"R8G8B8A8Srgb",
|
||||
"B8G8R8A8Unorm",
|
||||
"B8G8R8A8Srgb",
|
||||
"A2B10G10R10UnormPack32",
|
||||
"R16G16B16A16Sfloat",
|
||||
nullptr
|
||||
};
|
||||
return names;
|
||||
}
|
||||
|
||||
inline const char *EnumNamePixelFormat(PixelFormat e) {
|
||||
if (::flatbuffers::IsOutRange(e, PixelFormat::Undefined, PixelFormat::R16G16B16A16Sfloat)) return "";
|
||||
const size_t index = static_cast<size_t>(e);
|
||||
return EnumNamesPixelFormat()[index];
|
||||
}
|
||||
|
||||
inline const ::flatbuffers::TypeTable *PixelFormatTypeTable() {
|
||||
static const ::flatbuffers::TypeCode type_codes[] = {
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 },
|
||||
{ ::flatbuffers::ET_CHAR, 0, 0 }
|
||||
};
|
||||
static const ::flatbuffers::TypeFunction type_refs[] = {
|
||||
Bigfoot::PixelFormatTypeTable
|
||||
};
|
||||
static const ::flatbuffers::TypeTable tt = {
|
||||
::flatbuffers::ST_ENUM, 7, type_codes, type_refs, nullptr, nullptr, nullptr
|
||||
};
|
||||
return &tt;
|
||||
}
|
||||
|
||||
} // namespace Bigfoot
|
||||
|
||||
#endif // FLATBUFFERS_GENERATED_PIXELFORMAT_BIGFOOT_H_
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user