kidrigger
/
project-aster
1
1
Fork 0
Code Issues 4 Pull Requests Packages Projects 1 Releases Wiki Activity

Cleanup and header re-date.

This commit is contained in:
Anish Bhobe 2025-04-02 22:46:30 +02:00
parent e5b002c8cc
commit 8eb5a678fc
64 changed files with 592 additions and 536 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
aster/include/aster/core/buffer.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: buffer.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -109,4 +109,4 @@ struct IndexBuffer : Buffer
struct StagingBuffer : Buffer
{
void Init(const Device *device, usize size, cstr name = nullptr);
};
};

5
aster/include/aster/core/config.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: config.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -15,6 +15,7 @@
#define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS
#define VULKAN_HPP_DISABLE_ENHANCED_MODE 1
#define VULKAN_HPP_NO_EXCEPTIONS 1
#define VULKAN_HPP_NO_SMART_HANDLE 1
#define VMA_STATIC_VULKAN_FUNCTIONS 0
#define VMA_DYNAMIC_VULKAN_FUNCTIONS 1
@ -25,4 +26,4 @@
#define USE_OPTICK (0)
#else
#define USE_OPTICK (1)
#endif
#endif

4
aster/include/aster/core/constants.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: constants.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -167,4 +167,4 @@ template <typename T>
constexpr T Qnan = std::numeric_limits<T>::quiet_NaN();
template <typename T>
constexpr T Snan = std::numeric_limits<T>::signalling_NaN();
constexpr T Snan = std::numeric_limits<T>::signalling_NaN();

4
aster/include/aster/core/context.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: context.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -35,4 +35,4 @@ struct Context final
#endif
DISALLOW_COPY_AND_ASSIGN(Context);
};
};

17
aster/include/aster/core/device.h
View File

@ -1,14 +1,14 @@
// =============================================
// Aster: device.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
#include "global.h"
#include <EASTL/vector.h>
#include <EASTL/span.h>
#include <EASTL/vector.h>
struct QueueAllocation;
struct Context;
@ -31,8 +31,8 @@ struct Device final
vk::PipelineCache m_PipelineCache = nullptr;
bool m_ValidationEnabled = true;
template <typename T>
requires vk::isVulkanHandleType<T>::value void SetName(const T &object, cstr name) const;
template <concepts::VkHandle T>
void SetName(const T &object, cstr name) const;
[[nodiscard]] vk::Queue GetQueue(u32 familyIndex, u32 queueIndex) const;
[[nodiscard]] eastl::vector<u8> DumpPipelineCache() const;
@ -43,7 +43,8 @@ struct Device final
Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
const eastl::vector<QueueAllocation> &queueAllocations, NameString &&name);
Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
const eastl::vector<QueueAllocation> &queueAllocations, eastl::span<u8> &&pipelineCacheData, NameString &&name);
const eastl::vector<QueueAllocation> &queueAllocations, eastl::span<u8> &&pipelineCacheData,
NameString &&name);
~Device();
// Move
@ -53,8 +54,8 @@ struct Device final
DISALLOW_COPY_AND_ASSIGN(Device);
};
template <typename T>
requires vk::isVulkanHandleType<T>::value void
template <concepts::VkHandle T>
void
Device::SetName(const T &object, cstr name) const
{
if (!m_ValidationEnabled || !name || !object)
@ -69,4 +70,4 @@ Device::SetName(const T &object, cstr name) const
vk::Result result = m_Device.setDebugUtilsObjectNameEXT(&objectNameInfo);
WARN_IF(Failed(result), "Could not name {:x}: {} as {}. Cause: {}", handle, to_string(object.objectType), name,
result);
}
}

12
aster/include/aster/core/global.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: global.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -27,8 +27,8 @@
#define VULKAN_HPP_ASSERT(expr) DEBUG_IF(!(expr), "Vulkan assert failed")
#endif
#include "type_traits.h"
#include "EASTL/intrusive_ptr.h"
#include "type_traits.h"
#include <EASTL/fixed_string.h>
#include <EASTL/string.h>
@ -61,6 +61,12 @@ Failed(const vk::Result result)
return result != vk::Result::eSuccess;
}
namespace concepts
{
template <typename T>
concept VkHandle = vk::isVulkanHandleType<T>::value;
}
using NameString = eastl::fixed_string<char, 32, false>;
template <typename TFlagBits>
@ -216,4 +222,4 @@ struct fmt::formatter<eastl::fixed_string<TType, TCount, TOverflow>> : nested_fo
};
template <concepts::Manageable T>
using Ref = eastl::intrusive_ptr<T>;
using Ref = eastl::intrusive_ptr<T>;

6
aster/include/aster/core/image.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: image.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -119,7 +119,7 @@ struct Image
namespace concepts
{
template <typename T>
concept Image = std::derived_from<T, ::Image> and Manageable<T>;
concept Image = std::derived_from<T, Image> and Manageable<T>;
template <typename T>
concept ImageRef = Derefencable<T> and Image<DereferencesTo<T>>;
@ -218,4 +218,4 @@ struct StorageTextureCube : StorageImage
{
return other.IsStorage() && other.IsSampled() && other.IsCube();
}
};
};

38
aster/include/aster/core/image_view.h
View File

@ -69,18 +69,38 @@ struct View
}
};
struct ImageView : View<> {};
struct ImageCubeView : View<ImageCube> {};
struct TextureView : View<Texture> {};
struct TextureCubeView : View<TextureCube> {};
struct StorageImageView : View<StorageImage> {};
struct StorageTextureView : View<StorageTexture> {};
struct StorageTextureCubeView : View<StorageTextureCube> {};
struct ImageView : View<>
{
};
struct ImageCubeView : View<ImageCube>
{
};
struct TextureView : View<Texture>
{
};
struct TextureCubeView : View<TextureCube>
{
};
struct StorageImageView : View<StorageImage>
{
};
struct StorageTextureView : View<StorageTexture>
{
};
struct StorageTextureCubeView : View<StorageTextureCube>
{
};
namespace concepts
{
template <typename TView>
concept View = std::derived_from<TView, ::View<typename TView::ImageType>>;
concept View = std::derived_from<TView, View<typename TView::ImageType>>;
template <typename T>
concept ViewRef = Derefencable<T> and View<DereferencesTo<T>>;
@ -106,4 +126,4 @@ concept StorageImageView = View<T> and StorageImage<typename T::ImageType>;
template <typename T>
concept StorageImageViewRef = Derefencable<T> and StorageImageView<DereferencesTo<T>>;
} // namespace concepts
} // namespace concepts

2
aster/include/aster/core/physical_device.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: physical_device.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once

2
aster/include/aster/core/pipeline.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: pipeline.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once

2
aster/include/aster/core/queue_allocation.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: queue_allocation.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once

4
aster/include/aster/core/sampler.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: sampler.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -49,4 +49,4 @@ struct Sampler
{
return m_Sampler;
}
};
};

4
aster/include/aster/core/size.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: size.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -17,4 +17,4 @@ struct Size2D
{
return {m_Width, m_Height};
}
};
};

2
aster/include/aster/core/surface.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: surface.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once

4
aster/include/aster/core/swapchain.h
View File

@ -1,6 +1,6 @@
/// =============================================
// Aster: swapchain.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// ==============================================
#pragma once
@ -44,4 +44,4 @@ struct Swapchain final
private:
void Cleanup();
};
};

7
aster/include/aster/core/type_traits.h
View File

@ -1,10 +1,12 @@
// =============================================
// Aster: type_traits.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
#include "constants.h"
struct Device;
struct Image;
@ -37,6 +39,7 @@ concept SelfDestructible = requires(T a) {
};
template <typename T>
concept Manageable = std::is_default_constructible_v<T> and (DeviceDestructible<T> or SelfDestructible<T>) and RefCounted<T>;
concept Manageable =
std::is_default_constructible_v<T> and (DeviceDestructible<T> or SelfDestructible<T>) and RefCounted<T>;
} // namespace concepts

4
aster/include/aster/core/window.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: window.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -44,4 +44,4 @@ struct Window final
Window &operator=(Window &&other) noexcept;
DISALLOW_COPY_AND_ASSIGN(Window);
};
};

