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

Basic light support.

This commit is contained in:
Anish Bhobe 2024-07-22 23:11:55 +02:00
parent 641ad3ea77
commit b902d08ece
11 changed files with 649 additions and 171 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
samples/03_model_render/CMakeLists.txt
View File

@ -12,7 +12,11 @@ add_executable(model_render model_render.cpp
render_resource_manager.h
model_loader.cpp
model_loader.h
)
light_manager.cpp
light_manager.h
nodes.cpp
nodes.h)
add_shader(model_render shader/model.vs.hlsl)
add_shader(model_render shader/model.ps.hlsl)

276
samples/03_model_render/light_manager.cpp Normal file
View File

@ -0,0 +1,276 @@
// =============================================
// Aster: light_manager.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// =============================================
#include "light_manager.h"
#include "glm/ext/matrix_transform.hpp"
struct Light
{
union {
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;
constexpr static u32 MAX_GEN = 0x40;
constexpr static u32 GEN_MASK = MAX_GEN - 1;
constexpr static u32 TYPE_MASK = 0xC0;
constexpr static u32 TYPE_INVALID = 0x0;
constexpr static u32 TYPE_DIRECTIONAL = 1 << 6;
constexpr static u32 TYPE_POINT = 2 << 6;
constexpr static u32 TYPE_SPOT = 3 << 6; // Currently Unused
constexpr static u32 COLOR_MASK = ~(GEN_MASK | TYPE_MASK);
};
// Static Checks
// Ensure layouts are exact.
static_assert(offsetof(DirectionalLight, m_Direction) == offsetof(Light, um_Direction));
static_assert(offsetof(DirectionalLight, m_Color_) == offsetof(Light, m_Color_));
static_assert(offsetof(DirectionalLight, m_Intensity) == offsetof(Light, m_Intensity));
static_assert(sizeof(DirectionalLight) <= sizeof(Light));
// Ensure layouts are exact.
static_assert(offsetof(PointLight, m_Position) == offsetof(Light, um_Position));
static_assert(offsetof(PointLight, m_Range) == offsetof(Light, m_Range));
static_assert(offsetof(PointLight, m_Color_) == offsetof(Light, m_Color_));
static_assert(offsetof(PointLight, m_Intensity) == offsetof(Light, m_Intensity));
static_assert(sizeof(PointLight) <= sizeof(Light));
// Ensure bitmask are in the right place.
static_assert((Light::TYPE_MASK & Light::TYPE_INVALID) == Light::TYPE_INVALID);
static_assert((Light::TYPE_MASK & Light::TYPE_DIRECTIONAL) == Light::TYPE_DIRECTIONAL);
static_assert((Light::TYPE_MASK & Light::TYPE_POINT) == Light::TYPE_POINT);
static_assert((Light::TYPE_MASK & Light::TYPE_SPOT) == Light::TYPE_SPOT);
static_assert(Light::COLOR_MASK == 0xFFFFFF00);
inline u32
ToColor32(const vec4 &col)
{
const u32 r = Cast<u32>(eastl::min(col.r, 1.0f) * 255.99f);
const u32 g = Cast<u32>(eastl::min(col.g, 1.0f) * 255.99f);
const u32 b = Cast<u32>(eastl::min(col.b, 1.0f) * 255.99f);
const u32 a = Cast<u32>(eastl::min(col.a, 1.0f) * 255.99f);
return r << 24 | g << 16 | b << 8 | a;
}
inline u32
ToColor32(const vec3 &col)
{
const u32 r = Cast<u32>(eastl::min(col.r, 1.0f) * 255.99f);
const u32 g = Cast<u32>(eastl::min(col.g, 1.0f) * 255.99f);
const u32 b = Cast<u32>(eastl::min(col.b, 1.0f) * 255.99f);
constexpr u32 a = 255;
return r << 24 | g << 16 | b << 8 | a;
}
LightManager::LightManager(GpuResourceManager *resourceManager)
: m_ResourceManager{resourceManager}
, m_DirectionalLightCount{}
, m_PointLightCount{}
, m_MetaInfo{}
, m_GpuBufferCapacity_{0}
{
}
LightManager::~LightManager()
{
m_ResourceManager->Release(m_MetaInfo.m_LightBuffer);
}
LightManager::LightManager(LightManager &&other) noexcept
: m_ResourceManager(other.m_ResourceManager)
, m_Lights(std::move(other.m_Lights))
, m_DirectionalLightCount(other.m_DirectionalLightCount)
, m_PointLightCount(other.m_PointLightCount)
, m_MetaInfo(other.m_MetaInfo)
, m_GpuBufferCapacity_(other.m_GpuBufferCapacity_)
{
other.m_MetaInfo.m_LightBuffer = {};
}
LightManager &
LightManager::operator=(LightManager &&other) noexcept
{
if (this == &other)
return *this;
m_ResourceManager = other.m_ResourceManager;
m_Lights = std::move(other.m_Lights);
m_DirectionalLightCount = other.m_DirectionalLightCount;
m_PointLightCount = other.m_PointLightCount;
m_MetaInfo = other.m_MetaInfo;
other.m_MetaInfo.m_LightBuffer = {};
m_GpuBufferCapacity_ = other.m_GpuBufferCapacity_;
return *this;
}
LightHandle
LightManager::AddDirectional(const vec3 &direction, const vec3 &color)
{
const vec3 normDirection = normalize(direction);
if (m_DirectionalLightCount < m_MetaInfo.m_DirectionalLightMaxCount)
{
u16 index = 0;
for (auto &light : m_Lights)
{
if (light.m_Range < 0)
{
const u8 gen = light.m_Color_ & Light::GEN_MASK;
light.m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_DIRECTIONAL | gen;
light.m_Range = 1.0f;
light.um_Direction = normDirection;
m_GpuBufferCapacity_ |= UPDATE_REQUIRED_BIT;
return {Light::TYPE_DIRECTIONAL, gen, index};
}
++index;
assert(index < m_MetaInfo.m_DirectionalLightMaxCount); // Gap not found. But must exist
}
}
// In case we will end up intersecting, we move point lights away. (2 at a time)
if (m_DirectionalLightCount == m_MetaInfo.m_DirectionalLightMaxCount &&
m_MetaInfo.m_DirectionalLightMaxCount == m_MetaInfo.m_PointLightOffset)
{
const u16 oldPointLightOffset = m_MetaInfo.m_PointLightOffset;
const u32 pointLightMaxCount = m_MetaInfo.m_PointLightMaxCount;
// Might cause a capacity increase, but I want to use that for my gpu buffer resize.
m_Lights.push_back();
m_Lights.push_back();
if (m_MetaInfo.m_PointLightMaxCount > 0) // Edge Case: nullptr at size 0
{
Light *oldPointStart = m_Lights.data() + oldPointLightOffset;
Light *newPointStart = oldPointStart + 2;
static_assert(std::is_trivially_copyable_v<Light>);
memcpy(newPointStart, oldPointStart, pointLightMaxCount * sizeof *newPointStart);
}
m_MetaInfo.m_PointLightOffset += 2;
}
constexpr u8 gen = 0; // New light
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;
const u16 index = m_DirectionalLightCount;
++m_DirectionalLightCount;
++m_MetaInfo.m_DirectionalLightMaxCount;
return {Light::TYPE_DIRECTIONAL, gen, index};
}
LightHandle
LightManager::AddPoint(const vec3 & position, const vec3 &color, const f32 radius)
{
assert(m_PointLightCount <= m_MetaInfo.m_PointLightMaxCount);
assert(radius >= 0.0f);
if (m_PointLightCount < m_MetaInfo.m_PointLightMaxCount)
{
Light *light = m_Lights.data() + m_MetaInfo.m_PointLightOffset;
for (u32 index = 0; index < m_MetaInfo.m_PointLightMaxCount; ++index)
{
if (light->m_Range < 0)
{
const u8 gen = light->m_Color_ & Light::GEN_MASK;
light->m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_POINT | gen;
light->m_Range = radius;
light->um_Position = position;
m_GpuBufferCapacity_ |= UPDATE_REQUIRED_BIT;
return {Light::TYPE_POINT, gen, Cast<u16>(index)};
}
++light;
}
assert(false); // gap must exists.
return {};
}
m_Lights.push_back();
const u16 index = m_PointLightCount;
Light *light = &m_Lights[index + m_MetaInfo.m_PointLightOffset];
constexpr u8 gen = 0; // New light
light->m_Color_ = (ToColor32(color) & Light::COLOR_MASK) | Light::TYPE_POINT | gen;
light->m_Range = radius;
light->um_Position = position;
++m_PointLightCount;
++m_MetaInfo.m_PointLightMaxCount;
m_GpuBufferCapacity_ |= UPDATE_REQUIRED_BIT;
return {Light::TYPE_POINT, gen, index};
}
void
LightManager::Update()
{
const u16 requiredBufferCapacity = eastl::min(Cast<u16>(m_Lights.capacity()), MAX_LIGHTS);
if ((m_GpuBufferCapacity_ & CAPACITY_MASK) < requiredBufferCapacity)
{
StorageBuffer newBuffer;
newBuffer.Init(m_ResourceManager->m_Device, requiredBufferCapacity * sizeof m_Lights[0], true, "Light Buffer");
m_GpuBufferCapacity_ = requiredBufferCapacity | UPDATE_REQUIRED_BIT;
m_ResourceManager->Release(m_MetaInfo.m_LightBuffer);
m_MetaInfo.m_LightBuffer = m_ResourceManager->Commit(&newBuffer);
}
if (m_GpuBufferCapacity_ & UPDATE_REQUIRED_BIT)
{
m_ResourceManager->Write(m_MetaInfo.m_LightBuffer, 0, m_Lights.size() * sizeof m_Lights[0], m_Lights.data());
}
}
void
LightManager::RemoveLight(const LightHandle handle)
{
const u8 handleGen = handle.m_Generation;
if (handle.m_Type == Light::TYPE_DIRECTIONAL)
{
Light *lightSlot = &m_Lights[handle.m_Index];
const u8 slotGen = lightSlot->m_Color_ & Light::GEN_MASK;
if (slotGen > handleGen)
{
WARN("Invalid handle gen: {} being freed. (slot gen: {})", handleGen, slotGen);
return;
}
lightSlot->m_Range = -1.0f;
lightSlot->m_Color_ = Light::TYPE_INVALID | (slotGen + 1) % Light::MAX_GEN;
--m_DirectionalLightCount;
}
if (handle.m_Type == Light::TYPE_POINT)
{
Light *lightSlot = &m_Lights[handle.m_Index + m_MetaInfo.m_PointLightOffset];
const u8 slotGen = lightSlot->m_Color_ & Light::GEN_MASK;
if (slotGen > handleGen)
{
WARN("Invalid handle gen: {} being freed. (slot gen: {})", handleGen, slotGen);
return;
}
lightSlot->m_Range = -1.0f;
lightSlot->m_Color_ = Light::TYPE_INVALID | (slotGen + 1) % Light::MAX_GEN;
--m_PointLightCount;
}
}

84
samples/03_model_render/light_manager.h Normal file
View File

@ -0,0 +1,84 @@
// =============================================
// Aster: light_manager.h
// Copyright (c) 2020-2024 Anish Bhobe
// =============================================
#pragma once
#include "global.h"
// TODO: Separate files so you only import handles.
#include "render_resource_manager.h"
struct DirectionalLight
{
vec3 m_Direction;
u32 m_UnusedPadding0_;
u32 m_Color_; // LSB is used for flags. (R G B Flags)
f32 m_Intensity;
};
struct PointLight
{
vec3 m_Position;
f32 m_Range;
u32 m_Color_; // LSB is used for flags. (R G B Flags)
f32 m_Intensity;
};
struct LightHandle
{
u8 m_Type;
u8 m_Generation;
u16 m_Index;
};
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.
// We can use that with Offset = 0, and point light at further offsets.
// This way we don't need to move point lights often.
BufferHandle m_LightBuffer; // 04 04
u16 m_PointLightMaxCount; // 02 06
u16 m_PointLightOffset; // 02 08
u16 m_DirectionalLightMaxCount; // 02 10
u16 m_UnusedPadding0 = 0; // 02 12
};
GpuResourceManager *m_ResourceManager;
eastl::vector<Light> m_Lights;
// We don't need a Directional Light free list. We will just brute force iterate.
u16 m_DirectionalLightCount;
// TODO: A point light free list. We will brute force until we have a lot (100+) of point lights.
u16 m_PointLightCount;
LightMetaInfo m_MetaInfo;
// Using lower bit for flags. Use CAPACITY_MASK for value.
u16 m_GpuBufferCapacity_;
// Using lower bit. Capacity can be directly a multiple of 2
// Thus, range is up to MaxValue<u16>
constexpr static u16 UPDATE_REQUIRED_BIT = 1;
constexpr static u16 CAPACITY_MASK = ~(UPDATE_REQUIRED_BIT);
LightHandle AddDirectional(const vec3 &direction, const vec3 &color);
LightHandle AddPoint(const vec3& position, const vec3 &color, f32 radius);
void Update();
void RemoveLight(LightHandle handle);
explicit LightManager(GpuResourceManager *resourceManager);
~LightManager();
LightManager(LightManager &&other) noexcept;
LightManager &operator=(LightManager &&other) noexcept;
DISALLOW_COPY_AND_ASSIGN(LightManager);
};

