aster/CMakeLists.txt

@@ -20,7 +20,7 @@ set(HEADER_FILES
         physical_device.h
         device.h
         swapchain.h
-        pipeline.h
+        "pipeline.h"
         queue_allocation.h
         buffer.h)
 

aster/device.cpp

@@ -19,13 +19,6 @@ constexpr eastl::array DEVICE_EXTENSIONS = {
 
 Device::Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
                const eastl::vector<QueueAllocation> &queueAllocations, NameString &&name)
-    : Device(context, physicalDevice, enabledFeatures, queueAllocations, {}, std::move(name))
-{
-}
-
-Device::Device(const Context *context, PhysicalDevice *physicalDevice, Features *enabledFeatures,
-               const eastl::vector<QueueAllocation> &queueAllocations, eastl::span<u8> &&pipelineCacheData,
-               NameString &&name)
     : m_Name(std::move(name))
     , m_PhysicalDevice(physicalDevice->m_PhysicalDevice)
 {
@@ -93,22 +86,11 @@ Device::Device(const Context *context, PhysicalDevice *physicalDevice, Features
     THEN_ABORT(result)
     ELSE_VERBOSE("Memory Allocator Created");
 
-    vk::PipelineCacheCreateInfo pipelineCacheCreateInfo = {
-        .initialDataSize = pipelineCacheData.size_bytes(),
-        .pInitialData = pipelineCacheData.data(),
-    };
-    result = m_Device.createPipelineCache(&pipelineCacheCreateInfo, nullptr, &m_PipelineCache);
-    ERROR_IF(Failed(result), "Pipeline Cache creation failed. Cause: {}", result)
-    DO(m_Device.destroy(nullptr))
-    THEN_ABORT(result)
-    ELSE_VERBOSE("Pipeline Cache created.");
-
-    DEBUG("Created Device '{}' Successfully", m_Name);
+    DEBUG("Created '{}' Successfully", m_Name);
 }
 
 Device::~Device()
 {
-    m_Device.destroy(m_PipelineCache, nullptr);
     if (m_Allocator)
     {
         vmaDestroyAllocator(m_Allocator);
@@ -128,19 +110,6 @@ Device::GetQueue(const u32 familyIndex, const u32 queueIndex) const
     return queue;
 }
 
-eastl::vector<u8>
-Device::DumpPipelineCache() const
-{
-    usize pipelineCacheSize = 0;
-    vk::Result result = m_Device.getPipelineCacheData(m_PipelineCache, &pipelineCacheSize, nullptr);
-    ERROR_IF(Failed(result), "Pipeline Cache data fetch failed. Cause: {}", result);
-    eastl::vector<u8> pipelineCacheData(pipelineCacheSize);
-    result = m_Device.getPipelineCacheData(m_PipelineCache, &pipelineCacheSize, pipelineCacheData.data());
-    ERROR_IF(Failed(result), "Pipeline Cache data fetch failed. Cause: {}", result);
-
-    return pipelineCacheData;
-}
-
 Device::Device(Device &&other) noexcept
     : m_Name(std::move(other.m_Name))
     , m_PhysicalDevice(Take(other.m_PhysicalDevice))

aster/device.h

@@ -8,7 +8,6 @@
 #include "global.h"
 
 #include <EASTL/vector.h>
-#include <EASTL/span.h>
 
 struct QueueAllocation;
 struct Context;
@@ -28,19 +27,14 @@ struct Device final
     vk::PhysicalDevice m_PhysicalDevice = nullptr;
     vk::Device m_Device = nullptr;
     VmaAllocator m_Allocator = nullptr;
-    vk::PipelineCache m_PipelineCache = nullptr;
 
     template <typename T>
     requires vk::isVulkanHandleType<T>::value void SetName(const T &object, cstr name) const;
     [[nodiscard]] vk::Queue GetQueue(u32 familyIndex, u32 queueIndex) const;
 
-    [[nodiscard]] eastl::vector<u8> DumpPipelineCache() const;
-
     // Ctor/Dtor
     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);
     ~Device();
 
     // Move

aster/image.h

@@ -41,7 +41,7 @@ struct Image
     vk::Extent3D m_Extent;
     // Image.m_MipLevels_ is used for bookkeeping
     // If the image is Invalid, the remaining data in Image is used intrusively by `GpuResourceManager`.
-    u32 m_MipLevels_ = 0;
+    u32 m_MipLevels_;
 
     [[nodiscard]] bool IsValid() const;
     [[nodiscard]] bool IsOwned() const;

samples/00_util/gpu_resource_manager.cpp

@@ -36,7 +36,7 @@ TextureManager::Commit(Texture *texture)
 
         // Ensure it is copyable.
         static_assert(std::is_trivially_copyable_v<Texture>);
-        *allocatedTexture = *texture;
+        memcpy(allocatedTexture, texture, sizeof *texture);
 
         // Take ownership of the buffer.
         texture->m_MipLevels_ &= ~Texture::OWNED_BIT;
@@ -51,7 +51,7 @@ TextureManager::Commit(Texture *texture)
 
         // Ensure it is copyable.
         static_assert(std::is_trivially_copyable_v<Texture>);
-        *allocatedTexture = *texture;
+        memcpy(allocatedTexture, texture, sizeof *texture);
 
         texture->m_MipLevels_ &= ~Texture::OWNED_BIT;
 
@@ -115,7 +115,7 @@ BufferManager::Commit(StorageBuffer *buffer)
 
         // Ensure it is copyable.
         static_assert(std::is_trivially_copyable_v<StorageBuffer>);
-        *allocatedBuffer = *buffer;
+        memcpy(allocatedBuffer, buffer, sizeof *buffer);
 
         // Take ownership of the buffer.
         buffer->m_Size_ &= ~StorageBuffer::OWNED_BIT;
@@ -130,7 +130,7 @@ BufferManager::Commit(StorageBuffer *buffer)
 
         // Ensure it is copyable.
         static_assert(std::is_trivially_copyable_v<StorageBuffer>);
-        *allocatedBuffer = *buffer;
+        memcpy(allocatedBuffer, buffer, sizeof *buffer);
 
         buffer->m_Size_ &= ~StorageBuffer::OWNED_BIT;
 
@@ -294,7 +294,7 @@ GpuResourceManager::Commit(Texture *texture)
         .pImageInfo = &m_WriteInfos.back().uImageInfo,
     });
 