4
aster/include/aster/systems/buffer_manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: buffer_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -21,4 +21,4 @@ class BufferManager final : public Manager<Buffer>
[[nodiscard]] Handle CreateUniformBuffer(usize size, cstr name = nullptr);
[[nodiscard]] Handle CreateStagingBuffer(usize size, cstr name = nullptr);
};
} // namespace systems
} // namespace systems

22
aster/include/aster/systems/commit_manager.h
View File

@ -1,14 +1,14 @@
// =============================================
// Aster: render_resource_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
#include "aster/aster.h"
#include "buffer_manager.h"
#include "view_manager.h"
#include "sampler_manager.h"
#include "view_manager.h"
#include "aster/util/freelist.h"
@ -22,7 +22,6 @@ namespace systems
class CommitManager
{
private:
template <concepts::Manageable T>
struct HandleMapper
{
@ -82,6 +81,7 @@ class CommitManager
}
};
};
static_assert(sizeof(Entry) == 24);
eastl::vector<Entry> m_Data;
@ -102,7 +102,7 @@ class CommitManager
~HandleMapper()
{
for (auto & toDelete : m_ToDelete)
for (auto &toDelete : m_ToDelete)
{
ClearEntries(toDelete);
}
@ -187,14 +187,13 @@ class CommitManager
}
void
ClearEntries(FreeList<Entry>& entries)
ClearEntries(FreeList<Entry> &entries)
{
while (!entries.Empty())
{
Entry &entry = entries.Pop();
entry.mKey.reset();
entry.m_CommitCount = 0;
}
}
};
@ -226,10 +225,12 @@ class CommitManager
ResId<Buffer> CommitBuffer(const Ref<Buffer> &buffer);
// Commit Storage Images
ResId<StorageImageView> CommitStorageImage(const concepts::StorageImageViewRef auto &image)
ResId<StorageImageView>
CommitStorageImage(const concepts::StorageImageViewRef auto &image)
{
return CommitStorageImage(CastView<StorageImageView>(image));
}
ResId<StorageImageView> CommitStorageImage(const Ref<StorageImageView> &image);
// Sampled Images
@ -282,7 +283,8 @@ class CommitManager
return m_DescriptorSet;
}
static CommitManager &Instance()
static CommitManager &
Instance()
{
assert(m_Instance);
return *m_Instance;
@ -317,11 +319,13 @@ class CommitManager
{
m_Buffers.AddRef(handle);
}
void
AddRef(const ResId<TextureView> &handle)
{
m_Images.AddRef(handle);
}
void
AddRef(const ResId<StorageImageView> &handle)
{
@ -333,11 +337,13 @@ class CommitManager
{
m_Buffers.Release(handle);
}
void
Release(const ResId<TextureView> &handle)
{
m_Images.Release(handle);
}
void
Release(const ResId<StorageImageView> &handle)
{

6
aster/include/aster/systems/image_manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: image_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -57,7 +57,7 @@ struct DepthStencilImageCreateInfo
class ImageManager final : public Manager<Image>
{
public:
ImageManager(const Device *device, const u32 maxCount);
ImageManager(const Device *device, u32 maxCount);
template <concepts::Image T>
[[nodiscard]] Ref<T>
@ -80,4 +80,4 @@ class ImageManager final : public Manager<Image>
[[nodiscard]] Ref<Image> CreateAttachment(const AttachmentCreateInfo &createInfo);
[[nodiscard]] Ref<Image> CreateDepthStencilImage(const DepthStencilImageCreateInfo &createInfo);
};
} // namespace systems
} // namespace systems

8
aster/include/aster/systems/manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -67,7 +67,9 @@ class Manager
}
}
void Sweep() requires concepts::SelfDestructible<Type>
void
Sweep()
requires concepts::SelfDestructible<Type>
{
for (i64 i = m_Data.size() - 1; i >= 0; --i)
{
@ -106,4 +108,4 @@ class Manager
return {&pAlloc};
}
};
} // namespace systems
} // namespace systems

4
aster/include/aster/systems/resource.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: resource.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -89,4 +89,4 @@ struct NullId
}
};
} // namespace systems
} // namespace systems

23
aster/include/aster/systems/resource_manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: resource_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -9,8 +9,8 @@
#include "buffer_manager.h"
#include "image_manager.h"
#include "view_manager.h"
#include "sampler_manager.h"
#include "view_manager.h"
namespace systems
{
@ -44,7 +44,8 @@ class ResourceManager
return CastView<T>(handle);
}
[[nodiscard]] Ref<TextureView> CreateTexture2D(const Texture2DCreateInfo &createInfo) const
[[nodiscard]] Ref<TextureView>
CreateTexture2D(const Texture2DCreateInfo &createInfo) const
{
return m_ViewManager->CreateView<TextureView>({
.m_Image = CastImage<Texture>(m_ImageManager->CreateTexture2D(createInfo)),
@ -53,7 +54,9 @@ class ResourceManager
.m_AspectMask = vk::ImageAspectFlagBits::eColor,
});
}
[[nodiscard]] Ref<ImageCubeView> CreateTextureCube(const TextureCubeCreateInfo &createInfo) const
[[nodiscard]] Ref<ImageCubeView>
CreateTextureCube(const TextureCubeCreateInfo &createInfo) const
{
return m_ViewManager->CreateView<ImageCubeView>({
.m_Image = m_ImageManager->CreateTextureCube(createInfo),
@ -63,7 +66,8 @@ class ResourceManager
});
}
[[nodiscard]] Ref<ImageView> CreateAttachment(const AttachmentCreateInfo &createInfo) const
[[nodiscard]] Ref<ImageView>
CreateAttachment(const AttachmentCreateInfo &createInfo) const
{
return m_ViewManager->CreateView({
.m_Image = m_ImageManager->CreateAttachment(createInfo),
@ -73,7 +77,8 @@ class ResourceManager
});
}
[[nodiscard]] Ref<ImageView> CreateDepthStencilImage(const DepthStencilImageCreateInfo &createInfo) const
[[nodiscard]] Ref<ImageView>
CreateDepthStencilImage(const DepthStencilImageCreateInfo &createInfo) const
{
return m_ViewManager->CreateView({
.m_Image = m_ImageManager->CreateDepthStencilImage(createInfo),
@ -124,12 +129,14 @@ class ResourceManager
return m_Samplers;
}
CombinedImageViewManager &CombinedImageViews()
CombinedImageViewManager &
CombinedImageViews()
{
return m_CombinedImageViews;
}
void Update()
void
Update()
{
m_Views.Sweep();
m_Images.Sweep();

11
aster/include/aster/systems/sampler_manager.h
View File

@ -1,12 +1,12 @@
// =============================================
// Aster: sampler_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
#include "manager.h"
#include "EASTL/hash_map.h"
#include "manager.h"
#include "aster/aster.h"
#include "aster/core/sampler.h"
@ -67,7 +67,8 @@ struct SamplerCreateInfo
bool m_CompareEnable = false;
bool m_NormalizedCoordinates = true;
explicit operator vk::SamplerCreateInfo() const
explicit
operator vk::SamplerCreateInfo() const
{
return {
.flags = m_Flags,
@ -100,9 +101,9 @@ class SamplerManager final : public Manager<Sampler>
eastl::hash_map<vk::SamplerCreateInfo, Handle> m_HashToSamplerIdx;
public:
SamplerManager(const Device *device, const u32 maxCount);
SamplerManager(const Device *device, u32 maxCount);
~SamplerManager() override;
Ref<Sampler> CreateSampler(const SamplerCreateInfo &createInfo);
};
} // namespace systems
} // namespace systems

6
aster/include/aster/systems/view_manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: view_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -89,7 +89,7 @@ struct ViewCreateInfo
class ImageViewManager final : public Manager<ImageView>
{
public:
ImageViewManager(const Device *device, const u32 maxCount);
ImageViewManager(const Device *device, u32 maxCount);
template <concepts::ImageView TImageView>
Ref<TImageView>
@ -101,4 +101,4 @@ class ImageViewManager final : public Manager<ImageView>
Ref<ImageView> CreateView(const ViewCreateInfo<> &createInfo);
};
} // namespace systems
} // namespace systems