109
samples/03_model_render/model_loader.cpp
View File

@ -673,115 +673,6 @@ Model::operator=(Model &&other) noexcept
return *this;
}
u32
Nodes::Add(const mat4 &transform, const i32 parent)
{
m_Dirty = true;
const u32 index = Count();
m_Transforms.push_back(transform);
m_GlobalTransforms.emplace_back(transform);
const u32 parentVal = (parent < 0 ? ROOT_BIT : parent & PARENT_MASK) | DIRTY_BIT;
m_Parents_.push_back(parentVal);
return index;
}
const mat4 &
Nodes::Get(const u32 index) const
{
return m_Transforms[index];
}
void
Nodes::Set(const u32 index, const mat4 &transform)
{
m_Dirty = true;
m_Transforms[index] = transform;
m_Parents_[index] |= DIRTY_BIT;
}
const mat4 &
Nodes::operator[](const u32 index) const
{
return m_Transforms[index];
}
mat4 &
Nodes::operator[](const u32 index)
{
m_Dirty = true;
m_Parents_[index] |= DIRTY_BIT;
return m_Transforms[index];
}
u32
Nodes::Count() const
{
return Cast<u32>(m_Transforms.size());
}
usize
Nodes::GetGlobalTransformByteSize() const
{
return m_GlobalTransforms.size() * sizeof m_GlobalTransforms[0];
}
const Nodes::Transform *
Nodes::GetGlobalTransformPtr() const
{
return m_GlobalTransforms.data();
}
bool
Nodes::Update()
{
if (!m_Dirty)
return false;
auto transformIter = m_Transforms.begin();
auto globalTransformIter = m_GlobalTransforms.begin();
auto parentIter = m_Parents_.begin();
const auto parentEnd = m_Parents_.end();
while (parentIter != parentEnd)
{
const bool isRoot = *parentIter & ROOT_BIT;
const bool isDirty = *parentIter & DIRTY_BIT;
if (isRoot)
{
if (isDirty)
{
// Copy-update if the root is dirty.
*globalTransformIter = *transformIter;
}
}
else
{
const u32 parentIdx = *parentIter & PARENT_MASK;
const bool isParentDirty = m_Parents_[parentIdx] & DIRTY_BIT;
if (isDirty || isParentDirty)
{
// Update w.r.t parent if either local or parent transforms updated.
*globalTransformIter = m_GlobalTransforms[parentIdx].m_GlobalTransforms * *transformIter;
m_Parents_[parentIdx] |= DIRTY_BIT; // Set dirty to propagate the update.
}
}
++parentIter;
++globalTransformIter;
++transformIter;
}
for (u32 &parentValue : m_Parents_)
{
parentValue &= ~DIRTY_BIT; // Unset dirty.
}
m_Dirty = false;
return true;
}
const mat4 &
Model::GetModelTransform() const
{

47
samples/03_model_render/model_loader.h
View File

@ -9,6 +9,7 @@
#include "global.h"
#include "render_resource_manager.h"
#include "nodes.h"
#include <tiny_gltf.h>
@ -27,52 +28,6 @@ struct MeshPrimitive
i32 m_TransformIdx;
};
struct Nodes
{
struct Transform
{
mat4 m_GlobalTransforms;
mat4 m_NormalTransforms;
explicit Transform(const mat4& transform)
: m_GlobalTransforms(transform)
, m_NormalTransforms(transpose(inverse(mat3{transform})))
{
}
Transform &
operator=(const mat4& transform)
{
m_GlobalTransforms = transform;
m_NormalTransforms = transpose(inverse(mat3{transform}));
return *this;
}
};
eastl::vector<mat4> m_Transforms;
eastl::vector<Transform> m_GlobalTransforms;
/// Parents are also used for bookkeeping
eastl::vector<u32> m_Parents_;
bool m_Dirty = true;
constexpr static u32 ROOT_BIT = 1u << 31;
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);
[[nodiscard]] u32 Count() const;
[[nodiscard]] const mat4 &operator[](const u32 index) const;
[[nodiscard]] mat4 &operator[](const u32 index);
[[nodiscard]] usize GetGlobalTransformByteSize() const;
[[nodiscard]] const Transform *GetGlobalTransformPtr() const;
bool Update();
};
struct Material
{
vec4 m_AlbedoFactor; // 16 16

25
samples/03_model_render/model_render.cpp
View File

@ -16,6 +16,7 @@
#include "frame.h"
#include "helpers.h"
#include "light_manager.h"
#include "model_loader.h"
#include "pipeline_utils.h"
@ -73,8 +74,9 @@ main(int, char **)
GpuResourceManager resourceManager = {&device, 1000};
ModelLoader modelLoader = {&resourceManager, commandQueue, queueAllocation.m_Family, queueAllocation.m_Family};
LightManager lightManager = LightManager{&resourceManager};
auto model = modelLoader.LoadModel(MODEL_FILE);
Model model = modelLoader.LoadModel(MODEL_FILE);
Pipeline pipeline = CreatePipeline(&device, &swapchain, &resourceManager);
@ -84,6 +86,12 @@ main(int, char **)
70_deg, Cast<f32>(swapchain.m_Extent.width) / Cast<f32>(swapchain.m_Extent.height), 0.1f, 100.0f),
};
lightManager.AddDirectional(vec3(0.0f, -1.0f, 0.0f), {0.0f, 1.0f, 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();
vk::DescriptorPool descriptorPool;
vk::DescriptorSet descriptorSet;
@ -264,16 +272,23 @@ main(int, char **)
cmd.bindDescriptorSets(vk::PipelineBindPoint::eGraphics, pipeline.m_Layout, 1, 1, &descriptorSet, 0, nullptr);
cmd.bindIndexBuffer(model.m_IndexBuffer.m_Buffer, 0, vk::IndexType::eUint32);
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, 0, sizeof model.m_Handles,
u32 pcbOffset = 0;
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, pcbOffset, sizeof model.m_Handles,
&model.m_Handles);
pcbOffset += sizeof model.m_Handles;
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, pcbOffset, sizeof lightManager.m_MetaInfo,
&lightManager.m_MetaInfo);
pcbOffset += sizeof lightManager.m_MetaInfo;
for (auto &prim : model.m_MeshPrimitives)
{
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, sizeof model.m_Handles,
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, pcbOffset,
sizeof prim.m_MaterialIdx, &prim.m_MaterialIdx);
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll,
sizeof model.m_Handles + sizeof prim.m_MaterialIdx,
pcbOffset += sizeof prim.m_MaterialIdx;
cmd.pushConstants(pipeline.m_Layout, vk::ShaderStageFlagBits::eAll, pcbOffset,
sizeof prim.m_TransformIdx, &prim.m_TransformIdx);
pcbOffset += sizeof prim.m_TransformIdx;
cmd.drawIndexed(prim.m_IndexCount, 1, prim.m_FirstIndex, Cast<i32>(prim.m_VertexOffset), 0);
}