-    m_WriteOwner.emplace_back(HandleType::eTexture, handle.m_Index);
+    m_WriteOwner.emplace_back(HandleType::eBuffer, handle.m_Index);
 
 #if !defined(NDEBUG)
     ++m_CommitedTextureCount;
@@ -428,7 +428,6 @@ GpuResourceManager::~GpuResourceManager()
 #endif
 
     m_BufferManager.Destroy(m_Device);
-    m_TextureManager.Destroy(m_Device);
     m_Device->m_Device.destroy(m_ImmutableSampler, nullptr);
     m_Device->m_Device.destroy(m_DescriptorPool, nullptr);
     m_Device->m_Device.destroy(m_SetLayout, nullptr);

samples/00_util/helpers.cpp

@@ -84,54 +84,7 @@ ReadFile(cstr fileName)
         outputVec.resize(nextSize);
         memcpy(outputVec.data() + totalRead, buffer.data(), readCount * sizeof *buffer.data());
         totalRead = nextSize;
-    } while (readCount == buffer.size());
+    } while (readCount == 1024);
 
     return outputVec;
-}
-
-eastl::vector<u8>
-ReadFileBytes(cstr fileName, bool errorOnFail)
-{
-    FILE *filePtr = fopen(fileName, "rb");
-
-    if (!filePtr)
-    {
-        ERROR_IF(errorOnFail, "Invalid open (r) of {}. Cause: {}", fileName, errno);
-        return {};
-    }
-
-    eastl::vector<u8> outputVec;
-    eastl::array<u8, 4096> buffer{};
-    usize totalRead = 0;
-    usize readCount;
-    do
-    {
-        readCount = fread(buffer.data(), sizeof(u8), buffer.size(), filePtr);
-        const auto nextSize = totalRead + readCount;
-        outputVec.resize(nextSize);
-        memcpy(outputVec.data() + totalRead, buffer.data(), readCount * sizeof *buffer.data());
-        totalRead = nextSize;
-    } while (readCount == buffer.size());
-
-    (void)fclose(filePtr);
-
-    return outputVec;
-}
-
-bool
-WriteFileBytes(cstr fileName, eastl::span<u8> data)
-{
-    FILE *filePtr = fopen(fileName, "wb");
-
-    if (!filePtr)
-    {
-        ERROR("Invalid open (w) of {}. Cause: {}", fileName, errno);
-        return false;
-    }
-
-    const usize written = fwrite(data.data(), sizeof(u8), data.size(), filePtr);
-
-    (void)fclose(filePtr);
-
-    return written == data.size();
 }