6
aster/include/aster/util/freelist.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: freelist.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -23,7 +23,7 @@ struct FreeList
using ConstReference = const T &;
using Pointer = T *;
FreeListNode* m_Top;
FreeListNode *m_Top;
FreeList()
: m_Top{nullptr}
@ -93,4 +93,4 @@ struct FreeList
{
m_Top = nullptr;
}
};
};

2
aster/include/aster/util/logger.h
View File

@ -208,4 +208,4 @@ extern Logger g_Logger;
#define DO(code) , code
#define ABORT(code) exit(Cast<i32>(code))
#define THEN_ABORT(code) , ABORT(code)
#define THEN_ABORT(code) , ABORT(code)

18
aster/src/aster/core/buffer.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: buffer.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/buffer.h"
@ -113,7 +113,7 @@ StorageBuffer::Init(const Device *device, usize size, bool hostVisible, bool dev
vk::BufferUsageFlags usage = vk::BufferUsageFlagBits::eStorageBuffer;
if (deviceAddress)
{
usage |= vk::BufferUsageFlagBits::eShaderDeviceAddress;
usage |= vk::BufferUsageFlagBits::eShaderDeviceAddress;
}
if (hostVisible)
{
@ -125,8 +125,7 @@ StorageBuffer::Init(const Device *device, usize size, bool hostVisible, bool dev
else
{
usage |= vk::BufferUsageFlagBits::eTransferDst;
Allocate(device, size, usage, 0,
VMA_MEMORY_USAGE_AUTO, name);
Allocate(device, size, usage, 0, VMA_MEMORY_USAGE_AUTO, name);
}
}
@ -155,7 +154,8 @@ StorageIndexBuffer::Init(const Device *device, usize size, bool hostVisible, boo
void
IndirectBuffer::Init(const Device *device, usize size, bool hostVisible, cstr name)
{
vk::BufferUsageFlags usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eIndirectBuffer | vk::BufferUsageFlagBits::eShaderDeviceAddress;
vk::BufferUsageFlags usage = vk::BufferUsageFlagBits::eStorageBuffer | vk::BufferUsageFlagBits::eIndirectBuffer |
vk::BufferUsageFlagBits::eShaderDeviceAddress;
if (hostVisible)
{
Allocate(device, size, usage,
@ -173,15 +173,15 @@ IndirectBuffer::Init(const Device *device, usize size, bool hostVisible, cstr na
void
VertexBuffer::Init(const Device *device, usize size, cstr name)
{
Allocate(device, size, vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst,
0, VMA_MEMORY_USAGE_AUTO, name);
Allocate(device, size, vk::BufferUsageFlagBits::eVertexBuffer | vk::BufferUsageFlagBits::eTransferDst, 0,
VMA_MEMORY_USAGE_AUTO, name);
}
void
IndexBuffer::Init(const Device *device, usize size, cstr name)
{
Allocate(device, size, vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst,
0, VMA_MEMORY_USAGE_AUTO, name);
Allocate(device, size, vk::BufferUsageFlagBits::eIndexBuffer | vk::BufferUsageFlagBits::eTransferDst, 0,
VMA_MEMORY_USAGE_AUTO, name);
}
void

4
aster/src/aster/core/context.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: context.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/context.h"
@ -122,4 +122,4 @@ Context::operator=(Context &&other) noexcept
m_Instance = Take(other.m_Instance);
m_DebugMessenger = Take(other.m_DebugMessenger);
return *this;
}
}

2
aster/src/aster/core/device.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: device.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/device.h"

4
aster/src/aster/core/global.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: global.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/global.h"
@ -51,7 +51,7 @@ struct fmt::formatter<MemorySize>
template <typename Context>
// ReSharper disable once CppInconsistentNaming
constexpr auto
format(MemorySize const &mem, Context &ctx) const
format(const MemorySize &mem, Context &ctx) const
{
// return format_to(ctx.out(), "({}, {})", foo.a, foo.b); // --== KEY LINE ==--
if (mem.m_Gigabytes > 0)

581
aster/src/aster/core/image.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: image.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/image.h"
@ -24,8 +24,8 @@ Image::DestroyView(const vk::ImageView imageView) const
}
//
//void
//Texture::Init(const Device *device, const vk::Extent2D extent, vk::Format imageFormat, const bool isMipMapped,
// void
// Texture::Init(const Device *device, const vk::Extent2D extent, vk::Format imageFormat, const bool isMipMapped,
// const cstr name)
//{
// WARN_IF(!IsPowerOfTwo(extent.width) || !IsPowerOfTwo(extent.width), "Image {2} is {0}x{1} (Non Power of Two)",
@ -92,9 +92,9 @@ Image::DestroyView(const vk::ImageView imageView) const
//}
//
///*
//Cube map Faces info.
// Cube map Faces info.
//
//TODO: Correct this based on the actual layout for upside down viewport.
// TODO: Correct this based on the actual layout for upside down viewport.
//
//| Axis | Layer | Up |
//|:----:|:-----:|:--:|
@ -105,325 +105,330 @@ Image::DestroyView(const vk::ImageView imageView) const
//| +z | 4 | -y |
//| -z | 5 | -y |
//
//Remember, we use upside down viewport.
// Remember, we use upside down viewport.
//
//*/
//
//void
//TextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isMipMapped, cstr name)
// void
// TextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isMipMapped, cstr name)
//{
// WARN_IF(!IsPowerOfTwo(cubeSide), "Image Cube {1} has side {0}x{0} (Non Power of Two)", cubeSide,
// name ? name : "<unnamed>");
// WARN_IF(!IsPowerOfTwo(cubeSide), "Image Cube {1} has side {0}x{0} (Non Power of Two)", cubeSide,
// name ? name : "<unnamed>");
//
// const u8 mipLevels = isMipMapped ? 1 + Cast<u8>(floor(log2(cubeSide))) : 1;
// const u8 mipLevels = isMipMapped ? 1 + Cast<u8>(floor(log2(cubeSide))) : 1;
//
// auto usage = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst;
// if (isMipMapped)
// {
// usage |= vk::ImageUsageFlagBits::eTransferSrc;
// }
// auto usage = vk::ImageUsageFlagBits::eSampled | vk::ImageUsageFlagBits::eTransferDst;
// if (isMipMapped)
// {
// usage |= vk::ImageUsageFlagBits::eTransferSrc;
// }
//
// const vk::Extent3D extent = {.width = cubeSide, .height = cubeSide, .depth = 1};
// const vk::Extent3D extent = {.width = cubeSide, .height = cubeSide, .depth = 1};
//
// vk::ImageCreateInfo imageCreateInfo = {
// .flags = vk::ImageCreateFlagBits::eCubeCompatible,
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = extent,
// .mipLevels = mipLevels,
// .arrayLayers = 6,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
// vk::ImageCreateInfo imageCreateInfo = {
// .flags = vk::ImageCreateFlagBits::eCubeCompatible,
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = extent,
// .mipLevels = mipLevels,
// .arrayLayers = 6,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
//
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
//
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::eCube,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = mipLevels,
// .baseArrayLayer = 0,
// .layerCount = 6,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::eCube,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = mipLevels,
// .baseArrayLayer = 0,
// .layerCount = 6,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = extent;
// m_MipLevels = mipLevels;
// m_LayerCount = 6;
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = extent;
// m_MipLevels = mipLevels;
// m_LayerCount = 6;
//
// device->SetName(m_Image, name);
//}
// device->SetName(m_Image, name);
// }
//
//void
//AttachmentImage::Init(const Device *device, vk::Extent2D extent, vk::Format imageFormat, cstr name)
// void
// AttachmentImage::Init(const Device *device, vk::Extent2D extent, vk::Format imageFormat, cstr name)
//{
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
//
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate depth buffer. Cause: {}", result) THEN_ABORT(result);
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate depth buffer. Cause: {}", result) THEN_ABORT(result);
//
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result) THEN_ABORT(result);
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result)
// THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
//
// device->SetName(m_Image, name);
//}
// device->SetName(m_Image, name);
// }
//
//void
//DepthImage::Init(const Device *device, vk::Extent2D extent, cstr name)
// void
// DepthImage::Init(const Device *device, vk::Extent2D extent, cstr name)
//{
// constexpr vk::Format imageFormat = vk::Format::eD24UnormS8Uint;
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = vk::ImageUsageFlagBits::eDepthStencilAttachment,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
// constexpr vk::Format imageFormat = vk::Format::eD24UnormS8Uint;
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = vk::ImageUsageFlagBits::eDepthStencilAttachment,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = VMA_ALLOCATION_CREATE_DEDICATED_MEMORY_BIT,
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
//
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate depth buffer. Cause: {}", result) THEN_ABORT(result);
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate depth buffer. Cause: {}", result) THEN_ABORT(result);
//
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eDepth,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create depth image view {}. Cause: {}", name, result) THEN_ABORT(result);
// vk::ImageView view;
// vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eDepth,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create depth image view {}. Cause: {}", name, result) THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
//
// device->SetName(m_Image, name);
//}
// device->SetName(m_Image, name);
// }
//
//void
//StorageTexture::Init(const Device *device, vk::Extent2D extent, const vk::Format imageFormat, const bool isSampled,
// cstr name)
// void
// StorageTexture::Init(const Device *device, vk::Extent2D extent, const vk::Format imageFormat, const bool isSampled,
// cstr name)
//{
// // Reasoning:
// // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
// // results.
// auto usage =
// vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst;
// if (isSampled)
// {
// WARN_IF(!IsPowerOfTwo(extent.width) || !IsPowerOfTwo(extent.width), "Image {2} is {0}x{1} (Non Power of Two)",
// extent.width, extent.height, name ? name : "<unnamed>");
// usage |= vk::ImageUsageFlagBits::eSampled;
// }
// // Reasoning:
// // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
// // results.
// auto usage =
// vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc |
// vk::ImageUsageFlagBits::eTransferDst;
// if (isSampled)
// {
// WARN_IF(!IsPowerOfTwo(extent.width) || !IsPowerOfTwo(extent.width), "Image {2} is {0}x{1} (Non Power of
// Two)",
// extent.width, extent.height, name ? name : "<unnamed>");
// usage |= vk::ImageUsageFlagBits::eSampled;
// }
//
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
// vk::ImageCreateInfo imageCreateInfo = {
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = ToExtent3D(extent, 1),
// .mipLevels = 1,
// .arrayLayers = 1,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
//
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
//
// vk::ImageView view;
// const vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
// vk::ImageView view;
// const vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::e2D,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = 1,
// .baseArrayLayer = 0,
// .layerCount = 1,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = 1;
// m_LayerCount = 1;
//
// device->SetName(m_Image, name);
//}
// device->SetName(m_Image, name);
// }
//
//void
//StorageTextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isSampled, bool isMipMapped,
// cstr name)
// void
// StorageTextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isSampled, bool
// isMipMapped,
// cstr name)
//{
// // Reasoning:
// // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
// // results.
// auto usage =
// vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc | vk::ImageUsageFlagBits::eTransferDst;
// if (isSampled)
// {
// WARN_IF(!IsPowerOfTwo(cubeSide), "Image {1} is {0}x{0} (Non Power of Two)", cubeSide,
// name ? name : "<unnamed>");
// usage |= vk::ImageUsageFlagBits::eSampled;
// }
// // Reasoning:
// // Transfer Src and Dst to copy to and from the buffer since Storage will often be loaded with info, and read for
// // results.
// auto usage =
// vk::ImageUsageFlagBits::eStorage | vk::ImageUsageFlagBits::eTransferSrc |
// vk::ImageUsageFlagBits::eTransferDst;
// if (isSampled)
// {
// WARN_IF(!IsPowerOfTwo(cubeSide), "Image {1} is {0}x{0} (Non Power of Two)", cubeSide,
// name ? name : "<unnamed>");
// usage |= vk::ImageUsageFlagBits::eSampled;
// }
//
// const u8 mipLevels = isMipMapped ? 1 + Cast<u8>(floor(log2(cubeSide))) : 1;
// const u8 mipLevels = isMipMapped ? 1 + Cast<u8>(floor(log2(cubeSide))) : 1;
//
// vk::ImageCreateInfo imageCreateInfo = {
// .flags = vk::ImageCreateFlagBits::eCubeCompatible,
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = {cubeSide, cubeSide, 1},
// .mipLevels = mipLevels,
// .arrayLayers = 6,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
// vk::ImageCreateInfo imageCreateInfo = {
// .flags = vk::ImageCreateFlagBits::eCubeCompatible,
// .imageType = vk::ImageType::e2D,
// .format = imageFormat,
// .extent = {cubeSide, cubeSide, 1},
// .mipLevels = mipLevels,
// .arrayLayers = 6,
// .samples = vk::SampleCountFlagBits::e1,
// .tiling = vk::ImageTiling::eOptimal,
// .usage = usage,
// .sharingMode = vk::SharingMode::eExclusive,
// .initialLayout = vk::ImageLayout::eUndefined,
// };
// constexpr VmaAllocationCreateInfo allocationCreateInfo = {
// .flags = {},
// .usage = VMA_MEMORY_USAGE_AUTO,
// };
//
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
// VkImage image;
// VmaAllocation allocation;
// auto result = Cast<vk::Result>(vmaCreateImage(device->m_Allocator, Recast<VkImageCreateInfo *>(&imageCreateInfo),
// &allocationCreateInfo, &image, &allocation, nullptr));
// ERROR_IF(Failed(result), "Could not allocate image {}. Cause: {}", name, result) THEN_ABORT(result);
//
// vk::ImageView view;
// const vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::eCube,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = mipLevels,
// .baseArrayLayer = 0,
// .layerCount = 6,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
// vk::ImageView view;
// const vk::ImageViewCreateInfo imageViewCreateInfo = {
// .image = image,
// .viewType = vk::ImageViewType::eCube,
// .format = imageFormat,
// .components = {},
// .subresourceRange =
// {
// .aspectMask = vk::ImageAspectFlagBits::eColor,
// .baseMipLevel = 0,
// .levelCount = mipLevels,
// .baseArrayLayer = 0,
// .layerCount = 6,
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create image view {}. Cause: {}", name, result) THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = mipLevels;
// m_LayerCount = 6;
// m_Device = device;
// m_Image = image;
// m_View = view;
// m_Allocation = allocation;
// m_Extent = imageCreateInfo.extent;
// m_MipLevels = mipLevels;
// m_LayerCount = 6;
//
// device->SetName(m_Image, name);
//}
// device->SetName(m_Image, name);
// }

4
aster/src/aster/core/physical_device.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: physical_device.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/physical_device.h"
@ -161,4 +161,4 @@ PhysicalDevices::PhysicalDevices(const Surface *surface, const Context *context)
{
this->emplace_back(surface->m_Surface, physicalDevice);
}
}
}

2
aster/src/aster/core/pipeline.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: pipeline.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/pipeline.h"

2
aster/src/aster/core/sampler.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: sampler.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/sampler.h"

2
aster/src/aster/core/surface.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: surface.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/surface.h"

6
aster/src/aster/core/swapchain.cpp
View File

@ -1,6 +1,6 @@
/// =============================================
// Aster: swapchain.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// ==============================================
#include "core/swapchain.h"
@ -67,7 +67,7 @@ Swapchain::Create(const Surface *surface, Size2D size)
auto presentModes = GetSurfacePresentModes(m_Device->m_PhysicalDevice, surface->m_Surface);
m_Format = vk::Format::eUndefined;
vk::ColorSpaceKHR swapchainColorSpace = vk::ColorSpaceKHR::eSrgbNonlinear;
auto swapchainColorSpace = vk::ColorSpaceKHR::eSrgbNonlinear;
for (auto [format, colorSpace] : surfaceFormats)
{
if (format == vk::Format::eB8G8R8A8Srgb && colorSpace == vk::ColorSpaceKHR::eSrgbNonlinear)
@ -84,7 +84,7 @@ Swapchain::Create(const Surface *surface, Size2D size)
swapchainColorSpace = colorSpace;
}
vk::PresentModeKHR swapchainPresentMode = vk::PresentModeKHR::eFifo;
auto swapchainPresentMode = vk::PresentModeKHR::eFifo;
for (const auto presentMode : presentModes)
{
if (presentMode == vk::PresentModeKHR::eMailbox)

6
aster/src/aster/core/window.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: window.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "core/window.h"
@ -96,7 +96,7 @@ Window::~Window()
--m_WindowCount;
}
if (m_WindowCount== 0 && m_IsGlfwInit)
if (m_WindowCount == 0 && m_IsGlfwInit)
{
glfwTerminate();
m_IsGlfwInit = false;
@ -119,4 +119,4 @@ Window::operator=(Window &&other) noexcept
m_Window = Take(other.m_Window);
m_Name = Take(other.m_Name);
return *this;
}
}