115
samples/03_model_render/nodes.cpp Normal file
View File

@ -0,0 +1,115 @@
// =============================================
// Aster: nodes.cpp
// Copyright (c) 2020-2024 Anish Bhobe
// =============================================
#include "nodes.h"
u32
Nodes::Add(const mat4 &transform, const i32 parent)
{
m_Dirty = true;
const u32 index = Count();
m_Transforms.push_back(transform);
m_GlobalTransforms.emplace_back(transform);
const u32 parentVal = (parent < 0 ? ROOT_BIT : parent & PARENT_MASK) | DIRTY_BIT;
m_Parents_.push_back(parentVal);
return index;
}
const mat4 &
Nodes::Get(const u32 index) const
{
return m_Transforms[index];
}
void
Nodes::Set(const u32 index, const mat4 &transform)
{
m_Dirty = true;
m_Transforms[index] = transform;
m_Parents_[index] |= DIRTY_BIT;
}
const mat4 &
Nodes::operator[](const u32 index) const
{
return m_Transforms[index];
}
mat4 &
Nodes::operator[](const u32 index)
{
m_Dirty = true;
m_Parents_[index] |= DIRTY_BIT;
return m_Transforms[index];
}
u32
Nodes::Count() const
{
return Cast<u32>(m_Transforms.size());
}
usize
Nodes::GetGlobalTransformByteSize() const
{
return m_GlobalTransforms.size() * sizeof m_GlobalTransforms[0];
}
const Nodes::Transform *
Nodes::GetGlobalTransformPtr() const
{
return m_GlobalTransforms.data();
}
bool
Nodes::Update()
{
if (!m_Dirty)
return false;
auto transformIter = m_Transforms.begin();
auto globalTransformIter = m_GlobalTransforms.begin();
auto parentIter = m_Parents_.begin();
const auto parentEnd = m_Parents_.end();
while (parentIter != parentEnd)
{
const bool isRoot = *parentIter & ROOT_BIT;
const bool isDirty = *parentIter & DIRTY_BIT;
if (isRoot)
{
if (isDirty)
{
// Copy-update if the root is dirty.
*globalTransformIter = *transformIter;
}
}
else
{
const u32 parentIdx = *parentIter & PARENT_MASK;
const bool isParentDirty = m_Parents_[parentIdx] & DIRTY_BIT;
if (isDirty || isParentDirty)
{
// Update w.r.t parent if either local or parent transforms updated.
*globalTransformIter = m_GlobalTransforms[parentIdx].m_GlobalTransforms * *transformIter;
m_Parents_[parentIdx] |= DIRTY_BIT; // Set dirty to propagate the update.
}
}
++parentIter;
++globalTransformIter;
++transformIter;
}
for (u32 &parentValue : m_Parents_)
{
parentValue &= ~DIRTY_BIT; // Unset dirty.
}
m_Dirty = false;
return true;
}

