Shader.cpp

Go to the documentation of this file.

#include "Engine/Shader/Shader.h"
#include <vector>
#include "Engine/Files/FileHandler.h"
#include <stdexcept>
#include "Engine/Core/VulkanHelper.h"
 
void Shader::destroyShader(VkShaderModule shaderModule, const VkDevice &device)
{
    vkDestroyShaderModule(device, shaderModule, nullptr);
}
 
VkShaderModule Shader::createShaderModule(VkDevice device, const std::vector<char>& code)
{
    VkShaderModuleCreateInfo createInfo{};
    createInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    createInfo.codeSize = code.size();
    createInfo.pCode = reinterpret_cast<const uint32_t*>(code.data());
 
    VkShaderModule shaderModule;
    if(vkCreateShaderModule(device, &createInfo, nullptr, &shaderModule) != VK_SUCCESS)
    {
        throw std::runtime_error("failed to create shader module!");
    }
 
    return shaderModule;
}
 
ComputeShader::ComputeShader(VkDevice device, const std::filesystem::path& shaderPath)
{
    const std::vector<char> shader_content = FileHandler::readFile(shaderPath.string());
    computeShaderModule = createShaderModule(device, shader_content);
    VulkanHelper::setObjectName(device, computeShaderModule, "Compute shader module");
}
void ComputeShader::destroyShaders(VkDevice device)
{
    Shader::destroyShaders(device);
    destroyShader(computeShaderModule, device);
}
 
MeshShader::MeshShader(VkDevice device,
                               const std::filesystem::path& mesh_shader_path,
                               const std::filesystem::path& fragment_shader_path)
{
    const std::vector<char> meshShaderCode = FileHandler::readFile(mesh_shader_path.string());
    const std::vector<char> fragShaderCode = FileHandler::readFile(fragment_shader_path.string());
 
    meshShader = createShaderModule(device, meshShaderCode);
    fragmentShader = createShaderModule(device, fragShaderCode);
}
 
VkShaderModule MeshShader::getMeshShader() const
{
    return meshShader;
}
 
VkShaderModule MeshShader::getFragmentShader() const
{
    return fragmentShader;
}
void MeshShader::destroyShaders(VkDevice device)
{
    Shader::destroyShaders(device);
    destroyShader(meshShader, device);
    destroyShader(fragmentShader, device);
}
 
VertexShader::VertexShader(
    VkDevice                      device,
    const std::filesystem::path & vertex_shader_path,
    const std::filesystem::path & fragment_shader_path
)
{
    const std::vector<char> vertexShaderCode = FileHandler::readFile(vertex_shader_path.string());
    const std::vector<char> fragShaderCode = FileHandler::readFile(fragment_shader_path.string());
 
    vertexShader = createShaderModule(device, vertexShaderCode);
    fragmentShader = createShaderModule(device, fragShaderCode);
}
 
VkShaderModule VertexShader::getVertexShader() const
{
    return vertexShader;
}
 
VkShaderModule VertexShader::getFragmentShader() const
{
    return fragmentShader;
}
 
void VertexShader::destroyShaders( VkDevice device )
{
    Shader::destroyShaders( device );
    destroyShader(vertexShader, device);
    destroyShader( fragmentShader, device );
}