26
aster/src/aster/systems/commit_manager.cpp
View File

@ -36,8 +36,8 @@ using namespace systems;
CommitManager *CommitManager::m_Instance = nullptr;
CommitManager::CommitManager(const Device *device, u32 const maxBuffers, const u32 maxImages, const u32 maxStorageImages,
Ref<Sampler> defaultSampler)
CommitManager::CommitManager(const Device *device, const u32 maxBuffers, const u32 maxImages,
const u32 maxStorageImages, Ref<Sampler> defaultSampler)
: m_Device{device}
, m_Buffers{maxBuffers}
, m_Images{maxImages}
@ -55,10 +55,10 @@ CommitManager::CommitManager(const Device *device, u32 const maxBuffers, const u
.type = vk::DescriptorType::eCombinedImageSampler,
.descriptorCount = maxImages,
},
vk::DescriptorPoolSize{
.type = vk::DescriptorType::eStorageImage,
.descriptorCount = maxStorageImages,
},
vk::DescriptorPoolSize{
.type = vk::DescriptorType::eStorageImage,
.descriptorCount = maxStorageImages,
},
};
const vk::DescriptorPoolCreateInfo poolCreateInfo = {
@ -82,12 +82,12 @@ CommitManager::CommitManager(const Device *device, u32 const maxBuffers, const u
.descriptorCount = Cast<u32>(maxImages),
.stageFlags = vk::ShaderStageFlagBits::eAll,
},
vk::DescriptorSetLayoutBinding{
.binding = STORAGE_IMAGE_BINDING_INDEX,
.descriptorType = vk::DescriptorType::eStorageImage,
.descriptorCount = Cast<u32>(maxStorageImages),
.stageFlags = vk::ShaderStageFlagBits::eAll,
},
vk::DescriptorSetLayoutBinding{
.binding = STORAGE_IMAGE_BINDING_INDEX,
.descriptorType = vk::DescriptorType::eStorageImage,
.descriptorCount = Cast<u32>(maxStorageImages),
.stageFlags = vk::ShaderStageFlagBits::eAll,
},
};
vk::DescriptorBindingFlags bindingFlags =
@ -258,4 +258,4 @@ CommitManager::Update()
m_Buffers.Update();
m_Images.Update();
}
}