56
samples/03_model_render/nodes.h Normal file
View File

@ -0,0 +1,56 @@
// =============================================
// Aster: nodes.h
// Copyright (c) 2020-2024 Anish Bhobe
// =============================================
#pragma once
#include "global.h"
#include "EASTL/vector.h"
struct Nodes
{
struct Transform
{
mat4 m_GlobalTransforms;
mat4 m_NormalTransforms;
explicit Transform(const mat4 &transform)
: m_GlobalTransforms(transform)
, m_NormalTransforms(transpose(inverse(mat3{transform})))
{
}
Transform &
operator=(const mat4 &transform)
{
m_GlobalTransforms = transform;
m_NormalTransforms = transpose(inverse(mat3{transform}));
return *this;
}
};
eastl::vector<mat4> m_Transforms;
eastl::vector<Transform> m_GlobalTransforms;
/// Parents are also used for bookkeeping
eastl::vector<u32> m_Parents_;
bool m_Dirty = true;
constexpr static u32 ROOT_BIT = 1u << 31;
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);
[[nodiscard]] u32 Count() const;
[[nodiscard]] const mat4 &operator[](const u32 index) const;
[[nodiscard]] mat4 &operator[](const u32 index);
[[nodiscard]] usize GetGlobalTransformByteSize() const;
[[nodiscard]] const Transform *GetGlobalTransformPtr() const;
bool Update();
};

