Catcrafts/Crafter.Graphics
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

removed vulkan element

Browse source
This commit is contained in:
Jorijn van der Graaf 2025-04-27 23:20:52 +02:00
commit ae312807fc
11 changed files with 89 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Crafter.Graphics-Mesh.cppm
View file

@ -23,6 +23,7 @@ namespace Crafter {
static Mesh* FromAsset(const char* asset) {
std::uint32_t vertexCount = reinterpret_cast<const std::uint32_t*>(asset)[0];
std::uint32_t indexCount = reinterpret_cast<const std::uint32_t*>(asset)[1];
Mesh* mesh = new Mesh(vertexCount, (indexCount+ 63) & ~63);
const float* verticies = reinterpret_cast<const float*>(asset+sizeof(std::uint32_t)*2);
std::uint32_t counter = 0;

18
Crafter.Graphics-MeshShader.cppm
View file

@ -16,7 +16,7 @@ export module Crafter.Graphics:MeshShader;
import Crafter.Component;
import :Mesh;
import :Camera;
import :VulkanElement;
import :VulkanPipeline;
namespace Crafter {
@ -27,18 +27,14 @@ namespace Crafter {
ComponentRefOwning<Mesh<VertexType>> mesh;
ComponentRefOwning<Camera> camera;
Buffer<glm::mat4> mvp;
MeshShader(Mesh<VertexType>* mesh, Camera* camera) : mvp(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT), mesh(mesh), camera(camera) {
std::uint32_t threadCount;
MeshShader(Mesh<VertexType>* mesh, Camera* camera) : threadCount(mesh->indexCount/64/3), mvp(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT), mesh(mesh), camera(camera) {
}
void SetGroupSize(VulkanElement* element) {
element->sizeX = (mesh.component->indexCount/3)/64;
element->sizeY = 1;
element->sizeZ = 1;
}
void WriteDescriptors(VulkanElement* element) {
element->WriteDescriptor(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &mvp.descriptor);
element->WriteDescriptor(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, &mesh.component->verticies.descriptor);
element->WriteDescriptor(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2, &mesh.component->indicies.descriptor);
void WriteDescriptors(DescriptorSet& set) {
set.Write(0, VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0, &mvp.descriptor);
set.Write(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1, &mesh.component->verticies.descriptor);
set.Write(0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2, &mesh.component->indicies.descriptor);
}
void Update() {
mvp.value[0] = camera.component->projectionView*transform;

25
Crafter.Graphics-VulkanElement.cpp
View file

@ -1,25 +0,0 @@
module;
#include <cstdint>
#include <vulkan/vulkan.h>
#include "VulkanInitializers.hpp"
module Crafter.Graphics;
using namespace Crafter;
VulkanElement::VulkanElement(VkPipelineLayout pipelineLayout, VkPipeline pipeline) : pipelineLayout(pipelineLayout), pipeline(pipeline) {
}
VulkanElement::VulkanElement(VkPipelineLayout pipelineLayout, VkPipeline pipeline, std::uint32_t sizeX, std::uint32_t sizeY, std::uint32_t sizeZ) : pipelineLayout(pipelineLayout), pipeline(pipeline), sizeX(sizeX), sizeY(sizeY), sizeZ(sizeZ) {
}
void VulkanElement::WriteDescriptor(VkWriteDescriptorSet* set, std::uint32_t count) {
vkUpdateDescriptorSets(VulkanDevice::device, count, set, 0, nullptr);
}
void VulkanElement::WriteDescriptor(std::uint32_t stage, VkDescriptorType type, std::uint32_t binding, VkDescriptorBufferInfo* buffer) {
VkWriteDescriptorSet write = vks::initializers::writeDescriptorSet(descriptorSet[stage], type, binding, buffer);
vkUpdateDescriptorSets(VulkanDevice::device, 1, &write, 0, nullptr);
}

23
Crafter.Graphics-VulkanElement.cppm
View file

@ -1,23 +0,0 @@
module;
#include <cstdint>
#include <vulkan/vulkan.h>
export module Crafter.Graphics:VulkanElement;
import Crafter.Component;
namespace Crafter {
export class VulkanElement : public Component {
public:
VkPipelineLayout pipelineLayout;
VkDescriptorSet descriptorSet[2];
VkPipeline pipeline;
std::uint32_t sizeX;
std::uint32_t sizeY;
std::uint32_t sizeZ;
VulkanElement(VkPipelineLayout pipelineLayout, VkPipeline pipeline);
VulkanElement(VkPipelineLayout pipelineLayout, VkPipeline pipeline, std::uint32_t sizeX, std::uint32_t sizeY, std::uint32_t sizeZ);
void WriteDescriptor(VkWriteDescriptorSet* descriptors, std::uint32_t count);
void WriteDescriptor(std::uint32_t stage, VkDescriptorType type, std::uint32_t binding, VkDescriptorBufferInfo* buffer);
};
}

22
Crafter.Graphics-VulkanElementFromPipeline.cppm
View file

@ -1,22 +0,0 @@
module;
#include <cstdint>
#include <vulkan/vulkan.h>
export module Crafter.Graphics:VulkanElementFromPipeline;
import Crafter.Component;
import :VulkanPipeline;
import :VulkanElement;
namespace Crafter {
export template<typename Pipeline>
class VulkanElementFromPipeline : public VulkanElement {
public:
VulkanElementFromPipeline() : VulkanElement(Pipeline::pipelineLayout, Pipeline::pipeline) {
Pipeline::GetDescriptorSet(&descriptorSet[0]);
}
VulkanElementFromPipeline(std::uint32_t sizeX, std::uint32_t sizeY, std::uint32_t sizeZ) : VulkanElement(Pipeline::pipelineLayout, Pipeline::pipeline, sizeX, sizeY, sizeZ) {
Pipeline::GetDescriptorSet(&descriptorSet[0]);
}
};
}

15
Crafter.Graphics-VulkanPipeline.cppm
View file

@ -26,6 +26,17 @@ namespace Crafter {
bool occured = true;
};
export struct DescriptorSet {
VkDescriptorSet set[2];
void Write(VkWriteDescriptorSet* descriptors, std::uint32_t count) {
vkUpdateDescriptorSets(VulkanDevice::device, count, descriptors, 0, nullptr);
}
void Write(std::uint32_t stage, VkDescriptorType type, std::uint32_t binding, VkDescriptorBufferInfo* buffer) {
VkWriteDescriptorSet write = vks::initializers::writeDescriptorSet(set[stage], type, binding, buffer);
vkUpdateDescriptorSets(VulkanDevice::device, 1, &write, 0, nullptr);
}
};
export template <typename MeshShader, typename FragmentShader>
class VulkanPipeline {
private:
@ -197,9 +208,9 @@ namespace Crafter {
VulkanDevice::CHECK_VK_RESULT(vkCreateGraphicsPipelines(VulkanDevice::device, VK_NULL_HANDLE, 1, &pipelineCI, nullptr, &pipeline));
}
static void GetDescriptorSet(VkDescriptorSet* set) {
static void GetDescriptorSet(DescriptorSet& set) {
VkDescriptorSetAllocateInfo allocInfo = vks::initializers::descriptorSetAllocateInfo(descriptorPool, &descriptorSetLayout[0], 2);
VulkanDevice::CHECK_VK_RESULT(vkAllocateDescriptorSets(VulkanDevice::device, &allocInfo, set));
VulkanDevice::CHECK_VK_RESULT(vkAllocateDescriptorSets(VulkanDevice::device, &allocInfo, set.set));
}
};
}

52
Crafter.Graphics-VulkanTexture.cppm Normal file
View file

@ -0,0 +1,52 @@
module;
#include <cstdint>
#include <vulkan/vulkan.h>
#include <cstring>
#include <iostream>
#define GLM_FORCE_RADIANS
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
#define GLM_ENABLE_EXPERIMENTAL
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/matrix_inverse.hpp>
#include <glm/gtc/type_ptr.hpp>
export module Crafter.Graphics:VulkanTexture;
import :VulkanDevice;
namespace Crafter {
class VulkanTexture {
public:
static void createImage(uint32_t width, uint32_t height, VkFormat format, VkImageTiling tiling, VkImageUsageFlags usage, VkMemoryPropertyFlags properties, VkImage& image, VkDeviceMemory& imageMemory) {
VkImageCreateInfo imageInfo{};
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
imageInfo.imageType = VK_IMAGE_TYPE_2D;
imageInfo.extent.width = width;
imageInfo.extent.height = height;
imageInfo.extent.depth = 1;
imageInfo.mipLevels = 1;
imageInfo.arrayLayers = 1;
imageInfo.format = format;
imageInfo.tiling = tiling;
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
imageInfo.usage = usage;
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
VulkanDevice::CHECK_VK_RESULT(vkCreateImage(device, &imageInfo, nullptr, &image));
VkMemoryRequirements memRequirements;
vkGetImageMemoryRequirements(device, image, &memRequirements);
VkMemoryAllocateInfo allocInfo{};
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
allocInfo.allocationSize = memRequirements.size;
allocInfo.memoryTypeIndex = findMemoryType(memRequirements.memoryTypeBits, properties);
VulkanDevice::CHECK_VK_RESULT(vkAllocateMemory(device, &allocInfo, nullptr, &imageMemory));
vkBindImageMemory(device, image, imageMemory, 0);
}
};
}

7
Crafter.Graphics-WindowWaylandVulkan.cpp
View file

@ -418,12 +418,9 @@ void WindowWaylandVulkan::Start() {
VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
for(VulkanElement* element : vulkanElements.components) {
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, element->pipelineLayout, 0, 2, element->descriptorSet, 0, NULL);
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, element->pipeline);
VulkanDevice::vkCmdDrawMeshTasksEXTProc(drawCmdBuffers[i], element->sizeX, element->sizeY, element->sizeZ);
onDraw.Invoke(drawCmdBuffers[i]);
VulkanDevice::vkCmdEndRenderingKHRProc(drawCmdBuffers[i]);
}
image_layout_transition(drawCmdBuffers[i],
images[i],

2
Crafter.Graphics-WindowWaylandVulkan.cppm
View file

@ -29,7 +29,7 @@ namespace Crafter {
export class WindowWaylandVulkan : public WindowWayland {
public:
ComponentRefVector<VulkanElement> vulkanElements;
Event<VkCommandBuffer> onDraw;
WindowWaylandVulkan(std::string name, std::uint32_t width, std::uint32_t height);
~WindowWaylandVulkan();
void Start();

14
main.cpp
View file

@ -11,6 +11,7 @@
#include <glm/gtc/type_ptr.hpp>
import Crafter.Graphics;
import Crafter.Asset;
import Crafter.Event;
using namespace Crafter;
typedef VulkanShader<"test.spirv", "main", VK_SHADER_STAGE_MESH_BIT_EXT, 3, {{{VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 0}, {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1}, {VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 2}}}> MeshVulkanShader;
@ -29,16 +30,21 @@ int main() {
asset.LoadFull("core.cras");
Camera camera;
VulkanElement test = VulkanElementFromPipeline<Pipeline>();
Mesh<Vertex_xf32_yf32_zf32_wf32>* mesh = Mesh<Vertex_xf32_yf32_zf32_wf32>::FromAsset(asset.entries[0].data.data());
DescriptorSet descriptors;
Pipeline::GetDescriptorSet(descriptors);
MeshShader<Vertex_xf32_yf32_zf32_wf32> meshShader(mesh, &camera);
meshShader.SetGroupSize(&test);
meshShader.WriteDescriptors(&test);
meshShader.WriteDescriptors(descriptors);
meshShader.transform = glm::mat4(1.0f);
meshShader.Update();
window.vulkanElements.AddComponent(&test);
EventListener<VkCommandBuffer> listener(&window.onDraw, [&descriptors, &meshShader](VkCommandBuffer cmd){
vkCmdBindDescriptorSets(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, Pipeline::pipelineLayout, 0, 2, &descriptors.set[0], 0, NULL);
vkCmdBindPipeline(cmd, VK_PIPELINE_BIND_POINT_GRAPHICS, Pipeline::pipeline);
VulkanDevice::vkCmdDrawMeshTasksEXTProc(cmd, meshShader.threadCount, 1, 1);
});
window.Start();
while(true) {

4
project.json
View file

@ -4,9 +4,9 @@
{
"name": "base",
"standard": "c++26",
"source_files": ["Crafter.Graphics-Window","Crafter.Graphics-WindowWayland","Crafter.Graphics-WindowWaylandWayland", "Crafter.Graphics-UiElement", "Crafter.Graphics-VulkanDevice", "Crafter.Graphics-WindowWaylandVulkan", "VulkanBuffer", "VulkanTools", "Crafter.Graphics-VulkanElement", "Crafter.Graphics-Camera"],
"source_files": ["Crafter.Graphics-Window","Crafter.Graphics-WindowWayland","Crafter.Graphics-WindowWaylandWayland", "Crafter.Graphics-UiElement", "Crafter.Graphics-VulkanDevice", "Crafter.Graphics-WindowWaylandVulkan", "VulkanBuffer", "VulkanTools", "Crafter.Graphics-Camera"],
"c_files": ["wayland-xdg-decoration-unstable-v1-client-protocol", "xdg-shell-protocol", "shm"],
"module_files": ["Crafter.Graphics-Window","Crafter.Graphics-WindowWayland","Crafter.Graphics-WindowWaylandWayland", "Crafter.Graphics", "Crafter.Graphics-UiElement", "Crafter.Graphics-Types", "Crafter.Graphics-VulkanDevice", "Crafter.Graphics-VulkanPipeline", "Crafter.Graphics-VulkanShader", "Crafter.Graphics-WindowWaylandVulkan", "Crafter.Graphics-VulkanElement", "Crafter.Graphics-VulkanElementFromPipeline", "Crafter.Graphics-Camera", "Crafter.Graphics-VulkanBuffer", "Crafter.Graphics-Mesh", "Crafter.Graphics-MeshShader"],
"module_files": ["Crafter.Graphics-Window","Crafter.Graphics-WindowWayland","Crafter.Graphics-WindowWaylandWayland", "Crafter.Graphics", "Crafter.Graphics-UiElement", "Crafter.Graphics-Types", "Crafter.Graphics-VulkanDevice", "Crafter.Graphics-VulkanPipeline", "Crafter.Graphics-VulkanShader", "Crafter.Graphics-WindowWaylandVulkan", "Crafter.Graphics-Camera", "Crafter.Graphics-VulkanBuffer", "Crafter.Graphics-Mesh", "Crafter.Graphics-MeshShader"],
"build_dir": "./build",
"output_dir": "./bin",
"type":"library",