2
aster/src/aster/systems/image_manager.cpp
View File

@ -225,7 +225,7 @@ ToImageCreateInfo(const DepthStencilImageCreateInfo &createInfo)
{
auto &[extent, name] = createInfo;
constexpr vk::Format format = vk::Format::eD24UnormS8Uint;
constexpr auto format = vk::Format::eD24UnormS8Uint;
constexpr auto usage = usage_flags::DEPTH_STENCIL_ATTACHMENT;
return {

2
aster/src/aster/systems/manager.cpp
View File

@ -3,4 +3,4 @@
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "systems/manager.h"
#include "systems/manager.h"

2
aster/src/aster/systems/sampler_manager.cpp
View File

@ -35,4 +35,4 @@ SamplerManager::CreateSampler(const SamplerCreateInfo &createInfo)
m_HashToSamplerIdx.emplace(vkCreateInfo, object);
return object;
}
}

6
aster/src/aster/systems/view_manager.cpp
View File

@ -19,11 +19,9 @@ ImageViewManager::CreateView(const ViewCreateInfo<> &createInfo)
{
const auto layerCount = createInfo.GetLayerCount();
const auto mipCount = createInfo.GetMipLevelCount();
ERROR_IF((createInfo.m_BaseLayer + layerCount) > createInfo.m_Image->m_LayerCount,
"Invalid Layer Access")
ERROR_IF((createInfo.m_BaseLayer + layerCount) > createInfo.m_Image->m_LayerCount, "Invalid Layer Access")
THEN_ABORT(-1);
ERROR_IF((createInfo.m_BaseMipLevel + mipCount) > createInfo.m_Image->m_MipLevels,
"Invalid Mip Level Access")
ERROR_IF((createInfo.m_BaseMipLevel + mipCount) > createInfo.m_Image->m_MipLevels, "Invalid Mip Level Access")
THEN_ABORT(-1);
vk::ImageView view;

6
aster/src/aster/util/logger.cpp
View File

@ -1,11 +1,11 @@
// =============================================
// Aster: logger.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "util/logger.h"
Logger g_Logger = Logger();
auto g_Logger = Logger();
// ReSharper disable once CppInconsistentNaming
/* Credits to Const-me */
@ -16,4 +16,4 @@ AssertionFailure(const char *af)
{
ERROR("{}", af);
}
} // namespace eastl
} // namespace eastl

4
samples/00_util/frame.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: frame.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "frame.h"
@ -171,4 +171,4 @@ FrameManager::GetNextFrame(Swapchain *swapchain, const Surface *surface, Size2D
currentFrame->m_ImageIdx = imageIndex;
return currentFrame;
}
}

6
samples/00_util/frame.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: frame.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -31,7 +31,7 @@ struct Frame
// Transient
u32 m_ImageIdx;
void Present(const vk::Queue commandQueue, Swapchain* swapchain, const Surface* surface, Size2D size);
void Present(vk::Queue commandQueue, Swapchain *swapchain, const Surface *surface, Size2D size);
Frame(const Device *device, u32 queueFamilyIndex, u32 frameCount);
~Frame();
@ -52,4 +52,4 @@ struct FrameManager
FrameManager(const Device *device, u32 queueFamilyIndex, u32 framesInFlight);
Frame *GetNextFrame(Swapchain *swapchain, const Surface *surface, Size2D size);
};
};

26
samples/00_util/gui.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: gui.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "gui.h"
@ -108,7 +108,7 @@ StartBuild()
ImGui_ImplGlfw_NewFrame();
NewFrame();
static ImGuiDockNodeFlags dockspaceFlags = ImGuiDockNodeFlags_None | ImGuiDockNodeFlags_PassthruCentralNode;
static ImGuiDockNodeFlags dockspaceFlags = ImGuiDockNodeFlags_None | ImGuiDockNodeFlags_PassthruCentralNode;
// We are using the ImGuiWindowFlags_NoDocking flag to make the parent window not dockable into,
// because it would be confusing to have two docking targets within each others.
@ -130,18 +130,18 @@ StartBuild()
// all active windows docked into it will lose their parent and become undocked.
// We cannot preserve the docking relationship between an active window and an inactive docking, otherwise
// any change of dockspace/settings would lead to windows being stuck in limbo and never being visible.
PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
Begin("DockSpace Demo", nullptr, windowFlags);
PopStyleVar();
PushStyleVar(ImGuiStyleVar_WindowPadding, ImVec2(0.0f, 0.0f));
Begin("DockSpace Demo", nullptr, windowFlags);
PopStyleVar();
PopStyleVar(2);
PopStyleVar(2);
// DockSpace
if (GetIO().ConfigFlags & ImGuiConfigFlags_DockingEnable)
{
const ImGuiID dockspaceId = GetID("MyDockSpace");
DockSpace(dockspaceId, ImVec2(0.0f, 0.0f), dockspaceFlags);
}
// DockSpace
if (GetIO().ConfigFlags & ImGuiConfigFlags_DockingEnable)
{
const ImGuiID dockspaceId = GetID("MyDockSpace");
DockSpace(dockspaceId, ImVec2(0.0f, 0.0f), dockspaceFlags);
}
}
void
@ -213,4 +213,4 @@ PopDisable()
PopStyleVar();
PopItemFlag();
}
} // namespace ImGui
} // namespace ImGui

2
samples/00_util/gui.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: gui.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once

