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

2
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

3
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

2
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

2
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

15
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)

10
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>

4
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>>;

36
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>>;

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

2
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

2
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

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

2
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

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

2
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

2
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

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)
{

4
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>

6
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)
{

2
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

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();

9
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,7 +101,7 @@ 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);

4
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>

4
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}

16
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"
@ -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

2
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"

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)

55
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,12 +105,12 @@ 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>");
@ -176,10 +176,10 @@ Image::DestroyView(const vk::ImageView imageView) const
// m_LayerCount = 6;
//
// 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,
@ -220,7 +220,8 @@ Image::DestroyView(const vk::ImageView imageView) const
// },
// };
// result = device->m_Device.createImageView(&imageViewCreateInfo, nullptr, &view);
// ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result) THEN_ABORT(result);
// ERROR_IF(Failed(result), "Could not create attachment image view {}. Cause: {}", name, result)
// THEN_ABORT(result);
//
// m_Device = device;
// m_Image = image;
@ -231,10 +232,10 @@ Image::DestroyView(const vk::ImageView imageView) const
// m_LayerCount = 1;
//
// 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 = {
@ -287,20 +288,22 @@ Image::DestroyView(const vk::ImageView imageView) const
// m_LayerCount = 1;
//
// device->SetName(m_Image, name);
//}
// }
//
//void
//StorageTexture::Init(const Device *device, vk::Extent2D extent, const vk::Format imageFormat, const bool isSampled,
// 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;
// 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)",
// 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;
// }
@ -355,17 +358,19 @@ Image::DestroyView(const vk::ImageView imageView) const
// m_LayerCount = 1;
//
// device->SetName(m_Image, name);
//}
// }
//
//void
//StorageTextureCube::Init(const Device *device, u32 cubeSide, vk::Format imageFormat, bool isSampled, bool isMipMapped,
// 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;
// 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,
@ -426,4 +431,4 @@ Image::DestroyView(const vk::ImageView imageView) const
// m_LayerCount = 6;
//
// device->SetName(m_Image, name);
//}
// }

2
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"

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)

4
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;

4
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}

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 {

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;

4
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 */

2
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"

4
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();

2
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"

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"

2
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

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"

13
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,8 +214,7 @@ 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({
auto crate = resourceManager.CombinedImageViews().CreateTexture2D({
.m_Format = vk::Format::eR8G8B8A8Srgb,
.m_Extent = {imageFile.m_Width, imageFile.m_Height},
.m_Name = "Crate Texture",

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());

23
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
{
@ -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.

17
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);

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"

12
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,13 +41,13 @@ 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;

2
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"

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