fog_density = 0;
- mbuf = vbuf = fbuf = svbuf = 0;
+ mbuf = 0;
+ default_vs_ub = 0;
+ default_fs_ub = 0;
+ sky_vs_ub = 0;
}
MorphRenderer::~MorphRenderer()
return false;
}
- if(!vbuf) {
- vbuf = gfx_create_uniform_buffer();
- if(!vbuf->create(sizeof vu)) {
+ if(!default_vs_ub) {
+ default_vs_ub = gfx_create_uniform_buffer();
+ if(!default_vs_ub->create(sizeof default_vs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
}
- if(!fbuf) {
- fbuf = gfx_create_uniform_buffer();
- if(!fbuf->create(sizeof fu)) {
+ if(!default_fs_ub) {
+ default_fs_ub = gfx_create_uniform_buffer();
+ if(!default_fs_ub->create(sizeof default_fs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
}
- if(!svbuf) {
- svbuf = gfx_create_uniform_buffer();
- if(!svbuf->create(sizeof svu)) {
+ if(!sky_vs_ub) {
+ sky_vs_ub = gfx_create_uniform_buffer();
+ if(!sky_vs_ub->create(sizeof sky_vs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
mbuf->update(&mu);
mbuf->bind(MORPHING_MATRIX_UNIFORMS);
- vu.mmod = scene->objects[i]->transform.upper3x3();
- vbuf->update(&vu);
- vbuf->bind(MATRIX_UNIFORMS);
+ default_vs_uniforms.mmod = scene->objects[i]->transform.upper3x3();
+ default_vs_ub->update(&default_vs_uniforms);
+ default_vs_ub->bind(MATRIX_UNIFORMS);
draw_object(scene->objects[i]);
}
fog_density = 0;
- vbuf = fbuf = svbuf = 0;
+ default_vs_ub = 0;
+ default_fs_ub = 0;
+ sky_vs_ub = 0;
}
Renderer::~Renderer()
{
- delete vbuf;
- delete fbuf;
- delete svbuf;
+ delete default_vs_ub;
+ delete default_fs_ub;
+ delete sky_vs_ub;
}
bool Renderer::create()
// tf(stderr, "Failed to load debug shaders.\n");
// }
- vbuf = gfx_create_uniform_buffer();
- if(!vbuf->create(sizeof vu)) {
+ default_vs_ub = gfx_create_uniform_buffer();
+ if(!default_vs_ub->create(sizeof default_vs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
- fbuf = gfx_create_uniform_buffer();
- if(!fbuf->create(sizeof fu)) {
+ default_fs_ub = gfx_create_uniform_buffer();
+ if(!default_fs_ub->create(sizeof default_fs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
- svbuf = gfx_create_uniform_buffer();
- if(!svbuf->create(sizeof svu)) {
+ sky_vs_ub = gfx_create_uniform_buffer();
+ if(!sky_vs_ub->create(sizeof sky_vs_uniforms)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
/* setting uniforms for material */
- fu.diffuse = Vec4(m->diffuse.x, m->diffuse.y, m->diffuse.z, 1.0);
- fu.specular = Vec4(m->specular.x, m->specular.y, m->specular.z, 1.0);
- fu.shininess = m->shininess;
- fu.fog_density = fog_density;
+ default_fs_uniforms.diffuse = Vec4(m->diffuse.x, m->diffuse.y, m->diffuse.z, 1.0);
+ default_fs_uniforms.specular = Vec4(m->specular.x, m->specular.y, m->specular.z, 1.0);
+ default_fs_uniforms.shininess = m->shininess;
+ default_fs_uniforms.fog_density = fog_density;
- fbuf->update(&fu);
- fbuf->bind(SHADING_UNIFORMS);
+ default_fs_ub->update(&default_fs_uniforms);
+ default_fs_ub->bind(SHADING_UNIFORMS);
/* texture */
/* setting uniforms for matrices */
- vu.mview = object->transform * camera->get_view_matrix();
- vu.mmviewproj = object->transform * camera->get_view_matrix() * mprojection;
- vu.mmod = object->transform.upper3x3();
+ default_vs_uniforms.mview = object->transform * camera->get_view_matrix();
+ default_vs_uniforms.mmviewproj = object->transform * camera->get_view_matrix() * mprojection;
+ default_vs_uniforms.mmod = object->transform.upper3x3();
- vbuf->update(&vu);
- vbuf->bind(MATRIX_UNIFORMS);
+ default_vs_ub->update(&default_vs_uniforms);
+ default_vs_ub->bind(MATRIX_UNIFORMS);
object->mesh->draw();
#ifdef DRAW_NORMALS
if(nprog) {
vu.mmviewproj = mmviewproj;
- vbuf->update(&vu);
- vbuf->bind(MATRIX_UNIFORMS);
+ default_vs_ub->update(&vu);
+ default_vs_ub->bind(MATRIX_UNIFORMS);
nprog->use();
object->mesh->draw_normals(1.0);
skytex->bind();
skyprog->use();
- svu.mviewproj = camera->get_view_matrix().upper3x3() * mprojection;
- svbuf->update(&svu);
- svbuf->bind(SKY_MATRIX_UNIFORMS);
+ sky_vs_uniforms.mviewproj = camera->get_view_matrix().upper3x3() * mprojection;
+ sky_vs_ub->update(&sky_vs_uniforms);
+ sky_vs_ub->bind(SKY_MATRIX_UNIFORMS);
skymesh->draw();
class Renderer {
protected:
- BaseMatrixUniforms vu;
- UniformBuffer *vbuf;
+ BaseMatrixUniforms default_vs_uniforms;
+ UniformBuffer *default_vs_ub;
- BaseShadingUniforms fu;
- UniformBuffer *fbuf;
+ BaseShadingUniforms default_fs_uniforms;
+ UniformBuffer *default_fs_ub;
- SkyMatrixUniforms svu;
- UniformBuffer *svbuf;
+ SkyMatrixUniforms sky_vs_uniforms;
+ UniformBuffer *sky_vs_ub;
ShaderProgram *sprog;
#include <vulkan/vulkan.h>
+#include <stdio.h>
+#include "gfxapi.h"
#include "renderer-vk.h"
#include "uniforms.h"
+#include "vkutil.h"
+#include "vkutil-pipeline.h"
+
+static VkuPipelineGenerator pipe_gen;
RendererVK::RendererVK()
{
dskytex = 0;
fog_density = 0;
- vbuf = fbuf = svbuf = 0;
+
+ default_vs_ub = 0;
+ default_fs_ub = 0;
+ sky_vs_ub = 0;
}
RendererVK::~RendererVK()
{
- delete vbuf;
- delete fbuf;
- delete svbuf;
+ delete default_vs_ub;
+ delete default_fs_ub;
+ delete sky_vs_ub;
+}
+
+bool RendererVK::create_resources()
+{
+ /* default pipeline: create binding points */
+ default_vs_ub = gfx_create_uniform_buffer();
+ if(!default_vs_ub->create(sizeof default_vs_uniforms)) {
+ fprintf(stderr, "Failed to create the default VS uniform buffer.\n");
+ return false;
+ }
+ ResourceVK default_vs_res;
+ if(!default_vs_res.create_ds_layout(MATRIX_UNIFORMS,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ VK_SHADER_STAGE_VERTEX_BIT, 0)) {
+ fprintf(stderr, "Failed to create the ds layout for the default vs uniform buffer.\n");
+ return false;
+ }
+ default_resources.push_back(default_vs_res);
+
+ default_fs_ub = gfx_create_uniform_buffer();
+ if(!default_fs_ub->create(sizeof default_fs_uniforms)) {
+ fprintf(stderr, "Failed to create the default FS uniform buffer.\n");
+ return false;
+ }
+ ResourceVK default_fs_res;
+ if(!default_fs_res.create_ds_layout(SHADING_UNIFORMS,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ VK_SHADER_STAGE_FRAGMENT_BIT, 0)) {
+ fprintf(stderr, "Failed to create the ds layout for the default VS uniform buffer.\n");
+ return false;
+ }
+ default_resources.push_back(default_fs_res);
+
+ sky_vs_ub = gfx_create_uniform_buffer();
+ if(!sky_vs_ub->create(sizeof sky_vs_uniforms)) {
+ fprintf(stderr, "Failed to create the VS uniform buffer for the sky.\n");
+ return false;
+ }
+ ResourceVK sky_vs_res;
+ if(!sky_vs_res.create_ds_layout(SKY_MATRIX_UNIFORMS,
+ VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
+ VK_SHADER_STAGE_FRAGMENT_BIT, 0)) {
+ fprintf(stderr, "Failed to create the ds layout for the sky VS uniform buffer.\n");
+ return false;
+ }
+ sky_resources.push_back(sky_vs_res);
+
+ return true;
}
bool RendererVK::create()
return false;
}
-/* if(!create_sky_pipeline()) {
- fprintf(stderr, "Failed to create sky pipeline.\n");
- return false;
- }*/
+ /* if(!create_sky_pipeline()) {
+ fprintf(stderr, "Failed to create sky pipeline.\n");
+ return false;
+ }*/
return true;
}
bool RendererVK::create_default_pipeline()
{
- /* vertex */
+
return true;
}
#ifndef RENDERER_VK_H_
#define RENDERER_VK_H_
+#include <vector>
#include <vulkan/vulkan.h>
+
#include "renderer.h"
+#include "vulkan/resources.h"
class RendererVK : public Renderer {
private:
+ VkDescriptorPool uniform_pool;
+
+ VkPipeline pipe_default;
+ std::vector<ResourceVK> default_resources;
+
+ VkPipeline pipe_morph;
+ std::vector<ResourceVK> morph_resources;
+
+ VkPipeline pipe_sky;
+ std::vector<ResourceVK> sky_resources;
+
bool create_default_pipeline();
public:
RendererVK();
~RendererVK();
bool create() override;
+ bool create_resources();
};
--- /dev/null
+#include <stdio.h>
+#include <string.h>
+
+#include "resources.h"
+#include "vkutil.h"
+
+ResourceVK::ResourceVK() {}
+ResourceVK::~ResourceVK() {}
+
+bool ResourceVK::create_ds_layout(unsigned int num, VkDescriptorType type,
+ VkShaderStageFlags stage, VkSampler *sampler)
+{
+ res_type = RES_DESC_SET;
+
+ /* layout binding */
+ VkDescriptorSetLayoutBinding bind;
+
+ memset(&bind, 0, sizeof bind);
+ bind.binding = num;
+ bind.descriptorType = type;
+ bind.stageFlags = stage;
+
+ bind.pImmutableSamplers = sampler;
+
+ /* layout : for the moment:
+ * one layout per ds, (=> 1 binding point)
+ * */
+
+ VkDescriptorSetLayoutCreateInfo dslinf;
+ memset(&dslinf, 0, sizeof dslinf);
+ dslinf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
+ dslinf.bindingCount = 1;
+ dslinf.pBindings = &bind;
+
+ if(vkCreateDescriptorSetLayout(vk_device, &dslinf, 0, &layout) != VK_SUCCESS) {
+ fprintf(stderr, "Failed to create descriptor set layout.\n");
+ return false;
+ }
+ return true;
+}
--- /dev/null
+#ifndef RESOURCES_H_
+#define RESOURCES_H_
+
+#include <vulkan/vulkan.h>
+
+enum ResourceType {
+ RES_DESC_SET,
+ RES_PUSH_CONST,
+};
+
+class ResourceVK {
+private:
+ ResourceType res_type;
+
+ VkDescriptorSetLayout layout;
+ VkPushConstantRange range;
+
+public:
+ ResourceVK();
+ ~ResourceVK();
+
+ bool create_ds_layout(unsigned int num, VkDescriptorType type,
+ VkShaderStageFlags stage, VkSampler *sampler);
+};
+
+#endif //RESOURCES_H_
bool ShaderProgramVK::create()
{
-
return true;
}
UniformBufferVK::~UniformBufferVK()
{
+ destroy();
}
bool UniformBufferVK::create(int size)
{
if(!(ubo = vku_create_buffer(size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT))) {
- fprintf(stderr, "Failed to create uniform buffer object.\n");
+ fprintf(stderr, "Failed to create vulkan uniform buffer object.\n");
return false;
}
- return UniformBuffer::create(size);
+ if(!UniformBuffer::create(size)) {
+ fprintf(stderr, "Failed to create uniform buffer object.\n");
+ return false;
+ }
+ return true;
}
void UniformBufferVK::destroy()
void UniformBufferVK::bind(int binding) const
{
if(vkBindBufferMemory(vk_device, ubo->buf, ubo->mem_pool, 0) !=
- VK_SUCCESS) {
+ VK_SUCCESS) {
fprintf(stderr, "Failed to bind ubo.\n");
}
}
class UniformBufferVK : public UniformBuffer {
private:
vku_buffer *ubo;
- VkDescriptorSet dset;
+
+ VkWriteDescriptorSet descr_write;
+ VkDescriptorBufferInfo ubo_inf;
public:
UniformBufferVK();
VkPipelineLayoutCreateInfo linf;
memset(&linf, 0, sizeof linf);
linf.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- linf.setLayoutCount = dset_layouts.size();
- linf.pSetLayouts = dset_layouts.data();
+ linf.setLayoutCount = res_layouts.size();
+ linf.pSetLayouts = res_layouts.data();
//TODO find max num dsets vkGetPhysicalDeviceProperties
//maxBoundDescriptorSets of VkPhysicalDeviceLimits
- linf.pushConstantRangeCount = push_const_ranges.size();
- linf.pPushConstantRanges = push_const_ranges.data();
+ //linf.pushConstantRangeCount = push_const_ranges.size();
+ //linf.pPushConstantRanges = push_const_ranges.data();
//maxPushConstantsSize from VkPhysicalDeviceLimits
VkPipelineLayout layout;
VkPipeline gpipeline;
if(vkCreateGraphicsPipelines(vk_device, pcache, 1, &gpinf, 0, &gpipeline) !=
- VK_SUCCESS) {
+ VK_SUCCESS) {
fprintf(stderr, "Failed to create graphics pipeline.\n");
return 0;
}
}
void VkuPipelineGenerator::set_shader_modules(VkShaderModule vs,
- VkShaderModule fs)
+ VkShaderModule fs)
{
sdri[0].module = vs;
sdri[1].module = fs;
}
void VkuPipelineGenerator::set_attribute(uint32_t binding, uint32_t stride,
- uint32_t location, VkFormat format)
+ uint32_t location, VkFormat format)
{
VkVertexInputBindingDescription bdsc;
bdsc.binding = binding;
adsc.binding = binding;
adsc.format = format;
}
-
-void VkuPipelineGenerator::set_descriptor_set_layout(const vku_descriptor &desc)
-{
- dset_layouts.push_back(desc.layout);
-}
#include <vulkan/vulkan.h>
-#define VERTEX_ATTRIB_BIT (1 << VKU_BIND_VERTEX)
-#define NORMAL_ATTRIB_BIT (1 << VKU_BIND_NORMAL)
-#define TEX_COORD_ATTRIB_BIT (1 << VKU_BIND_TEX_COORD)
-
enum VkuVertexBindings {
VKU_BIND_VERTEX,
VKU_BIND_NORMAL,
std::vector<VkVertexInputBindingDescription> bind_descriptions;
std::vector<VkVertexInputAttributeDescription> attr_descriptions;
- /* uniforms */
- std::vector<VkDescriptorSetLayout> dset_layouts;
- std::vector<VkPushConstantRange> push_const_ranges;
+ /* resources */
+ std::vector<VkDescriptorSetLayout> res_layouts;
+// std::vector<VkPushConstantRange> push_const_ranges;
public:
VkuPipelineGenerator();
void set_shader_modules(VkShaderModule vs, VkShaderModule fs);
void set_attribute(uint32_t binding, uint32_t stride, uint32_t location,
VkFormat format);
- void set_descriptor_set_layout(const vku_descriptor &desc);
- void set_push_constant(); //TODO
};
#endif // VKUTIL_PIPELINE_H_
void vku_destroy_buffer(struct vku_buffer *buf)
{
- if(buf) {
- vkDestroyBuffer(vk_device, buf->buf, 0);
- }
}
bool vku_update_buffer(vku_buffer *buf, int size, void *data)
{
uint8_t *pdata;
- if(vkMapMemory(vk_device, buf->mem_pool, 0, size, 0, (void**)&pdata) != VK_SUCCESS) {
+ if(vkMapMemory(vk_device, buf->mem_pool, 0, size, 0, (void **)&pdata) != VK_SUCCESS) {
fprintf(stderr, "Failed to map memory.\n");
return false;
}
}
vku_descriptor *vku_create_descriptor(VkDescriptorType type,
- VkFlags stage, int binding_point,
- int size, int num_desc)
+ VkFlags stage, int binding_point,
+ int size, int num_desc)
{
vku_descriptor *desc = new vku_descriptor;
// std::vector
return true;
}
-
-VkPipelineCache vku_create_pipeline_cache()
-{
- VkPipelineCacheCreateInfo cinf;
- memset(&cinf, 0, sizeof cinf);
- cinf.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-
- VkPipelineCache cache;
- if(vkCreatePipelineCache(vk_device, &cinf, 0, &cache) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create pipeline cache.\n");
- return 0;
- }
- return cache;
-}
-
-void vku_destroy_pipeline_cache(VkPipelineCache cache)
-{
- vkDestroyPipelineCache(vk_device, cache, 0);
-}
-
-void vku_pl_init_shader_stage_state_info(VkPipelineShaderStageCreateInfo *ssinf,
- VkShaderStageFlagBits stage, VkShaderModule sm)
-{
- memset(ssinf, 0, sizeof *ssinf);
- ssinf->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
- ssinf->stage = stage;
- ssinf->module = sm;
- ssinf->pName = "main";
-}
-
-void vku_pl_init_input_asm_state_info(VkPipelineInputAssemblyStateCreateInfo *iasinf)
-{
- memset(iasinf, 0, sizeof *iasinf);
- iasinf->sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
- iasinf->topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
-}
-
-void vku_pl_init_viewport_state_info(VkPipelineViewportStateCreateInfo *vsinf,
- VkViewport *viewports, int num_viewports, VkRect2D *scissors,
- int num_scissors)
-{
- memset(vsinf, 0, sizeof *vsinf);
- vsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
- vsinf->viewportCount = num_viewports;
- vsinf->scissorCount = num_scissors;
- vsinf->pViewports = viewports;
- vsinf->pScissors = scissors;
-}
-
-void vku_pl_init_rasterization_state_info(VkPipelineRasterizationStateCreateInfo *rsinf)
-{
- memset(rsinf, 0, sizeof *rsinf);
- rsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
- rsinf->polygonMode = VK_POLYGON_MODE_FILL;
- rsinf->cullMode = VK_CULL_MODE_FRONT_BIT;
- rsinf->frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
-}
-
-void vku_pl_init_multisample_state_info(VkPipelineMultisampleStateCreateInfo *msinf)
-{
- memset(msinf, 0, sizeof *msinf);
- msinf->sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
- msinf->rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
-}
-
-void vku_pl_init_depth_stencil_state_info(VkPipelineDepthStencilStateCreateInfo *dsinf,
- bool enable)
-{
- memset(dsinf, 0, sizeof *dsinf);
- dsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
- dsinf->depthTestEnable = enable ? VK_TRUE : VK_FALSE;
-}
-
-void vku_pl_init_color_blend_state_info(VkPipelineColorBlendStateCreateInfo *cbsinf,
- bool enable)
-{
- memset(cbsinf, 0, sizeof *cbsinf);
- cbsinf->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
- //TODO
-}
extern VkSurfaceKHR vk_surface;
extern VkInstance vk_instance;
extern int vk_qfamily;
-extern VkDescriptorPool vk_dpool;
extern VkRenderPass vk_renderpass;
struct vku_buffer {
int size;
};
-struct vku_pipeline {
-};
-
-struct vku_pipeline_info {
- /* shader stages */
- VkShaderModule vs;
- VkShaderModule fs;
-
- /* states info */
-
- VkPipelineShaderStageCreateInfo inf_shader_stage;
-
- VkPipelineVertexInputStateCreateInfo inf_vertex_input;
-
- VkPipelineInputAssemblyStateCreateInfo inf_input_asm;
-
- VkPipelineTessellationStateCreateInfo inf_tessel;
-
- VkPipelineViewportStateCreateInfo inf_viewport;
- VkPipelineRasterizationStateCreateInfo inf_raster;
- VkPipelineMultisampleStateCreateInfo inf_multisample;
- VkPipelineDepthStencilStateCreateInfo inf_depth_stencil;
- VkPipelineColorBlendStateCreateInfo inf_colorblend;
-
- VkPipelineDynamicStateCreateInfo inf_dynamic_state;
-
- VkPipelineLayout layout;
- VkRenderPass renderpass;
- uint32_t subpass;
-};
-
/* extensions */
bool vku_have_extension(const char *name);
bool vku_have_device_extension(const char *name);
bool vku_create_descriptor_pool(vku_descriptor **descriptors, int num_desc,
VkDescriptorSet set);
-void vku_destroy_descriptor_pool();
+
+/*
+void vku_destroy_descriptor_pool();*/
#endif // VKUTIL_H_
projects / demo / commitdiff