2
samples/00_util/helpers.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: helpers.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "helpers.h"

4
samples/00_util/helpers.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: helpers.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -46,4 +46,4 @@ using StackString = eastl::fixed_string<char, TSize, false>;
{ \
auto _checkResultValue_ = Cast<vk::Result>(RESULT); \
ERROR_IF(Failed(_checkResultValue_), MSG " Cause: {}", _checkResultValue_) THEN_ABORT(_checkResultValue_); \
} while (false)
} while (false)

2
samples/01_triangle/triangle.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: triangle.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "aster/aster.h"

23
samples/02_box/box.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: box.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "aster/aster.h"
@ -19,12 +19,12 @@
#define STB_IMAGE_IMPLEMENTATION
#include "aster/systems/buffer_manager.h"
#include "aster/systems/image_manager.h"
#include "aster/systems/commit_manager.h"
#include "aster/systems/image_manager.h"
#include "aster/systems/resource_manager.h"
#include "aster/systems/view_manager.h"
#include "frame.h"
#include "stb_image.h"
#include "aster/systems/view_manager.h"
#include "aster/systems/resource_manager.h"
#include <EASTL/array.h>
@ -139,7 +139,7 @@ main(int, char **)
Camera camera = {
.m_Model = {1.0f},
.m_View = glm::lookAt(vec3(0.0f, 2.0f, 2.0f), vec3(0.0f), vec3(0.0f, 1.0f, 0.0f)),
.m_View = lookAt(vec3(0.0f, 2.0f, 2.0f), vec3(0.0f), vec3(0.0f, 1.0f, 0.0f)),
.m_Perspective = glm::perspective(
70_deg, Cast<f32>(swapchain.m_Extent.width) / Cast<f32>(swapchain.m_Extent.height), 0.1f, 100.0f),
};
@ -214,12 +214,11 @@ main(int, char **)
auto vbo = resourceManager.Buffers().CreateStorageBuffer(vertices.size() * sizeof vertices[0], "Vertex Buffer");
vbo->Write(0, vertices.size() * sizeof vertices[0], vertices.data());
auto crate = resourceManager.CombinedImageViews()
.CreateTexture2D({
.m_Format = vk::Format::eR8G8B8A8Srgb,
.m_Extent = {imageFile.m_Width, imageFile.m_Height},
.m_Name = "Crate Texture",
});
auto crate = resourceManager.CombinedImageViews().CreateTexture2D({
.m_Format = vk::Format::eR8G8B8A8Srgb,
.m_Extent = {imageFile.m_Width, imageFile.m_Height},
.m_Name = "Crate Texture",
});
{
StagingBuffer imageStaging;
@ -411,7 +410,7 @@ main(int, char **)
{
systems::ResId<Buffer> m_Camera;
systems::ResId<Buffer> m_VertexBuffer;
systems::ResId<TextureView> m_Texture;
systems::ResId<TextureView> m_Texture;
};
PCB pcb = {

38
samples/03_model_render/asset_loader.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: asset_loader.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "aster/core/buffer.h"
@ -553,8 +553,8 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
if (!model.materials.empty())
{
// TODO("Something broken on load here.");
auto getTextureHandle = [this, &textureHandleMap, &stagingBuffers, &model](i32 index,
const bool isSrgb) -> systems::ResId<TextureView> {
auto getTextureHandle = [this, &textureHandleMap, &stagingBuffers,
&model](i32 index, const bool isSrgb) -> systems::ResId<TextureView> {
if (index < 0)
{
return systems::NullId{};
@ -642,12 +642,12 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
if (posAccessor->type == TINYGLTF_TYPE_VEC4)
{
vec4 *data = Recast<vec4 *>(posBuffer->data.data() + byteOffset);
auto data = Recast<vec4 *>(posBuffer->data.data() + byteOffset);
vertexPositions.insert(vertexPositions.end(), data, data + vertexCount);
}
else if (posAccessor->type == TINYGLTF_TYPE_VEC3)
{
vec3 *data = Recast<vec3 *>(posBuffer->data.data() + byteOffset);
auto data = Recast<vec3 *>(posBuffer->data.data() + byteOffset);
for (u32 i = 0; i < vertexCount; ++i)
{
vertexPositions.push_back(vec4(data[i], 1.0f));
@ -655,7 +655,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
}
else if (posAccessor->type == TINYGLTF_TYPE_VEC2)
{
vec2 *data = Recast<vec2 *>(posBuffer->data.data() + byteOffset);
auto data = Recast<vec2 *>(posBuffer->data.data() + byteOffset);
for (u32 i = 0; i < vertexCount; ++i)
{
vertexPositions.push_back(vec4(data[i], 0.0f, 1.0f));
@ -679,7 +679,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
if (normAccessor->type == TINYGLTF_TYPE_VEC4)
{
vec4 *data = Recast<vec4 *>(normBuffer->data.data() + byteOffset);
auto data = Recast<vec4 *>(normBuffer->data.data() + byteOffset);
vec4 *end = data + vertexCount;
u32 idx = vertexOffset;
@ -691,7 +691,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
}
else if (normAccessor->type == TINYGLTF_TYPE_VEC3)
{
vec3 *data = Recast<vec3 *>(normBuffer->data.data() + byteOffset);
auto data = Recast<vec3 *>(normBuffer->data.data() + byteOffset);
for (u32 i = 0; i < vertexCount; ++i)
{
auto norm = vec4(data[i], 0.0f);
@ -700,7 +700,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
}
else if (normAccessor->type == TINYGLTF_TYPE_VEC2)
{
vec2 *data = Recast<vec2 *>(normBuffer->data.data() + byteOffset);
auto data = Recast<vec2 *>(normBuffer->data.data() + byteOffset);
for (u32 i = 0; i < vertexCount; ++i)
{
auto norm = vec4(data[i], 0.0f, 0.0f);
@ -723,7 +723,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
assert(uvAccessor->type == TINYGLTF_TYPE_VEC2 &&
uvAccessor->componentType == TINYGLTF_COMPONENT_TYPE_FLOAT);
{
vec2 *data = Recast<vec2 *>(uvBuffer->data.data() + byteOffset);
auto data = Recast<vec2 *>(uvBuffer->data.data() + byteOffset);
vec2 *end = data + vertexCount;
u32 idx = vertexOffset;
vec2 *it = data;
@ -746,7 +746,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
if (colorAccessor->type == TINYGLTF_TYPE_VEC4)
{
vec4 *data = Recast<vec4 *>(colorBuffer->data.data() + byteOffset);
auto data = Recast<vec4 *>(colorBuffer->data.data() + byteOffset);
vec4 *end = data + vertexCount;
u32 idx = vertexOffset;
@ -758,7 +758,7 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
}
else if (colorAccessor->type == TINYGLTF_TYPE_VEC3)
{
vec3 *data = Recast<vec3 *>(colorBuffer->data.data() + byteOffset);
auto data = Recast<vec3 *>(colorBuffer->data.data() + byteOffset);
for (u32 i = 0; i < vertexCount; ++i)
{
auto color = vec4(data[i], 1.0f);
@ -784,17 +784,17 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT)
{
u32 *data = Recast<u32 *>(indexBuffer->data.data() + byteOffset);
auto data = Recast<u32 *>(indexBuffer->data.data() + byteOffset);
indices.insert(indices.end(), data, data + indexCount);
}
else if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT)
{
u16 *data = Recast<u16 *>(indexBuffer->data.data() + byteOffset);
auto data = Recast<u16 *>(indexBuffer->data.data() + byteOffset);
indices.insert(indices.end(), data, data + indexCount);
}
else if (indexAccessor->componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_BYTE)
{
u8 *data = Recast<u8 *>(indexBuffer->data.data() + byteOffset);
auto data = Recast<u8 *>(indexBuffer->data.data() + byteOffset);
indices.insert(indices.end(), data, data + indexCount);
}
}
@ -831,10 +831,10 @@ AssetLoader::LoadModelToGpu(cstr path, cstr name)
&meshPrimitives](i32 idx, i32 parent) -> void {
const auto *node = &model.nodes[idx];
vec3 nodeTranslation = vec3{0.0f};
quat nodeRotation = quat{1.0f, 0.0f, 0.0f, 0.0f};
vec3 nodeScale = vec3{1.0f};
mat4 nodeMatrix = mat4{1.0f};
auto nodeTranslation = vec3{0.0f};
auto nodeRotation = quat{1.0f, 0.0f, 0.0f, 0.0f};
auto nodeScale = vec3{1.0f};
auto nodeMatrix = mat4{1.0f};
if (node->translation.size() == 3)
{
nodeTranslation = glm::make_vec3(node->translation.data());

31
samples/03_model_render/asset_loader.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: asset_loader.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -9,11 +9,11 @@
#include "aster/core/buffer.h"
#include "aster/systems/image_manager.h"
#include "aster/systems/resource.h"
#include "aster/systems/view_manager.h"
#include "nodes.h"
#include "tiny_gltf.h"
#include "aster/systems/image_manager.h"
#include "aster/systems/view_manager.h"
#include "aster/systems/resource.h"
namespace systems
{
@ -22,7 +22,7 @@ class SamplerManager;
class BufferManager;
class ImageManager;
class CommitManager;
}
} // namespace systems
namespace tinygltf
{
@ -46,10 +46,10 @@ struct MeshPrimitive
struct Material
{
vec4 m_AlbedoFactor; // 16 16
vec3 m_EmissionFactor; // 12 28
f32 m_MetalFactor; // 04 32
f32 m_RoughFactor; // 04 36
vec4 m_AlbedoFactor; // 16 16
vec3 m_EmissionFactor; // 12 28
f32 m_MetalFactor; // 04 32
f32 m_RoughFactor; // 04 36
systems::ResId<TextureView> m_AlbedoTex; // 04 40
systems::ResId<TextureView> m_NormalTex; // 04 44
systems::ResId<TextureView> m_MetalRoughTex; // 04 48
@ -88,8 +88,9 @@ struct Model
void SetModelTransform(const mat4 &transform);
void Update();
Model(systems::CommitManager *resourceManager, eastl::vector<systems::ResId<TextureView>> &textureHandles, Nodes &&nodes, Ref<Buffer> nodeBuffer,
ModelHandles &handles, Ref<Buffer> indexBuffer, const eastl::vector<MeshPrimitive> &meshPrimitives);
Model(systems::CommitManager *resourceManager, eastl::vector<systems::ResId<TextureView>> &textureHandles,
Nodes &&nodes, Ref<Buffer> nodeBuffer, ModelHandles &handles, Ref<Buffer> indexBuffer,
const eastl::vector<MeshPrimitive> &meshPrimitives);
~Model() = default;
Model(Model &&other) noexcept = default;
@ -124,8 +125,7 @@ struct AssetLoader
constexpr static auto AWeights0 = "WEIGHTS_0";
AssetLoader(systems::ResourceManager *resourceManager, systems::CommitManager *commitManager,
vk::Queue transferQueue, u32 transferQueueIndex,
u32 graphicsQueueIndex);
vk::Queue transferQueue, u32 transferQueueIndex, u32 graphicsQueueIndex);
~AssetLoader();
AssetLoader(AssetLoader &&other) noexcept;
@ -138,7 +138,6 @@ void
GenerateMipMaps(vk::CommandBuffer commandBuffer, const Ref<Texture> &textureView, vk::ImageLayout initialLayout,
vk::ImageLayout finalLayout, vk::PipelineStageFlags2 prevStage, vk::PipelineStageFlags2 finalStage);
void
GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageRef auto &texture, vk::ImageLayout initialLayout,
vk::ImageLayout finalLayout,
@ -150,8 +149,8 @@ GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageRef auto
}
void
GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageViewRef auto &texture, vk::ImageLayout initialLayout,
vk::ImageLayout finalLayout,
GenerateMipMaps(vk::CommandBuffer commandBuffer, concepts::SampledImageViewRef auto &texture,
vk::ImageLayout initialLayout, vk::ImageLayout finalLayout,
vk::PipelineStageFlags2 prevStage = vk::PipelineStageFlagBits2::eAllCommands,
vk::PipelineStageFlags2 finalStage = vk::PipelineStageFlagBits2::eAllCommands)
{

10
samples/03_model_render/ibl_helpers.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: ibl_helpers.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "ibl_helpers.h"
@ -18,10 +18,10 @@
#include <EASTL/fixed_vector.h>
#include <EASTL/tuple.h>
constexpr cstr EQUIRECT_TO_CUBE_SHADER_FILE = "shader/eqrect_to_cube.cs.hlsl.spv";
constexpr cstr DIFFUSE_IRRADIANCE_SHADER_FILE = "shader/diffuse_irradiance.cs.hlsl.spv";
constexpr cstr PREFILTER_SHADER_FILE = "shader/prefilter.cs.hlsl.spv";
constexpr cstr BRDF_LUT_SHADER_FILE = "shader/brdf_lut.cs.hlsl.spv";
constexpr auto EQUIRECT_TO_CUBE_SHADER_FILE = "shader/eqrect_to_cube.cs.hlsl.spv";
constexpr auto DIFFUSE_IRRADIANCE_SHADER_FILE = "shader/diffuse_irradiance.cs.hlsl.spv";
constexpr auto PREFILTER_SHADER_FILE = "shader/prefilter.cs.hlsl.spv";
constexpr auto BRDF_LUT_SHADER_FILE = "shader/brdf_lut.cs.hlsl.spv";
Environment
CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, const u32 cubeSide,

8
samples/03_model_render/ibl_helpers.h
View File

@ -1,14 +1,14 @@
// =============================================
// Aster: ibl_helpers.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
#include "aster/aster.h"
#include "aster/systems/resource.h"
#include "aster/core/image.h"
#include "aster/core/image_view.h"
#include "aster/systems/resource.h"
struct Pipeline;
struct Texture;
@ -23,5 +23,5 @@ struct Environment
systems::ResId<TextureView> m_BrdfLut;
};
Environment CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, u32 cubeSide, systems::ResId<TextureView> hdrEnv,
cstr name = nullptr);
Environment CreateCubeFromHdrEnv(AssetLoader *assetLoader, vk::Queue computeQueue, u32 cubeSide,
systems::ResId<TextureView> hdrEnv, cstr name = nullptr);

9
samples/03_model_render/light_manager.cpp
View File

@ -1,14 +1,14 @@
// =============================================
// Aster: light_manager.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "light_manager.h"
#include "aster/core/buffer.h"
#include "aster/systems/commit_manager.h"
#include "aster/systems/resource.h"
#include "aster/systems/resource_manager.h"
#include "aster/systems/commit_manager.h"
#include "glm/ext/matrix_transform.hpp"
// Static Checks
@ -60,7 +60,7 @@ LightManager::LightManager(systems::ResourceManager *resourceManager, systems::C
, m_CommitManager{commitManager}
, m_DirectionalLightCount{}
, m_PointLightCount{}
, m_MetaInfo{.m_LightBuffer = systems::ResId<Buffer>::Null() }
, m_MetaInfo{.m_LightBuffer = systems::NullId()}
, m_GpuBufferCapacity_{0}
{
}
@ -210,7 +210,8 @@ LightManager::Update()
const u16 requiredBufferCapacity = eastl::min(Cast<u16>(m_Lights.capacity()), MAX_LIGHTS);
if ((m_GpuBufferCapacity_ & CAPACITY_MASK) < requiredBufferCapacity)
{
auto newBuffer = m_ResourceManager->Buffers().CreateStorageBuffer(requiredBufferCapacity * sizeof m_Lights[0], "Light Buffer");
auto newBuffer = m_ResourceManager->Buffers().CreateStorageBuffer(requiredBufferCapacity * sizeof m_Lights[0],
"Light Buffer");
m_GpuBufferCapacity_ = requiredBufferCapacity | UPDATE_REQUIRED_BIT;
m_MetaInfo.m_LightBuffer = m_CommitManager->CommitBuffer(newBuffer);

6
samples/03_model_render/light_manager.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: light_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -8,8 +8,8 @@
#include "aster/aster.h"
// TODO: Separate files so you only import handles.
#include "aster/systems/resource.h"
#include "aster/core/buffer.h"
#include "aster/systems/resource.h"
#include <EASTL/vector.h>
@ -48,6 +48,7 @@ struct Light
vec3 um_Position;
vec3 um_Direction;
};
f32 m_Range; // < 0.0 for invalid
u32 m_Color_; // LSB is used for flags. (R G B Flags)
f32 m_Intensity;
@ -67,6 +68,7 @@ struct Light
struct LightManager
{
constexpr static u16 MAX_LIGHTS = MaxValue<u16>;
struct LightMetaInfo
{
// The number of directional lights is relatively low (1 - 2) and will almost never change in a scene.

37
samples/03_model_render/model_render.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: model_render.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "aster/aster.h"
@ -57,7 +57,7 @@ struct Camera
struct CameraController
{
constexpr static vec3 UP = vec3(0.0f, 1.0f, 0.0f);
constexpr static auto UP = vec3(0.0f, 1.0f, 0.0f);
f32 m_Fov;
f32 m_Pitch;
@ -98,7 +98,7 @@ struct CameraController
m_Camera.m_Position = vec4(position, 1.0f);
f32 cosPitch = cos(m_Pitch);
const vec3 target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
const auto target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
m_Camera.m_View = lookAt(position, position + target, UP);
m_Camera.CalculateInverses();
@ -111,7 +111,7 @@ struct CameraController
m_Yaw = yaw;
f32 cosPitch = cos(m_Pitch);
const vec3 target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
const auto target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
const vec3 position = m_Camera.m_Position;
m_Camera.m_View = lookAt(position, position + target, UP);
@ -179,11 +179,12 @@ main(int, char **)
Swapchain swapchain = {&surface, &device, window.GetSize(), "Primary Chain"};
systems::ResourceManager resourceManager = {&device, 1000, 1000, 10, 1000};
systems::CommitManager commitManager = {&device, 1000, 1000, 1000, resourceManager.Samplers().CreateSampler({.m_Name = "Default Sampler"})};
systems::CommitManager commitManager = {&device, 1000, 1000, 1000,
resourceManager.Samplers().CreateSampler({.m_Name = "Default Sampler"})};
AssetLoader assetLoader = {&resourceManager, &commitManager, graphicsQueue, queueAllocation.m_Family,
queueAllocation.m_Family};
LightManager lightManager = LightManager{&resourceManager, &commitManager};
auto lightManager = LightManager{&resourceManager, &commitManager};
Model model = assetLoader.LoadModelToGpu(MODEL_FILE);
auto environmentHdri = assetLoader.LoadHdrImage(BACKDROP_FILE);
@ -191,7 +192,7 @@ main(int, char **)
auto environment = CreateCubeFromHdrEnv(&assetLoader, graphicsQueue, 512, envHdriHandle, "Cube Env");
vk::Format attachmentFormat = vk::Format::eR8G8B8A8Srgb;
auto attachmentFormat = vk::Format::eR8G8B8A8Srgb;
Pipeline pipeline = CreatePipeline(&device, attachmentFormat, &commitManager);
Pipeline backGroundPipeline = CreateBackgroundPipeline(&device, attachmentFormat, &commitManager);
@ -238,7 +239,7 @@ main(int, char **)
usize lightingSize = sizeof environment + sizeof lightManager.m_MetaInfo;
uboSize += ClosestMultiple(lightingSize, physicalDeviceOffsetAlignment);
u8 *data = new u8[uboSize];
auto data = new u8[uboSize];
memcpy(data, &cameraController.m_Camera, cameraSize);
memcpy(data + lightOffset, &environment, sizeof environment);
memcpy(data + lightOffset + sizeof environment, &lightManager.m_MetaInfo, sizeof lightManager.m_MetaInfo);
@ -351,15 +352,15 @@ main(int, char **)
};
vk::ImageMemoryBarrier2 transferDstToGuiRenderBarrier = {
.srcStageMask = vk::PipelineStageFlagBits2::eTransfer,
.srcAccessMask = vk::AccessFlagBits2::eTransferWrite | vk::AccessFlagBits2::eTransferRead,
.dstStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
.dstAccessMask = vk::AccessFlagBits2::eColorAttachmentRead,
.oldLayout = vk::ImageLayout::eTransferDstOptimal,
.newLayout = vk::ImageLayout::eColorAttachmentOptimal,
.srcQueueFamilyIndex = vk::QueueFamilyIgnored,
.dstQueueFamilyIndex = vk::QueueFamilyIgnored,
.subresourceRange = subresourceRange,
.srcStageMask = vk::PipelineStageFlagBits2::eTransfer,
.srcAccessMask = vk::AccessFlagBits2::eTransferWrite | vk::AccessFlagBits2::eTransferRead,
.dstStageMask = vk::PipelineStageFlagBits2::eColorAttachmentOutput,
.dstAccessMask = vk::AccessFlagBits2::eColorAttachmentRead,
.oldLayout = vk::ImageLayout::eTransferDstOptimal,
.newLayout = vk::ImageLayout::eColorAttachmentOptimal,
.srcQueueFamilyIndex = vk::QueueFamilyIgnored,
.dstQueueFamilyIndex = vk::QueueFamilyIgnored,
.subresourceRange = subresourceRange,
};
vk::DependencyInfo preGuiDependencies = {
.imageMemoryBarrierCount = 1,
@ -709,4 +710,4 @@ main(int, char **)
device.m_Device.destroy(descriptorPool, nullptr);
return 0;
}
}

2
samples/03_model_render/nodes.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: nodes.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "nodes.h"

14
samples/03_model_render/nodes.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: nodes.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -41,16 +41,16 @@ struct Nodes
constexpr static u32 DIRTY_BIT = 1u << 30;
constexpr static u32 PARENT_MASK = ~(ROOT_BIT | DIRTY_BIT);
u32 Add(const mat4 &transform, const i32 parent = -1);
[[nodiscard]] const mat4 &Get(const u32 index) const;
void Set(const u32 index, const mat4 &transform);
u32 Add(const mat4 &transform, i32 parent = -1);
[[nodiscard]] const mat4 &Get(u32 index) const;
void Set(u32 index, const mat4 &transform);
[[nodiscard]] u32 Count() const;
[[nodiscard]] const mat4 &operator[](const u32 index) const;
[[nodiscard]] mat4 &operator[](const u32 index);
[[nodiscard]] const mat4 &operator[](u32 index) const;
[[nodiscard]] mat4 &operator[](u32 index);
[[nodiscard]] usize GetGlobalTransformByteSize() const;
[[nodiscard]] const Transform *GetGlobalTransformPtr() const;
bool Update();
};
};

4
samples/03_model_render/pipeline_utils.cpp
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: pipeline_utils.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#include "pipeline_utils.h"
@ -350,4 +350,4 @@ CreateShader(const Device *device, cstr shaderFile)
AbortIfFailedMV(device->m_Device.createShaderModule(&shaderModuleCreateInfo, nullptr, &shaderModule),
"Shader {} could not be created.", shaderFile);
return shaderModule;
}
}

7
samples/03_model_render/pipeline_utils.h
View File

@ -1,6 +1,6 @@
// =============================================
// Aster: pipeline_utils.h
// Copyright (c) 2020-2024 Anish Bhobe
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#pragma once
@ -24,6 +24,7 @@ constexpr auto BACKGROUND_VERTEX_SHADER_FILE = "shader/background.vs.hlsl.spv";
constexpr auto BACKGROUND_FRAGMENT_SHADER_FILE = "shader/background.ps.hlsl.spv";
vk::ShaderModule CreateShader(const Device *device, cstr shaderFile);
Pipeline CreatePipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
Pipeline
CreateBackgroundPipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
CreatePipeline(const Device *device, vk::Format attachmentFormat, const systems::CommitManager *resourceManager);
Pipeline CreateBackgroundPipeline(const Device *device, vk::Format attachmentFormat,
const systems::CommitManager *resourceManager);

5
samples/03_model_render/tiny_gltf_setup.cpp
View File

@ -1,4 +1,7 @@
// =============================================
// Aster: tiny_gltf_setup.cpp
// Copyright (c) 2020-2025 Anish Bhobe
// =============================================
#define TINYGLTF_NOEXCEPTION
#define JSON_NOEXCEPTION