2
samples/03_model_render/pipeline_utils.cpp
View File

@ -58,7 +58,7 @@ CreatePipeline(const Device *device, const Swapchain *swapchain, const GpuResour
vk::PushConstantRange pushConstantRange = {
.stageFlags = vk::ShaderStageFlagBits::eAll,
.offset = 0,
.size = 24,
.size = 36,
};
vk::PipelineLayoutCreateInfo pipelineLayoutCreateInfo = {

16
samples/03_model_render/shader/bindless_structs.hlsli
View File

@ -32,22 +32,38 @@ struct Block
uint vertexDataHandle;
uint materialBufferHandle;
uint nodeBufferHandle;
uint lightHandle;
uint pointLightIndexer;
uint directionLightIndexer;
int m_MaterialIdx;
uint m_NodeIdx;
};
struct Light
{
float m_Position[3];
float m_Range;
uint m_Color;
float m_Intensity;
};
struct Camera
{
float4x4 view;
float4x4 proj;
};
// Little Endian storage. First short is least significant.
#define IndexerCount(Indexer) (Indexer & 0xFFFF)
#define IndexerOffset(Indexer) ((Indexer & 0xFFFF0000) >> 16);
#define INVALID_HANDLE 0xFFFFFFFF
[[vk::binding(0, 0)]] StructuredBuffer<float4> vertexBuffer[];
[[vk::binding(0, 0)]] StructuredBuffer<VertexData> vertexDataBuffer[];
[[vk::binding(0, 0)]] StructuredBuffer<MaterialData> materialsBuffer[];
[[vk::binding(0, 0)]] StructuredBuffer<TransformData> nodeBuffer[];
[[vk::binding(0, 0)]] StructuredBuffer<Light> lightBuffer[];
[[vk::binding(1, 0)]] Texture2D<float4> textures[];
[[vk::binding(1, 0)]] SamplerState immutableSamplers[];

84
samples/03_model_render/shader/model.ps.hlsl
View File

@ -26,23 +26,89 @@ float4 GetAlbedo(uint materialBufferId, int materialId, float2 uv)
}
}
FS_Output main(FS_Input stage_input)
float3 GetDirectionalLightInfluence(float3 normal)
{
if (pcb.lightHandle == INVALID_HANDLE)
return float3(0.0f, 0.0f, 0.0f);
uint count = IndexerCount(pcb.directionLightIndexer);
float3 contrib = 0.0f;
for (uint i = 0; i < count; ++i)
{
Light light = lightBuffer[pcb.lightHandle][i];
float3 lightDir = - (float3) light.m_Position; // Position is actually direction for directionalLight; LightDir is Direction towards the light (-direction)
float diff = max(dot(normal, lightDir), 0.0f);
int ur = (light.m_Color & 0xFF000000) >> 24;
int ug = (light.m_Color & 0x00FF0000) >> 16;
int ub = (light.m_Color & 0x0000FF00) >> 8;
float r = ur;
float g = ug;
float b = ub;
float3 color = float3(r, g, b) * 0.00392156862f; // 0.00392156862 = 1/255
float3 diffuse = diff * color;
contrib += (light.m_Range < 0 ? float3(0.0f, 0.0f, 0.0f) : diffuse);
}
return contrib;
}
float3 GetPointLightInfluence(float3 position, float3 normal)
{
if (pcb.lightHandle == INVALID_HANDLE)
return float3(0.0f, 0.0f, 0.0f);
uint offset = IndexerOffset(pcb.pointLightIndexer);
uint count = IndexerCount(pcb.pointLightIndexer);
float3 contrib = 0.0f;
for (uint i = 0; i < count; ++i)
{
Light light = lightBuffer[pcb.lightHandle][i + offset];
float3 lightDir = normalize(((float3)light.m_Position) - position);
float diff = max(dot(normal, lightDir), 0.0f);
int ur = (light.m_Color & 0xFF000000) >> 24;
int ug = (light.m_Color & 0x00FF0000) >> 16;
int ub = (light.m_Color & 0x0000FF00) >> 8;
float r = ur;
float g = ug;
float b = ub;
float3 color = float3(r, g, b) * 0.00392156862f; // 0.00392156862 = 1/255
float3 diffuse = diff * color;
contrib += (light.m_Range < 0 ? float3(0.0f, 0.0f, 0.0f) : diffuse);
}
return contrib;
}
FS_Output
main(FS_Input stage_input)
{
// Hereby assume that we always have a point light at
float3 lightPos = float3(6.0f, 6.0f, 6.0f);
// with
float3 lightColor = float3(0.7f, 0.7f, 0.7f); //float3(0.7f, 0.4f, 0.1f);
// and
//// Hereby assume that we always have a point light at
//float3 lightPos = float3(6.0f, 6.0f, 6.0f);
//// with
//float3 lightColor = float3(0.7f, 0.7f, 0.7f); //float3(0.7f, 0.4f, 0.1f);
//// and
float3 ambient = float3(0.02f, 0.02f, 0.02f);
float3 norm = normalize(stage_input.inNormal.xyz);
float3 lightDir = normalize(lightPos - stage_input.inPosition.xyz);
float diff = max(dot(norm, lightDir), 0.0f);
float3 diffuse = diff * lightColor;
float3 pos = stage_input.inPosition.xyz;
float4 objColor = pcb.m_MaterialIdx < 0 ? stage_input.inColor : GetAlbedo(pcb.materialBufferHandle, pcb.m_MaterialIdx, stage_input.inUV);
float3 diffuse = GetDirectionalLightInfluence(norm) + GetPointLightInfluence(pos, norm);
FS_Output output;
output.outColor = float4(objColor.rgb * (diffuse + ambient), objColor.a);
return output;