780 lines
26 KiB
C++
780 lines
26 KiB
C++
#include <Orange/Core/Array.h>
|
|
#include <Orange/Core/Vector.h>
|
|
#include "Orange/Core/Span.h"
|
|
#include <Orange/Core/Result.h>
|
|
#include <Orange/Core/FileSystem.h>
|
|
#include <Orange/Math/Vector.h>
|
|
#include <Orange/Math/Matrix.h>
|
|
#include <Orange/Math/Transformation.h>
|
|
#include <Orange/Core/Parse.h>
|
|
#include <Orange/Core/Variant.h>
|
|
#include <Orange/Core/Time.h>
|
|
|
|
#include <Orange/Render/Window.h>
|
|
#include <Orange/Render/RenderContext.h>
|
|
#include <Orange/Render/Swapchain.h>
|
|
#include <Orange/Render/VulkanHelpers.h>
|
|
|
|
#include <Orange/Graphics/Camera.h>
|
|
|
|
#include <vs_Mesh.h>
|
|
#include <fs_DebugVertColor.h>
|
|
|
|
using namespace orange;
|
|
|
|
struct AABB
|
|
{
|
|
vec3 min;
|
|
vec3 max;
|
|
|
|
void Extend(vec3 pos)
|
|
{
|
|
min = Min(pos, min);
|
|
max = Max(pos, max);
|
|
}
|
|
};
|
|
|
|
enum class MeshVertexType
|
|
{
|
|
Static,
|
|
Skinned,
|
|
};
|
|
|
|
#ifndef offsetof2
|
|
#define offsetof2(type, member) size_t(uintptr_t(&((type*)0)->member))
|
|
#endif
|
|
|
|
struct StaticVertex
|
|
{
|
|
vec3 pos;
|
|
vec2 uv;
|
|
vec3 normal;
|
|
//vec3 tangent;
|
|
|
|
static constexpr VkVertexInputAttributeDescription Attributes[] =
|
|
{
|
|
{ .location = 0, .binding = 0, .format = VK_FORMAT_R32G32B32_SFLOAT, .offset = uint32_t(offsetof2(StaticVertex, pos)) },
|
|
{ .location = 1, .binding = 0, .format = VK_FORMAT_R32G32_SFLOAT, .offset = uint32_t(offsetof2(StaticVertex, uv)) },
|
|
{ .location = 2, .binding = 0, .format = VK_FORMAT_R32G32B32_SFLOAT, .offset = uint32_t(offsetof2(StaticVertex, normal)) },
|
|
};
|
|
|
|
bool operator == (const StaticVertex& other) const
|
|
{
|
|
return pos == other.pos &&
|
|
uv == other.uv &&
|
|
normal == other.normal;// &&
|
|
//tangent == other.tangent;
|
|
}
|
|
};
|
|
|
|
struct SkinnedVertex : public StaticVertex
|
|
{
|
|
static constexpr uint32_t MaxVertexWeights = 4;
|
|
|
|
bool operator == (const SkinnedVertex& other) const
|
|
{
|
|
return pos == other.pos &&
|
|
uv == other.uv &&
|
|
normal == other.normal &&
|
|
//tangent == other.tangent &&
|
|
boneIndices == other.boneIndices &&
|
|
boneWeights == other.boneWeights;
|
|
}
|
|
|
|
Array<uint8_t, MaxVertexWeights> boneIndices;
|
|
Array<uint8_t, MaxVertexWeights> boneWeights;
|
|
};
|
|
|
|
struct MeshVertexData
|
|
{
|
|
MeshVertexData(MeshVertexType type)
|
|
: vertexType(type)
|
|
{
|
|
switch(vertexType)
|
|
{
|
|
case MeshVertexType::Static:
|
|
vertices.Construct<Vector<StaticVertex>>();
|
|
break;
|
|
case MeshVertexType::Skinned:
|
|
vertices.Construct<Vector<SkinnedVertex>>();
|
|
break;
|
|
}
|
|
}
|
|
|
|
Vector<StaticVertex>& GetStaticVertices()
|
|
{
|
|
Assert(vertexType == MeshVertexType::Static);
|
|
return vertices.Get<Vector<StaticVertex>>();
|
|
}
|
|
|
|
Vector<SkinnedVertex>& GetSkinnedVertices()
|
|
{
|
|
Assert(vertexType == MeshVertexType::Skinned);
|
|
return vertices.Get<Vector<SkinnedVertex>>();
|
|
}
|
|
|
|
BufferView View()
|
|
{
|
|
switch(vertexType)
|
|
{
|
|
case MeshVertexType::Static:
|
|
return GetStaticVertices();
|
|
break;
|
|
case MeshVertexType::Skinned:
|
|
return GetSkinnedVertices();
|
|
break;
|
|
default:
|
|
return BufferView{ nullptr, 0 };
|
|
}
|
|
}
|
|
|
|
uint32_t VertexCount() const
|
|
{
|
|
// Type doesn't matter here, just want to grab m_size.
|
|
return uint32_t(vertices.Get<Vector<uint8_t>>().Size());
|
|
}
|
|
|
|
MeshVertexType vertexType;
|
|
Variant<Vector<StaticVertex>, Vector<SkinnedVertex>> vertices;
|
|
};
|
|
|
|
struct MeshData
|
|
{
|
|
MeshData(MeshVertexType type)
|
|
: vertexData{ type } {}
|
|
|
|
MeshVertexData vertexData;
|
|
Vector<uint16_t> indices;
|
|
AABB bounds;
|
|
};
|
|
|
|
Result<MeshData> ParseOBJ(StringView buffer)
|
|
{
|
|
MeshData data{ MeshVertexType::Static };
|
|
|
|
Vector<vec3> positions;
|
|
Vector<vec2> uvs;
|
|
Vector<vec3> normals;
|
|
|
|
const char* obj = buffer.data;
|
|
const char* end = buffer.data + buffer.size;
|
|
while (obj != end)
|
|
{
|
|
SmallVector<char, 8> element;
|
|
stream::ReadString(obj, end, " #\n", element);
|
|
|
|
if (element == "v" || element == "vt" || element == "vn")
|
|
{
|
|
float vtx[3]{};
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
stream::ConsumeSpace(obj, end);
|
|
if (auto r_float = stream::Parse<float>(obj, end))
|
|
vtx[i] = *r_float;
|
|
}
|
|
|
|
if (element == "v")
|
|
positions.EmplaceBack(vtx[0], vtx[1], vtx[2]);
|
|
else if (element == "vt")
|
|
uvs.EmplaceBack(vtx[0], vtx[1]);
|
|
else if (element == "vn")
|
|
normals.EmplaceBack(vtx[0], vtx[1], vtx[2]);
|
|
}
|
|
else if (element == "g" || element == "o")
|
|
{
|
|
stream::ConsumeSpace(obj, end);
|
|
SmallVector<char, 32> name;
|
|
stream::ReadString(obj, end, " #\n", name);
|
|
|
|
name.PushBack('\0');
|
|
if (element == "g")
|
|
log::info("Group name: %s", name.Data());
|
|
else
|
|
log::info("Object name: %s", name.Data());
|
|
}
|
|
else if (element == "f")
|
|
{
|
|
int32_t indices[3][3]{};
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
stream::ConsumeSpace(obj, end);
|
|
|
|
for (int j = 0; j < 3; j++)
|
|
{
|
|
indices[i][j] = -1;
|
|
|
|
if (j == 0 || stream::Consume(obj, end, "/"))
|
|
{
|
|
if (auto r_int = stream::Parse<uint32_t>(obj, end))
|
|
indices[i][j] = *r_int - 1; // OBJ indexing starts at one.
|
|
}
|
|
}
|
|
}
|
|
|
|
for (int i = 0; i < 3; i++)
|
|
{
|
|
StaticVertex vertex =
|
|
{
|
|
.pos = indices[i][0] != -1 ? positions[indices[i][0]] : vec3{},
|
|
.uv = indices[i][1] != -1 ? uvs [indices[i][1]] : vec2{},
|
|
.normal = indices[i][2] != -1 ? normals [indices[i][2]] : vec3{},
|
|
};
|
|
|
|
auto& vertices = data.vertexData.GetStaticVertices();
|
|
|
|
size_t vertexIdx = vertices.FindIdx(vertex);
|
|
if (vertexIdx == vertices.InvalidIdx)
|
|
{
|
|
data.bounds.Extend(vertex.pos);
|
|
vertexIdx = vertices.PushBack(vertex);
|
|
}
|
|
|
|
Assert(vertexIdx < UINT16_MAX);
|
|
data.indices.PushBack(uint16_t(vertexIdx));
|
|
}
|
|
}
|
|
else if (!element.Empty())
|
|
{
|
|
element.PushBack('\0');
|
|
log::info("Unknown element: %s", element.Data());
|
|
}
|
|
|
|
stream::AdvancePast(obj, end, "\n");
|
|
};
|
|
|
|
return Result<MeshData>::Success(data);
|
|
}
|
|
|
|
int main(int argc, char** argv)
|
|
{
|
|
(void)argc; (void)argv;
|
|
|
|
auto r_window = Window::Create();
|
|
if (!r_window)
|
|
return 1;
|
|
|
|
auto r_renderContext = RenderContext::Create("Cube Test");
|
|
if (!r_renderContext)
|
|
return 1;
|
|
|
|
auto r_surface = r_window->CreateSurface(r_renderContext->Instance());
|
|
if (!r_surface)
|
|
return 1;
|
|
|
|
auto r_swapchain = Swapchain::Create(*r_renderContext, *r_surface);
|
|
if (!r_swapchain)
|
|
return 1;
|
|
|
|
auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/chair.obj");
|
|
//auto r_objData = fs::OpenFileIntoTextBuffer("/home/joshua/cube.obj");
|
|
if (!r_objData)
|
|
return 1;
|
|
|
|
auto r_mesh = ParseOBJ(*r_objData);
|
|
|
|
auto r_vs = r_renderContext->CreateShader(vs_Mesh);
|
|
if (!r_vs) return 1;
|
|
auto r_fs = r_renderContext->CreateShader(fs_DebugVertColor);
|
|
if (!r_fs) return 1;
|
|
|
|
//
|
|
|
|
VkSamplerCreateInfo samplerInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
|
|
.magFilter = VK_FILTER_LINEAR,
|
|
.minFilter = VK_FILTER_LINEAR,
|
|
.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR,
|
|
.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
|
|
.mipLodBias = 0.0f,
|
|
.anisotropyEnable = VK_TRUE,
|
|
.maxAnisotropy = 16.0f,
|
|
.minLod = -FLT_MAX,
|
|
.maxLod = FLT_MAX,
|
|
};
|
|
VkSampler sampler = VK_NULL_HANDLE;
|
|
vkCreateSampler(r_renderContext->Device(), &samplerInfo, nullptr, &sampler);
|
|
|
|
constexpr uint32_t MaxBindlessResources = 32768;
|
|
VkDescriptorPoolSize bindlessPoolSizes[] =
|
|
{
|
|
{ VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, MaxBindlessResources }
|
|
};
|
|
|
|
VkDescriptorPoolCreateInfo poolInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO,
|
|
.flags = VK_DESCRIPTOR_POOL_CREATE_UPDATE_AFTER_BIND_BIT,
|
|
.maxSets = MaxBindlessResources * Size(bindlessPoolSizes),
|
|
.poolSizeCount = uint32_t(Size(bindlessPoolSizes)),
|
|
.pPoolSizes = bindlessPoolSizes,
|
|
};
|
|
|
|
VkDescriptorPool descriptorPool = VK_NULL_HANDLE;
|
|
vkCreateDescriptorPool(r_renderContext->Device(), &poolInfo, nullptr, &descriptorPool);
|
|
|
|
VkDescriptorSetLayoutBinding layoutBindings[] =
|
|
{
|
|
{
|
|
.binding = 0,
|
|
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
.descriptorCount = MaxBindlessResources,
|
|
.stageFlags = VK_SHADER_STAGE_ALL,
|
|
},
|
|
{
|
|
.binding = 1,
|
|
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLER,
|
|
.descriptorCount = 1,
|
|
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
.pImmutableSamplers = &sampler,
|
|
},
|
|
{
|
|
.binding = 2,
|
|
.descriptorType = VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE,
|
|
.descriptorCount = MaxBindlessResources,
|
|
.stageFlags = VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
},
|
|
};
|
|
|
|
constexpr VkDescriptorBindingFlags bindingFlags[] =
|
|
{
|
|
0,
|
|
0,
|
|
VK_DESCRIPTOR_BINDING_PARTIALLY_BOUND_BIT_EXT | VK_DESCRIPTOR_BINDING_VARIABLE_DESCRIPTOR_COUNT_BIT_EXT | VK_DESCRIPTOR_BINDING_UPDATE_AFTER_BIND_BIT_EXT,
|
|
};
|
|
|
|
Assert(Size(bindingFlags) == Size(layoutBindings));
|
|
|
|
VkDescriptorSetLayoutBindingFlagsCreateInfo layoutBindingFlagsInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_BINDING_FLAGS_CREATE_INFO_EXT,
|
|
.bindingCount = Size(bindingFlags),
|
|
.pBindingFlags = bindingFlags,
|
|
};
|
|
|
|
VkDescriptorSetLayoutCreateInfo layoutInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO,
|
|
.pNext = &layoutBindingFlagsInfo,
|
|
.flags = VK_DESCRIPTOR_SET_LAYOUT_CREATE_UPDATE_AFTER_BIND_POOL_BIT_EXT,
|
|
.bindingCount = Size(layoutBindings),
|
|
.pBindings = layoutBindings,
|
|
};
|
|
|
|
VkDescriptorSetLayout descriptorSetLayout = VK_NULL_HANDLE;
|
|
vkCreateDescriptorSetLayout(r_renderContext->Device(), &layoutInfo, nullptr, &descriptorSetLayout);
|
|
|
|
VkDescriptorSetVariableDescriptorCountAllocateInfoEXT descriptorCountAllocInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_VARIABLE_DESCRIPTOR_COUNT_ALLOCATE_INFO_EXT,
|
|
.descriptorSetCount = 1,
|
|
.pDescriptorCounts = &MaxBindlessResources,
|
|
};
|
|
|
|
VkDescriptorSetAllocateInfo descriptorSetAllocInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,
|
|
.pNext = &descriptorCountAllocInfo,
|
|
.descriptorPool = descriptorPool,
|
|
.descriptorSetCount = 1,
|
|
.pSetLayouts = &descriptorSetLayout,
|
|
};
|
|
|
|
VkDescriptorSet descriptorSet = VK_NULL_HANDLE;
|
|
vkAllocateDescriptorSets(r_renderContext->Device(), &descriptorSetAllocInfo, &descriptorSet);
|
|
|
|
//
|
|
|
|
VkPipelineShaderStageCreateInfo stages[] =
|
|
{
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
|
|
.stage = VK_SHADER_STAGE_VERTEX_BIT,
|
|
.module = *r_vs,
|
|
.pName = "main",
|
|
},
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,
|
|
.stage = VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
.module = *r_fs,
|
|
.pName = "main",
|
|
},
|
|
};
|
|
|
|
Array<VkDynamicState, 2> dynamicStates =
|
|
{
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
|
VK_DYNAMIC_STATE_SCISSOR,
|
|
};
|
|
|
|
VkPipelineDynamicStateCreateInfo dynamicStateInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO,
|
|
.dynamicStateCount = uint32_t(dynamicStates.Size()),
|
|
.pDynamicStates = dynamicStates.Data(),
|
|
};
|
|
|
|
VkVertexInputBindingDescription inputBindingDescription =
|
|
{
|
|
.binding = 0,
|
|
.stride = sizeof(StaticVertex),
|
|
.inputRate = VK_VERTEX_INPUT_RATE_VERTEX,
|
|
};
|
|
|
|
VkPipelineVertexInputStateCreateInfo vertexInputInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,
|
|
.vertexBindingDescriptionCount = 1u,
|
|
.pVertexBindingDescriptions = &inputBindingDescription,
|
|
.vertexAttributeDescriptionCount = Size(StaticVertex::Attributes),
|
|
.pVertexAttributeDescriptions = StaticVertex::Attributes,
|
|
};
|
|
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,
|
|
.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
|
|
.primitiveRestartEnable = VK_FALSE,
|
|
};
|
|
|
|
VkPipelineViewportStateCreateInfo viewportStateInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,
|
|
.viewportCount = 1,
|
|
.scissorCount = 1,
|
|
};
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterizationInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,
|
|
.cullMode = VK_CULL_MODE_NONE, //VK_CULL_MODE_BACK_BIT,
|
|
.frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE,
|
|
.lineWidth = 1.0f,
|
|
};
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisampleInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,
|
|
.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT,
|
|
};
|
|
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,
|
|
.depthTestEnable = VK_TRUE,
|
|
.depthWriteEnable = VK_TRUE,
|
|
.depthCompareOp = VK_COMPARE_OP_LESS,
|
|
.minDepthBounds = 0.0f,
|
|
.maxDepthBounds = 1.0f,
|
|
};
|
|
|
|
VkPipelineColorBlendAttachmentState attachmentBlendState =
|
|
{
|
|
.colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
|
|
VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT,
|
|
};
|
|
|
|
VkPipelineColorBlendStateCreateInfo colorBlendStateInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,
|
|
.attachmentCount = 1,
|
|
.pAttachments = &attachmentBlendState,
|
|
};
|
|
|
|
VkPipelineLayoutCreateInfo pipelineLayoutInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
|
|
.setLayoutCount = 1,
|
|
.pSetLayouts = &descriptorSetLayout
|
|
};
|
|
VkPipelineLayout pipelineLayout = VK_NULL_HANDLE;
|
|
vkCreatePipelineLayout(r_renderContext->Device(), &pipelineLayoutInfo, nullptr, &pipelineLayout);
|
|
|
|
VkFormat colorFormat = FormatToSrgbFormat(r_swapchain->Format());
|
|
VkFormat depthFormat = *FindDepthFormat(r_renderContext->PhysicalDevice());
|
|
VkPipelineRenderingCreateInfo renderingInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO,
|
|
.viewMask = 0u,
|
|
.colorAttachmentCount = 1u,
|
|
.pColorAttachmentFormats = &colorFormat,
|
|
.depthAttachmentFormat = depthFormat
|
|
};
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,
|
|
.pNext = &renderingInfo,
|
|
.stageCount = Size(stages),
|
|
.pStages = stages,
|
|
.pVertexInputState = &vertexInputInfo,
|
|
.pInputAssemblyState = &inputAssemblyInfo,
|
|
.pViewportState = &viewportStateInfo,
|
|
.pRasterizationState = &rasterizationInfo,
|
|
.pMultisampleState = &multisampleInfo,
|
|
.pDepthStencilState = &depthStencilInfo,
|
|
.pColorBlendState = &colorBlendStateInfo,
|
|
.pDynamicState = &dynamicStateInfo,
|
|
.layout = pipelineLayout,
|
|
};
|
|
|
|
VkPipeline pipeline = VK_NULL_HANDLE;
|
|
if (vkCreateGraphicsPipelines(r_renderContext->Device(), VK_NULL_HANDLE, 1, &pipelineInfo, nullptr, &pipeline) != VK_SUCCESS)
|
|
{
|
|
log::err("Blah");
|
|
return 1;
|
|
}
|
|
|
|
auto r_buffer = r_renderContext->CreateBuffer(256 * 1024 * 1024);
|
|
if (!r_buffer)
|
|
return 1;
|
|
|
|
VkBufferViewCreateInfo bufferViewInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_BUFFER_VIEW_CREATE_INFO,
|
|
.buffer = r_buffer->buffer,
|
|
.format = VK_FORMAT_R8G8B8A8_UNORM,
|
|
.offset = 0,
|
|
.range = r_buffer->size,
|
|
};
|
|
VkBufferView bufferView = VK_NULL_HANDLE;
|
|
vkCreateBufferView(r_renderContext->Device(), &bufferViewInfo, nullptr, &bufferView);
|
|
|
|
struct UniformData
|
|
{
|
|
mat4 projection;
|
|
mat4 view;
|
|
};
|
|
|
|
Camera camera;
|
|
camera.transform.position = vec3{0.0f, 0.0f, 80.0f};
|
|
camera.viewportAspectRatio = 16.0f / 9.0f;
|
|
//camera.offsetOrientation(1_deg * Seconds(t2 - t1).count(), 0_deg);
|
|
//camera.lookAt(vec3{40.0f, 40.0f, 0.0f});
|
|
camera.transform.orientation = eulerAnglesToQuaternion(EulerAngles{ 0_deg, 0_deg, 0_deg });
|
|
|
|
UniformData uniformData
|
|
{
|
|
.projection = camera.projection(),
|
|
.view = camera.view(),
|
|
};
|
|
|
|
auto pooler = MemoryPool{ *r_buffer };
|
|
auto meshData = r_mesh->vertexData.View();
|
|
auto vertexSlice = *pooler.AllocSlice(meshData.size, 16);
|
|
auto indexSlice = *pooler.AllocSlice(r_mesh->indices.Size() * sizeof(uint16_t), 16);
|
|
auto uniformSlice = *pooler.AllocSlice(sizeof(UniformData), 16);
|
|
auto r_depthImage = r_renderContext->CreateImage(pooler, 1280, 720, depthFormat);
|
|
|
|
VkImageViewCreateInfo depthImageViewInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,
|
|
.image = *r_depthImage,
|
|
.viewType = VK_IMAGE_VIEW_TYPE_2D,
|
|
.format = depthFormat,
|
|
.subresourceRange = FirstDepthMipSubresourceRange,
|
|
};
|
|
|
|
VkImageView depthImageView = VK_NULL_HANDLE;
|
|
if (vkCreateImageView(r_renderContext->Device(), &depthImageViewInfo, nullptr, &depthImageView) != VK_SUCCESS)
|
|
return 1;
|
|
|
|
VkDescriptorBufferInfo bufferInfo =
|
|
{
|
|
.buffer = r_buffer->buffer,
|
|
.offset = uniformSlice.offset,
|
|
.range = uniformSlice.size,
|
|
};
|
|
|
|
VkWriteDescriptorSet writeDescriptorSet[] =
|
|
{
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
|
|
.dstSet = descriptorSet,
|
|
.dstBinding = 0,
|
|
.descriptorCount = 1,
|
|
.descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
.pBufferInfo = &bufferInfo,
|
|
},
|
|
};
|
|
vkUpdateDescriptorSets(r_renderContext->Device(), Size(writeDescriptorSet), writeDescriptorSet, 0, nullptr);
|
|
|
|
meshData.Copy ((uint8_t*)(r_buffer->ptr) + vertexSlice.offset);
|
|
r_mesh->indices.Copy((uint8_t*)(r_buffer->ptr) + indexSlice.offset);
|
|
|
|
memcpy((uint8_t*)(r_buffer->ptr) + uniformSlice.offset, &uniformData, sizeof(uniformData));
|
|
|
|
Input::InputHandler handler;
|
|
|
|
r_window->EnableRelativeMouse(true);
|
|
|
|
auto t1 = Time::now();
|
|
while (r_window->Update(handler))
|
|
{
|
|
const auto t2 = Time::now();
|
|
const float dt = Seconds(t2 - t1).count();
|
|
t1 = t2;
|
|
|
|
{
|
|
auto mouseDelta = r_window->GetMouseDelta();
|
|
//if (mouseDelta.x || mouseDelta.y)
|
|
//{
|
|
// log::info("mouse: %d %d", mouseDelta.x, mouseDelta.y);
|
|
//}
|
|
|
|
const float sensitivity = 6.0f;
|
|
|
|
camera.offsetOrientation(
|
|
-sensitivity * dt * Radian( mouseDelta.x ),
|
|
sensitivity * dt * Radian( mouseDelta.y ));
|
|
|
|
UniformData uniformData
|
|
{
|
|
.projection = camera.projection(),
|
|
.view = camera.view(),
|
|
};
|
|
|
|
const float movementSpeed = handler.get(Input::ButtonCodes::Key_LShift) ? 64.0f : 16.0f;
|
|
|
|
if (handler.get(Input::ButtonCodes::Key_W))
|
|
camera.transform.position += camera.forward() * movementSpeed * dt;
|
|
else if (handler.get(Input::ButtonCodes::Key_S))
|
|
camera.transform.position += camera.backward() * movementSpeed * dt;
|
|
|
|
if (handler.get(Input::ButtonCodes::Key_A))
|
|
camera.transform.position += camera.left() * movementSpeed * dt;
|
|
else if (handler.get(Input::ButtonCodes::Key_D))
|
|
camera.transform.position += camera.right() * movementSpeed * dt;
|
|
// NEED TO SYNCHRONIZE THIS
|
|
memcpy((uint8_t*)(r_buffer->ptr) + uniformSlice.offset, &uniformData, sizeof(uniformData));
|
|
}
|
|
|
|
VkCommandBuffer cmdBuf = r_swapchain->CommandBuffer();
|
|
r_renderContext->BeginCommandBuffer(cmdBuf);
|
|
{
|
|
VkViewport viewport =
|
|
{
|
|
.x = 0.0f,
|
|
.y = 0.0f,
|
|
.width = float(r_swapchain->Extent().width),
|
|
.height = float(r_swapchain->Extent().height),
|
|
.minDepth = 0.0f,
|
|
.maxDepth = 1.0f,
|
|
};
|
|
|
|
VkRect2D scissor =
|
|
{
|
|
.offset = {0u, 0u},
|
|
.extent = r_swapchain->Extent(),
|
|
};
|
|
|
|
vkCmdSetViewport(cmdBuf, 0, 1, &viewport);
|
|
vkCmdSetScissor(cmdBuf, 0, 1, &scissor);
|
|
|
|
vkCmdBindPipeline(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
|
|
vkCmdBindDescriptorSets(cmdBuf, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, nullptr);
|
|
|
|
vkCmdBindVertexBuffers2(cmdBuf, 0, 1, &vertexSlice.buffer, &vertexSlice.offset, &vertexSlice.size, nullptr);
|
|
vkCmdBindIndexBuffer(cmdBuf, r_buffer->buffer, indexSlice.offset, VK_INDEX_TYPE_UINT16);
|
|
|
|
const VkImageMemoryBarrier undefinedToColorBarrier =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
|
|
.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
.image = r_swapchain->Image(),
|
|
.subresourceRange = FirstColorMipSubresourceRange,
|
|
};
|
|
|
|
vkCmdPipelineBarrier(
|
|
cmdBuf,
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
|
|
0,
|
|
0, nullptr,
|
|
0, nullptr,
|
|
1, &undefinedToColorBarrier);
|
|
|
|
const VkImageMemoryBarrier undefinedToDepthBarrier =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.dstAccessMask = VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED,
|
|
.newLayout = VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL,
|
|
.image = *r_depthImage,
|
|
.subresourceRange = FirstColorMipSubresourceRange,
|
|
};
|
|
|
|
vkCmdPipelineBarrier(
|
|
cmdBuf,
|
|
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT,
|
|
VK_PIPELINE_STAGE_EARLY_FRAGMENT_TESTS_BIT,
|
|
0,
|
|
0, nullptr,
|
|
0, nullptr,
|
|
1, &undefinedToDepthBarrier);
|
|
|
|
const VkRenderingAttachmentInfoKHR colorAttachmentInfos[] =
|
|
{
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
|
|
.imageView = r_swapchain->ImageView(),
|
|
.imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
|
|
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
|
|
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
|
|
.clearValue = { .color = { .float32 = { 1.0f, 0.5f, 0.0f, 1.0f } } },
|
|
},
|
|
};
|
|
|
|
const VkRenderingAttachmentInfoKHR depthAttachmentInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_RENDERING_ATTACHMENT_INFO_KHR,
|
|
.imageView = depthImageView,
|
|
.imageLayout = VK_IMAGE_LAYOUT_ATTACHMENT_OPTIMAL_KHR,
|
|
.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR,
|
|
.storeOp = VK_ATTACHMENT_STORE_OP_STORE,
|
|
.clearValue = { .color = { .float32 = { 1.0f, 1.0f, 1.0f, 1.0f } } },
|
|
};
|
|
|
|
const VkRenderingInfo renderInfo =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_RENDERING_INFO,
|
|
.renderArea = { {}, r_swapchain->Extent() },
|
|
.layerCount = 1,
|
|
.colorAttachmentCount = Size(colorAttachmentInfos),
|
|
.pColorAttachments = colorAttachmentInfos,
|
|
.pDepthAttachment = &depthAttachmentInfo,
|
|
};
|
|
vkCmdBeginRendering(cmdBuf, &renderInfo);
|
|
vkCmdDrawIndexed(cmdBuf, r_mesh->indices.Size(), 1, 0, 0, 0);
|
|
vkCmdEndRendering(cmdBuf);
|
|
|
|
const VkImageMemoryBarrier colorToPresentBarrier =
|
|
{
|
|
.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,
|
|
.srcAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT,
|
|
.oldLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL,
|
|
.newLayout = VK_IMAGE_LAYOUT_PRESENT_SRC_KHR,
|
|
.image = r_swapchain->Image(),
|
|
.subresourceRange = FirstColorMipSubresourceRange,
|
|
};
|
|
|
|
vkCmdPipelineBarrier(
|
|
cmdBuf,
|
|
VK_PIPELINE_STAGE_COLOR_ATTACHMENT_OUTPUT_BIT,
|
|
VK_PIPELINE_STAGE_BOTTOM_OF_PIPE_BIT,
|
|
0,
|
|
0, nullptr,
|
|
0, nullptr,
|
|
1, &colorToPresentBarrier);
|
|
}
|
|
r_renderContext->EndCommandBuffer(cmdBuf);
|
|
r_swapchain->Present();
|
|
}
|
|
|
|
return 0;
|
|
}
|