samples/00_util/helpers.h

@@ -8,8 +8,6 @@
 #include "global.h"
 
 #include "queue_allocation.h"
-
-#include "EASTL/span.h"
 #include <EASTL/vector.h>
 #include <glm/gtc/matrix_transform.hpp>
 
@@ -19,8 +17,6 @@ class PhysicalDevices;
 PhysicalDevice FindSuitableDevice(const PhysicalDevices &physicalDevices);
 QueueAllocation FindAppropriateQueueAllocation(const PhysicalDevice *physicalDevice);
 eastl::vector<u32> ReadFile(cstr fileName);
-eastl::vector<u8> ReadFileBytes(cstr fileName, bool errorOnFail = true);
-bool WriteFileBytes(cstr fileName, eastl::span<u8> data);
 
 #define AbortIfFailed(RESULT)                                                                                          \
     do                                                                                                                 \

samples/03_model_render/image/.gitattributes

@@ -1,2 +0,0 @@
-*.hdr filter=lfs diff=lfs merge=lfs -text
-*.exr filter=lfs diff=lfs merge=lfs -text

samples/03_model_render/light_manager.cpp

@@ -115,7 +115,7 @@ LightManager::operator=(LightManager &&other) noexcept
 }
 
 LightHandle
-LightManager::AddDirectional(const vec3 &direction, const vec3 &color, f32 intensity)
+LightManager::AddDirectional(const vec3 &direction, const vec3 &color)
 {
     const vec3 normDirection = normalize(direction);
     if (m_DirectionalLightCount < m_MetaInfo.m_DirectionalLightMaxCount)
@@ -130,7 +130,6 @@ LightManager::AddDirectional(const vec3 &direction, const vec3 &color, f32 inten
                 light.m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_DIRECTIONAL | gen;
                 light.m_Range = 1.0f;
                 light.um_Direction = normDirection;
-                light.m_Intensity = intensity;
 
                 m_GpuBufferCapacity_ |= UPDATE_REQUIRED_BIT;
 
@@ -154,14 +153,10 @@ LightManager::AddDirectional(const vec3 &direction, const vec3 &color, f32 inten
         if (m_MetaInfo.m_PointLightMaxCount > 0) // Edge Case: nullptr at size 0
         {
             Light *oldPointStart = m_Lights.data() + oldPointLightOffset;
-            Light *oldPointEnd = oldPointStart + pointLightMaxCount;
-            Light *newPointEnd = oldPointEnd + 2;
+            Light *newPointStart = oldPointStart + 2;
 
             static_assert(std::is_trivially_copyable_v<Light>);
-
-            // Overlaps since 0 -> 2, 1 -> 3, 2 -> 4 (old 2 is lost)
-            // Backward copy fixes this.
-            std::copy_backward(oldPointStart, oldPointEnd, newPointEnd);
+            memcpy(newPointStart, oldPointStart, pointLightMaxCount * sizeof *newPointStart);
         }
 
         m_MetaInfo.m_PointLightOffset += 2;
@@ -171,7 +166,6 @@ LightManager::AddDirectional(const vec3 &direction, const vec3 &color, f32 inten
     m_Lights[m_DirectionalLightCount].m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_DIRECTIONAL | gen;
     m_Lights[m_DirectionalLightCount].m_Range = 1.0f;
     m_Lights[m_DirectionalLightCount].um_Direction = normDirection;
-    m_Lights[m_DirectionalLightCount].m_Intensity = intensity;
     const u16 index = m_DirectionalLightCount;
 
     ++m_DirectionalLightCount;
@@ -181,7 +175,7 @@ LightManager::AddDirectional(const vec3 &direction, const vec3 &color, f32 inten
 }
 
 LightHandle
-LightManager::AddPoint(const vec3 &position, const vec3 &color, const f32 radius, f32 intensity)
+LightManager::AddPoint(const vec3 &position, const vec3 &color, const f32 radius)
 {
     assert(m_PointLightCount <= m_MetaInfo.m_PointLightMaxCount);
     assert(radius >= 0.0f);
@@ -197,7 +191,6 @@ LightManager::AddPoint(const vec3 &position, const vec3 &color, const f32 radius
                 light->m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_POINT | gen;
                 light->m_Range = radius;
                 light->um_Position = position;
-                light->m_Intensity = intensity;
 
                 m_GpuBufferCapacity_ |= UPDATE_REQUIRED_BIT;
 
@@ -218,7 +211,6 @@ LightManager::AddPoint(const vec3 &position, const vec3 &color, const f32 radius
     light->m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_POINT | gen;
     light->m_Range = radius;
     light->um_Position = position;
-    light->m_Intensity = intensity;
 
     ++m_PointLightCount;
     ++m_MetaInfo.m_PointLightMaxCount;

samples/03_model_render/light_manager.h

@@ -68,8 +68,8 @@ struct LightManager
     constexpr static u16 UPDATE_REQUIRED_BIT = 1;
     constexpr static u16 CAPACITY_MASK = ~(UPDATE_REQUIRED_BIT);
 
-    LightHandle AddDirectional(const vec3 &direction, const vec3 &color, f32 intensity);
-    LightHandle AddPoint(const vec3 &position, const vec3 &color, f32 radius, f32 intensity);
+    LightHandle AddDirectional(const vec3 &direction, const vec3 &color);
+    LightHandle AddPoint(const vec3 &position, const vec3 &color, f32 radius);
     void Update();
     void RemoveLight(LightHandle handle);
 

samples/03_model_render/model/MarbleBust/marble_bust_01_4k.gltf

@@ -1,161 +0,0 @@
-{
-  "asset": {
-    "generator": "Khronos glTF Blender I/O v1.6.16",
-    "version": "2.0"
-  },
-  "scene": 0,
-  "scenes": [
-    {
-      "name": "Scene",
-      "nodes": [
-        0
-      ]
-    }
-  ],
-  "nodes": [
-    {
-      "mesh": 0,
-      "name": "marble_bust_01",
-      "translation": [
-        0,
-        0.028335653245449066,
-        0
-      ]
-    }
-  ],
-  "materials": [
-    {
-      "doubleSided": true,
-      "name": "marble_bust_01",
-      "normalTexture": {
-        "index": 0
-      },
-      "pbrMetallicRoughness": {
-        "baseColorTexture": {
-          "index": 1
-        },
-        "metallicFactor": 0,
-        "metallicRoughnessTexture": {
-          "index": 2
-        }
-      }
-    }
-  ],
-  "meshes": [
-    {
-      "name": "marble_bust_01",
-      "primitives": [
-        {
-          "attributes": {
-            "POSITION": 0,
-            "NORMAL": 1,
-            "TEXCOORD_0": 2
-          },
-          "indices": 3,
-          "material": 0
-        }
-      ]
-    }
-  ],
-  "textures": [
-    {
-      "sampler": 0,
-      "source": 0
-    },
-    {
-      "sampler": 0,
-      "source": 1
-    },
-    {
-      "sampler": 0,
-      "source": 2
-    }
-  ],
-  "images": [
-    {
-      "mimeType": "image/jpeg",
-      "name": "marble_bust_01_nor_gl",
-      "uri": "textures/marble_bust_01_nor_gl_4k.jpg"
-    },
-    {
-      "mimeType": "image/jpeg",
-      "name": "marble_bust_01_diff",
-      "uri": "textures/marble_bust_01_diff_4k.jpg"
-    },
-    {
-      "mimeType": "image/jpeg",
-      "name": "marble_bust_01_arm",
-      "uri": "textures/marble_bust_01_rough_4k.jpg"
-    }
-  ],
-  "accessors": [
-    {
-      "bufferView": 0,
-      "componentType": 5126,
-      "count": 9746,
-      "max": [
-        0.14886942505836487,
-        0.48668384552001953,
-        0.1551172435283661
-      ],
-      "min": [
-        -0.12288019061088562,
-        -0.028259359300136566,
-        -0.1445964276790619
-      ],
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 1,
-      "componentType": 5126,
-      "count": 9746,
-      "type": "VEC3"
-    },
-    {
-      "bufferView": 2,
-      "componentType": 5126,
-      "count": 9746,
-      "type": "VEC2"
-    },
-    {
-      "bufferView": 3,
-      "componentType": 5123,
-      "count": 52368,
-      "type": "SCALAR"
-    }
-  ],
-  "bufferViews": [
-    {
-      "buffer": 0,
-      "byteLength": 116952,
-      "byteOffset": 0
-    },
-    {
-      "buffer": 0,
-      "byteLength": 116952,
-      "byteOffset": 116952
-    },
-    {
-      "buffer": 0,
-      "byteLength": 77968,
-      "byteOffset": 233904
-    },
-    {
-      "buffer": 0,
-      "byteLength": 104736,
-      "byteOffset": 311872
-    }
-  ],
-  "samplers": [
-    {
-      "magFilter": 9729,
-      "minFilter": 9987
-    }
-  ],
-  "buffers": [
-    {
-      "byteLength": 416608,
-      "uri": "marble_bust_01.bin"
-    }
-  ]
-}

samples/03_model_render/model_loader.cpp

@@ -22,12 +22,6 @@
 #include <EASTL/hash_map.h>
 #include <glm/gtc/type_ptr.hpp>
 
-#include <tiny_gltf.h>
-
-#if defined(LoadImage)
-#undef LoadImage
-#endif
-
 vec4
 VectorToVec4(const std::vector<double> &vec)
 {

samples/03_model_render/model_loader.h

@@ -11,10 +11,7 @@
 #include "gpu_resource_manager.h"
 #include "nodes.h"
 
-namespace tinygltf
-{
-struct Image;
-}
+#include <tiny_gltf.h>
 
 struct TextureHandle;
 struct Texture;

samples/03_model_render/model_render.cpp

@@ -29,67 +29,14 @@
 #include <filesystem>
 
 constexpr u32 MAX_FRAMES_IN_FLIGHT = 3;
-constexpr auto PIPELINE_CACHE_FILE = "PipelineCacheData.bin";
+constexpr auto MODEL_FILE = "model/DamagedHelmet.glb";
 
 struct Camera
 {
     mat4 m_View;
     mat4 m_Perspective;
-    vec4 m_Position;
-};
-
-struct CameraController
-{
-    constexpr static vec3 UP = vec3(0.0f, 1.0f, 0.0f);
-
-    f32 m_Fov;
-    f32 m_Pitch;
-    f32 m_Yaw;
+    vec3 m_Position;
     f32 m_AspectRatio;
-
-    Camera m_Camera;
-
-    CameraController(const vec3 &position, const vec3 &target, const f32 vFov, const f32 aspectRatio)
-        : m_Fov(vFov)
-        , m_Pitch{0.0f}
-        , m_Yaw{0.0f}
-        , m_AspectRatio{aspectRatio}
-        , m_Camera{
-              .m_View = lookAt(position, target, UP),
-              .m_Perspective = glm::perspective(vFov, aspectRatio, 0.1f, 100.0f),
-              .m_Position = vec4{0.0f, 2.0f, 2.0f, 1.0f},
-          }
-    {
-    }
-
-    void
-    SetAspectRatio(const f32 aspectRatio)
-    {
-        m_AspectRatio = aspectRatio;
-        m_Camera.m_Perspective = glm::perspective(m_Fov, aspectRatio, 0.1f, 100.0f);
-    }
-
-    void
-    SetPosition(const vec3 &position)
-    {
-        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);
-        m_Camera.m_View = lookAt(position, position + target, UP);
-    }
-
-    void
-    SetPitchYaw(f32 pitch, f32 yaw)
-    {
-        m_Pitch = pitch;
-        m_Yaw = yaw;
-
-        f32 cosPitch = cos(m_Pitch);
-        const vec3 target = vec3(sin(m_Yaw) * cosPitch, sin(m_Pitch), -cos(m_Yaw) * cosPitch);
-        const vec3 position = vec3{m_Camera.m_Position};
-        m_Camera.m_View = lookAt(position, position + target, UP);
-    }
 };
 
 int
@@ -127,10 +74,8 @@ main(int, char **)
             },
     };
 
-    auto pipelineCacheData = ReadFileBytes(PIPELINE_CACHE_FILE, false);
-
     QueueAllocation queueAllocation = FindAppropriateQueueAllocation(&deviceToUse);
-    Device device = {&context, &deviceToUse, &enabledDeviceFeatures, {queueAllocation}, pipelineCacheData, "Primary Device"};
+    Device device = {&context, &deviceToUse, &enabledDeviceFeatures, {queueAllocation}, "Primary Device"};
     vk::Queue commandQueue = device.GetQueue(queueAllocation.m_Family, 0);
     Swapchain swapchain = {&window, &device, "Primary Chain"};
     GpuResourceManager resourceManager = {&device, 1000};
@@ -143,14 +88,9 @@ main(int, char **)
     vk::Format attachmentFormat = vk::Format::eR8G8B8A8Srgb;
     Pipeline pipeline = CreatePipeline(&device, attachmentFormat, &resourceManager);
 
-    //lightManager.AddDirectional(vec3(0.0f, -1.0f, 0.0f), {0.0f, 0.7f, 0.0f});
-    //lightManager.AddPoint(vec3{2.0f, 1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}, 15.0f);
-    //lightManager.AddPoint(vec3{-2.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, 15.0f);
-
-    lightManager.AddPoint(vec3{-5.0f, -5.0f, 5.0f}, vec3{1.0f}, 30.0f, 16.0f);
-    lightManager.AddPoint(vec3{5.0f, -5.0f, 5.0f}, vec3{1.0f}, 30.0f, 16.0f);
-    lightManager.AddPoint(vec3{-5.0f, 5.0f, 5.0f}, vec3{1.0f}, 30.0f, 16.0f);
-    lightManager.AddPoint(vec3{5.0f, 5.0f, 5.0f}, vec3{1.0f}, 30.0f, 16.0f);
+    lightManager.AddDirectional(vec3(0.0f, -1.0f, 0.0f), {0.0f, 0.7f, 0.0f});
+    lightManager.AddPoint(vec3{2.0f, 1.0f, 0.0f}, {1.0f, 0.0f, 0.0f}, 15.0f);
+    lightManager.AddPoint(vec3{-2.0f, 1.0f, 0.0f}, {0.0f, 0.0f, 1.0f}, 15.0f);
 
     lightManager.Update();
 
@@ -179,12 +119,17 @@ main(int, char **)
 
     vk::Extent2D internalResolution = {1920, 1080};
 
-    CameraController cameraController = {vec3{0.0f, 2.0f, 2.0f}, vec3{0.0f}, 70_deg,
-                                         Cast<f32>(swapchain.m_Extent.width) / Cast<f32>(swapchain.m_Extent.height)};
+    Camera camera = {
+        .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),
+        .m_Position = vec4{0.0f, 2.0f, 2.0f, 1.0f},
+        .m_AspectRatio = Cast<f32>(swapchain.m_Extent.width) / Cast<f32>(swapchain.m_Extent.height),
+    };
 
     UniformBuffer ubo;
-    ubo.Init(&device, sizeof cameraController.m_Camera, "Camera UBO");
-    ubo.Write(&device, 0, sizeof cameraController.m_Camera, &cameraController.m_Camera);
+    ubo.Init(&device, sizeof camera, "Camera UBO");
+    ubo.Write(&device, 0, sizeof camera, &camera);
     vk::DescriptorBufferInfo descriptorBufferInfo = {
         .buffer = ubo.m_Buffer,
         .offset = 0,
@@ -330,12 +275,11 @@ main(int, char **)
     bool rotating = false;
     bool lockToScreen = true;
     i32 height = Cast<i32>(internalResolution.height);
-    vec2 camPitchYaw = vec2(0.0f);
-    vec3 camPosition = cameraController.m_Camera.m_Position;
     vk::Extent2D inputResolution = internalResolution;
 
-    swapchain.RegisterResizeCallback([&cameraController](vk::Extent2D extent) {
-        cameraController.SetAspectRatio(Cast<f32>(extent.width) / Cast<f32>(extent.height));
+    swapchain.RegisterResizeCallback([&camera](vk::Extent2D extent) {
+        camera.m_AspectRatio = Cast<f32>(extent.width) / Cast<f32>(extent.height);
+        camera.m_Perspective = glm::perspective(70_deg, camera.m_AspectRatio, 0.1f, 100.0f);
     });
 
     Time::Init();
@@ -359,7 +303,7 @@ main(int, char **)
             }
 
             inputResolution.height = height;
-            inputResolution.width = Cast<i32>(cameraController.m_AspectRatio * Cast<f32>(inputResolution.height));
+            inputResolution.width = Cast<i32>(camera.m_AspectRatio * Cast<f32>(inputResolution.height));
 
             if (gui::Button("Change Resolution"))
             {
@@ -389,15 +333,6 @@ main(int, char **)
         gui::Separator();
         gui::Text("Delta: %0.6f ms", 1000.0f * Time::m_Delta);
         gui::Text("FPS: %0.6f", 1.0f / Time::m_Delta);
-        gui::Separator();
-        if (gui::DragFloat2("Camera Orientation", Recast<f32 *>(&camPitchYaw)))
-        {
-            cameraController.SetPitchYaw(glm::radians(camPitchYaw.x), glm::radians(camPitchYaw.y));
-        }
-        if (gui::InputFloat3("Camera Position", Recast<f32 *>(&camPosition)))
-        {
-            cameraController.SetPosition(camPosition);
-        }
         gui::Checkbox("Rotate", &rotating);
         if (gui::Button("Exit"))
         {
@@ -413,7 +348,7 @@ main(int, char **)
                 rotate(model.GetModelTransform(), Cast<f32>(45.0_deg * Time::m_Delta), vec3(0.0f, 1.0f, 0.0f)));
         }
         model.Update();
-        ubo.Write(&device, 0, sizeof cameraController.m_Camera, &cameraController.m_Camera);
+        ubo.Write(&device, 0, sizeof camera, &camera);
 
         Frame *currentFrame = frameManager.GetNextFrame(&swapchain, &window);
 
@@ -570,9 +505,6 @@ main(int, char **)
 
     AbortIfFailed(device.m_Device.waitIdle());
 
-    pipelineCacheData = device.DumpPipelineCache();
-    ERROR_IF(!WriteFileBytes(PIPELINE_CACHE_FILE, pipelineCacheData), "Pipeline Cache incorrectly written");
-
     gui::Destroy(&device);
 
     for (auto &depthImage : depthImages)

samples/03_model_render/shader/model.ps.hlsl

@@ -110,7 +110,7 @@ float3 GetPBRContrib(float3 Albedo, float3 LightColor, float3 ViewDir, float3 No
     float NdotL = max(dot(Normal, LightDir), 0.0f);
         
     float3 Radiance = LightColor * Attenuation;
-    
+        
     float NormalDistribution = TrowbridgeReitzGGX(Normal, Halfway, Roughness);
     float Geometry = GeometrySmith(NdotV, NdotL, Roughness);
     float3 Fresnel = FresnelSchlick(CosineFactor, F_0);
@@ -167,7 +167,7 @@ float3 GetPointLightInfluence(float3 Albedo, float2 MetalRough, float3 Position,
         float G = (Light.Color & 0x00FF0000) >> 16;
         float B = (Light.Color & 0x0000FF00) >> 8;
         
-        float3 LightColor = LightAmp * Light.Intensity * float3(R, G, B) * 0.00392156862f; // 0.00392156862 = 1/255
+        float3 LightColor = LightAmp * float3(R, G, B) * 0.00392156862f; // 0.00392156862 = 1/255
  
         Contrib += GetPBRContrib(Albedo, LightColor, ViewDir, Normal, Metallic, Roughness, F_0, LightDir, LightDistance);
     }
@@ -209,7 +209,7 @@ float3 GetDirectionalLightInfluence(float3 Albedo, float2 MetalRough, float3 Pos
         float G = (Light.Color & 0x00FF0000) >> 16;
         float B = (Light.Color & 0x0000FF00) >> 8;
         
-        float3 LightColor = LightAmp * Light.Intensity * float3(R, G, B) * 0.00392156862f; // 0.00392156862 = 1/255
+        float3 LightColor = LightAmp * float3(R, G, B) * 0.00392156862f; // 0.00392156862 = 1/255
  
         Contrib += GetPBRContrib(Albedo, LightColor, ViewDir, Normal, Metallic, Roughness, F_0, LightDir, 1.0f);
     }