#!/bin/bash
-glslangValidator -V -S vert shaders/default.v.glsl -o shaders/spirv/default.v.spv
-glslangValidator -V -S frag shaders/default.f.glsl -o shaders/spirv/default.f.spv
-glslangValidator -V -S vert shaders/morphing.v.glsl -o shaders/spirv/morphing.v.spv
-glslangValidator -V -S frag shaders/morphing.f.glsl -o shaders/spirv/morphing.f.spv
-glslangValidator -V -S vert shaders/sky.v.glsl -o shaders/spirv/sky.v.spv
-glslangValidator -V -S frag shaders/sky.f.glsl -o shaders/spirv/sky.f.spv
+glslangValidator -V -S vert shaders/default.v.glsl -o shaders/spirv/default.v.spirv
+glslangValidator -V -S frag shaders/default.f.glsl -o shaders/spirv/default.f.spirv
+glslangValidator -V -S vert shaders/morphing.v.glsl -o shaders/spirv/morphing.v.spirv
+glslangValidator -V -S frag shaders/morphing.f.glsl -o shaders/spirv/morphing.f.spirv
+glslangValidator -V -S vert shaders/sky.v.glsl -o shaders/spirv/sky.v.spirv
+glslangValidator -V -S frag shaders/sky.f.glsl -o shaders/spirv/sky.f.spirv
#version 450
#define MATRIX_UNIFORMS 0
-#define MORPHING_UNIFORMS 3
+#define MORPHING_MATRIX_UNIFORMS 3
layout(std140, binding = MATRIX_UNIFORMS) uniform vu {
mat4 mview;
uniform mat4 mmod;
} m;
-layout(std140, binding = MORPHING_UNIFORMS) uniform mvu {
+layout(std140, binding = MORPHING_MATRIX_UNIFORMS) uniform mvu {
float t;
} time;
static float fog_density;
-static int num_cows = 400;
+static int num_cows = 1;
static float cow_gap = 4;
static Scene *cow_scene;
static MorphRenderer *cow_rend;
return false;
}
- p.xsz = 200;
- p.ysz = 200;
- p.max_height = 30;
- p.xtiles = 40;
- p.ytiles = 40;
+ p.xsz = 20;//200;
+ p.ysz = 20; //200;
+ p.max_height = 3;//30;
+ p.xtiles = 4;//40;
+ p.ytiles = 4;//40;
p.tile_usub = 10;
p.tile_vsub = 10;
p.num_octaves = 3;
for(size_t i=0; i<scene->objects.size(); i++) {
mu.t = (sin(time_sec + 7.3 * noise(i * M_PI)) + 1) * 0.5;
mbuf->update(&mu);
- mbuf->bind(MORPHING_UNIFORMS);
+ mbuf->bind(MORPHING_MATRIX_UNIFORMS);
vu.mmod = scene->objects[i]->transform.upper3x3();
vbuf->update(&vu);
private:
unsigned int tex;
unsigned int target;
-
+
virtual void update() override;
public:
TextureGL();
glBindBufferBase(GL_UNIFORM_BUFFER, binding, ubo);
}
-void UniformBufferGL::update(void *data)
+bool UniformBufferGL::update(void *data)
{
glBindBuffer(GL_UNIFORM_BUFFER, ubo);
glBufferSubData(GL_UNIFORM_BUFFER, 0, size, data);
+
+ return true;
}
virtual void destroy() override;
virtual void bind(int binding) const override;
- virtual void update(void *data) override;
+ virtual bool update(void *data) override;
};
#endif // UNIFORMS_GL_H_
// fprintf(stderr, "Failed to load debug shaders.\n");
// }
- if(!(sprog = sdr_man->create_shader_program("default.v.glsl", "default.f.glsl"))) {
- return false;
- }
-
vbuf = gfx_create_uniform_buffer();
if(!vbuf->create(sizeof vu)) {
fprintf(stderr, "Failed to create uniform buffer.\n");
return false;
}
+ if(!(sprog = sdr_man->create_shader_program("default.v.glsl", "default.f.glsl"))) {
+ return false;
+ }
+
return true;
}
MATRIX_UNIFORMS = 0,
SHADING_UNIFORMS = 1,
SKY_MATRIX_UNIFORMS = 2,
- MORPHING_UNIFORMS = 3,
+ MORPHING_MATRIX_UNIFORMS = 3,
MORPHING_SHADING_UNIFORMS = 4,
};
-struct BaseVertUniforms {
+struct BaseMatrixUniforms {
Mat4 mview;
Mat4 mmviewproj;
Mat4 mmod;
};
-struct BaseFragUniforms {
+struct BaseShadingUniforms {
Vec4 diffuse;
Vec4 specular;
float shininess;
float fog_density;
};
-struct SkyVertUniforms {
+struct SkyMatrixUniforms {
Mat4 mviewproj;
};
class Renderer {
protected:
- BaseVertUniforms vu;
+ BaseMatrixUniforms vu;
UniformBuffer *vbuf;
- BaseFragUniforms fu;
+ BaseShadingUniforms fu;
UniformBuffer *fbuf;
- SkyVertUniforms svu;
+ SkyMatrixUniforms svu;
UniformBuffer *svbuf;
ShaderProgram *sprog;
#include <assert.h>
#include <stdio.h>
+
#include "shader.h"
Shader::Shader() {}
type = SDR_UNKNOWN;
}
-bool Shader::load(const char *fname, SType type)
+bool Shader::load(const char *fname, ShaderType type)
{
switch(type) {
case SDR_VERTEX:
return create(buf, fsz, fname);
}
-SType Shader::get_type()
+ShaderType Shader::get_type()
{
return type;
}
#include <gmath/gmath.h>
-/*
- Shader class
-*/
+class Texture;
-enum SType {
+enum ShaderType {
SDR_UNKNOWN,
SDR_VERTEX,
SDR_FRAGMENT
class Shader {
protected:
- SType type;
+ ShaderType type;
std::string name;
virtual bool create(char *buf, unsigned int bsz, const char *fname) = 0;
public:
-
Shader();
virtual ~Shader() = 0;
- virtual bool load(const char *fname, SType type);
+ virtual bool load(const char *fname, ShaderType type);
virtual void destroy() = 0;
- virtual SType get_type();
+ virtual ShaderType get_type();
};
/* Shader Program */
shaders[name] = sdr;
}
-Shader *ShaderManager::load_shader(const char *name, SType type)
+Shader *ShaderManager::load_shader(const char *name, ShaderType type)
{
std::map<std::string, Shader *>::const_iterator it;
it = shaders.find(name);
~ShaderManager();
void add_shader(Shader *sdr, const char *name);
- Shader *load_shader(const char *name, SType type);
+ Shader *load_shader(const char *name, ShaderType type);
void delete_shaders();
ShaderProgram *create_shader_program(const char *vname, const char *fname);
void set_path(const char *path);
};
-#endif // SHADER_MANAGER_H_
\ No newline at end of file
+#endif // SHADER_MANAGER_H_
virtual void destroy() = 0;
virtual void bind(int binding) const = 0;
- virtual void update(void *data) = 0;
+ virtual bool update(void *data) = 0;
};
#endif // UNIFORMS_H_
bool MeshVK::update_vertex_data()
{
+ return true;
if(vertices.empty()) {
printf("empty vertices!\n");
return false;
--- /dev/null
+#include <vulkan/vulkan.h>
+
+#include "renderer-vk.h"
+#include "uniforms.h"
+
+RendererVK::RendererVK()
+{
+ scene = 0;
+ camera = 0;
+ sprog = 0;
+
+ skytex = 0;
+ dskytex = 0;
+
+ fog_density = 0;
+ vbuf = fbuf = svbuf = 0;
+}
+
+RendererVK::~RendererVK()
+{
+ delete vbuf;
+ delete fbuf;
+ delete svbuf;
+}
+
+bool RendererVK::create()
+{
+ if(!create_default_pipeline()) {
+ fprintf(stderr, "Failed to create default 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;
+}
--- /dev/null
+#ifndef RENDERER_VK_H_
+#define RENDERER_VK_H_
+
+#include <vulkan/vulkan.h>
+#include "renderer.h"
+
+class RendererVK : public Renderer {
+private:
+ bool create_default_pipeline();
+public:
+ RendererVK();
+ ~RendererVK();
+
+ bool create() override;
+
+};
+
+#endif // RENDERER_VK_H_
destroy();
}
-bool ShaderVK::load(const char *fname, SType type)
+bool ShaderVK::load(const char *fname, ShaderType type)
{
char *vk_fname = new char[strlen(fname) + strlen(".spirv") + 1];
strcpy(vk_fname, fname);
sminf.codeSize = bsz;
sminf.pCode = (uint32_t *)buf;
- if(vkCreateShaderModule(vk_device, &sminf, 0, &sm) != VK_SUCCESS) {
+ if(vkCreateShaderModule(vk_device, &sminf, 0, &sdr) != VK_SUCCESS) {
delete [] buf;
fprintf(stderr, "Failed to create vertex shader module.\n");
void ShaderVK::destroy()
{
- vkDestroyShaderModule(vk_device, sm, 0);
+ vkDestroyShaderModule(vk_device, sdr, 0);
}
ShaderProgramVK::ShaderProgramVK()
ShaderProgramVK::~ShaderProgramVK()
{
+ destroy();
}
bool ShaderProgramVK::create()
{
- /* pipeline cache */
- VkPipelineCacheCreateInfo pcinf;
- memset(&pcinf, 0, sizeof pcinf);
- pcinf.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-
- VkPipelineCache pcache;
- if(!vkCreatePipelineCache(vk_device, &pcinf, 0, &pcache) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create pipeline cache.\n");
- return false;
- }
-
- /* pipeline */
- VkGraphicsPipelineCreateInfo gpinf;
- memset(&gpinf, 0, sizeof gpinf);
- gpinf.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
- gpinf.stageCount = 2;
-
- VkPipelineShaderStageCreateInfo ssinf[2];
- for(int i=0; i<2; i++) {
- memset(&ssinf[i], 0, sizeof ssinf[i]);
- ssinf[i].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
-
- switch(shaders[i]->get_type()) {
- case SDR_VERTEX:
- ssinf[i].stage = VK_SHADER_STAGE_VERTEX_BIT;
- break;
- case SDR_FRAGMENT:
- ssinf[i].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
- break;
- default:
- fprintf(stderr, "Failed to create graphics pipeline: Invalid shader type.\n");
- return false;
- }
- ssinf[i].module = ((ShaderVK *)shaders[i])->sm;
- }
-
- gpinf.pStages = ssinf;
-
+
return true;
}
void ShaderProgramVK::destroy()
{
+ int len = sizeof shaders / sizeof *shaders;
+
+ for(int i=0; i<len; ++i) {
+ delete shaders[i];
+ }
+
}
void ShaderProgramVK::attach_shader(Shader *shader)
* must have the cull, zbuffer etc since they can't be dynamic states */
class ShaderVK : public Shader {
+private:
+ VkShaderModule sdr;
+
protected:
- SType type;
+ ShaderType type;
std::string name;
virtual bool create(char *buf, unsigned int bsz, const char *fname) override;
public:
- VkShaderModule sm;
ShaderVK();
virtual ~ShaderVK();
- virtual bool load(const char *fname, SType type) override;
+ virtual bool load(const char *fname, ShaderType type) override;
virtual void destroy() override;
};
class ShaderProgramVK : public ShaderProgram
{
-private:
- VkPipeline gpipeline;
-
protected:
+ VkPipeline gpipeline;
public:
ShaderProgramVK();
+#include <stdio.h>
+#include <string.h>
+
#include "uniforms-vk.h"
UniformBufferVK::UniformBufferVK()
{
+ ubo = 0;
}
UniformBufferVK::~UniformBufferVK()
bool UniformBufferVK::create(int size)
{
- return true;
+ if(!(ubo = vku_create_buffer(size, VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT))) {
+ fprintf(stderr, "Failed to create uniform buffer object.\n");
+ return false;
+ }
+
+ return UniformBuffer::create(size);
}
void UniformBufferVK::destroy()
{
+ vku_destroy_buffer(ubo);
}
void UniformBufferVK::bind(int binding) const
{
+ if(vkBindBufferMemory(vk_device, ubo->buf, ubo->mem_pool, 0) !=
+ VK_SUCCESS) {
+ fprintf(stderr, "Failed to bind ubo.\n");
+ }
}
-void UniformBufferVK::update(void *data)
+bool UniformBufferVK::update(void *data)
{
+ if(!vku_update_buffer(ubo, size, data)) {
+ fprintf(stderr, "Failed to update ubo.\n");
+ return false;
+ }
+ return true;
}
#ifndef UNIFORMS_VK_H_
#define UNIFORMS_VK_H_
+#include <vulkan/vulkan.h>
#include "uniforms.h"
+#include "vkutil.h"
class UniformBufferVK : public UniformBuffer {
+private:
+ vku_buffer *ubo;
+ VkDescriptorSet dset;
+
public:
UniformBufferVK();
virtual ~UniformBufferVK();
virtual void destroy() override;
virtual void bind(int binding) const override;
- virtual void update(void *data) override;
+ virtual bool update(void *data) override;
};
#endif //UNIFORMS_VK_H_
static uint32_t curr_img; // current sc image
static VkSemaphore psema;
-
/* static variables */
static Vec4 clear_color(1, 0.1, 0.1, 1.0);
static bool create_zbuffer();
static bool create_renderpass();
static bool create_framebuffers();
-static bool create_pipelines();
static bool begin_init_command_buffer(VkCommandBuffer *cb);
static bool end_init_command_buffer(VkCommandBuffer *cb);
static bool allocate_rendering_command_buffers(VkCommandBuffer *bufs);
return false;
}
- if(!glfwGetPhysicalDevicePresentationSupport(vkinst, vk_physical, vkqfamily)) {
+ if(!glfwGetPhysicalDevicePresentationSupport(vk_instance, vk_physical, vk_qfamily)) {
fprintf(stderr, "Presentation support not found.\n");
return false;
}
return false;
}
- VkResult res = glfwCreateWindowSurface(vkinst, win, 0, &vk_surface);
+ VkResult res = glfwCreateWindowSurface(vk_instance, win, 0, &vk_surface);
if(res != VK_SUCCESS) {
fprintf(stderr, "Failed to create KHR surface: %s\n", vku_get_vulkan_error_str(res));
return false;
return false;
}
- if(!create_pipelines()) {
- fprintf(stderr, "Failed to create the pipelines.\n");
- return false;
- }
-
if(!end_init_command_buffer(&init_buf)) {
fprintf(stderr, "Failed to end the command buffer.\n");
return false;
return true;
}
-static bool create_pipelines()
-{
- VkDescriptorSetLayoutBinding dslb[1];
- memset(&dslb[0], 0, sizeof dslb[0]);
- dslb[0].binding = 0;
- dslb[0].descriptorType = VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER;
- dslb[0].descriptorCount = 1;
- dslb[0].stageFlags = VK_SHADER_STAGE_VERTEX_BIT;
-
- VkDescriptorSetLayoutCreateInfo dslinf;
- memset(&dslinf, 0, sizeof dslinf);
- dslinf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
- dslinf.bindingCount = 1; //dslb.size();
- dslinf.pBindings = dslb;
-
- VkDescriptorSetLayout dsl;
- if(vkCreateDescriptorSetLayout(vk_device, &dslinf, 0, &dsl) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create descriptor set layout.\n");
- return false;
- }
-
- VkPipelineLayoutCreateInfo pinf;
- memset(&pinf, 0, sizeof pinf);
- pinf.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
- pinf.setLayoutCount = 1;
- pinf.pSetLayouts = &dsl;
-
- VkPipelineLayout pl;
- if(vkCreatePipelineLayout(vk_device, &pinf, 0, &pl) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create pipeline layout.\n");
- return false;
- }
-
- VkPipelineCacheCreateInfo pcinf;
- memset(&pcinf, 0, sizeof pcinf);
- pcinf.sType = VK_STRUCTURE_TYPE_PIPELINE_CACHE_CREATE_INFO;
-
- VkPipelineCache pcache;
- if(vkCreatePipelineCache(vk_device, &pcinf, 0, &pcache) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create pipeline cache.\n");
- return false;
- }
-
- VkGraphicsPipelineCreateInfo ginf;
- memset(&ginf, 0, sizeof ginf);
- ginf.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
- ginf.stageCount = 2;
-
- return true;
-}
-
static bool end_init_command_buffer(VkCommandBuffer *cb)
{
if(vkEndCommandBuffer(*cb) != VK_SUCCESS) {
/* global variables */
VkPhysicalDevice vk_physical;
VkDevice vk_device;
-VkCommandPool vk_pool;
+VkInstance vk_instance;
VkQueue vk_queue;
+int vk_qfamily;
+VkCommandPool vk_pool;
VkSurfaceKHR vk_surface;
VkSwapchainKHR vk_swapchain;
-
-VkPipeline *vkgparent_pipeline;
-VkFramebuffer *vkfbufs;
-VkRenderPass vkrpass;
-VkInstance vkinst;
-VkCommandBuffer vkcmdbuf; /* primary command buffer */
-int vkqfamily;
-
-VkSemaphore vk_img_avail_sema;
-VkSemaphore vk_rend_done_sema;
-VkImage *vkswapchain_images;
-VkImageView *vkswapchain_views;
-int vknum_swapchain_images;
-int vk_curr_swapchain_image;
+VkDescriptorPool vk_dpool;
/* static functions */
static const char *get_device_name_str(VkPhysicalDeviceType type);
inst_info.ppEnabledExtensionNames = ext_names;
inst_info.enabledExtensionCount = sizeof ext_names / sizeof *ext_names;
- if(vkCreateInstance(&inst_info, 0, &vkinst) != 0) {
+ if(vkCreateInstance(&inst_info, 0, &vk_instance) != 0) {
fprintf(stderr, "failed to create vulkan instance\n");
return false;
}
printf("created vulkan instance\n");
- if(vkEnumeratePhysicalDevices(vkinst, &num_devices, 0) != 0) {
+ if(vkEnumeratePhysicalDevices(vk_instance, &num_devices, 0) != 0) {
fprintf(stderr, "failed to enumerate vulkan physical devices\n");
return false;
}
phys_devices = new VkPhysicalDevice[num_devices];
- if(vkEnumeratePhysicalDevices(vkinst, &num_devices, phys_devices) != 0) {
+ if(vkEnumeratePhysicalDevices(vk_instance, &num_devices, phys_devices) != 0) {
fprintf(stderr, "failed to enumerate vulkan physical devices\n");
return false;
}
printf("created device %d\n", sel_dev);
vk_physical = phys_devices[sel_dev];
- vkqfamily = sel_qfamily;
+ vk_qfamily = sel_qfamily;
vkGetDeviceQueue(vk_device, sel_qfamily, 0, &vk_queue);
void vku_cleanup()
{
- if(vkinst) {
+ if(vk_instance) {
vkDeviceWaitIdle(vk_device);
vkDestroyCommandPool(vk_device, vk_pool, 0);
- vkDestroySemaphore(vk_device, vk_img_avail_sema, 0);
- vkDestroySemaphore(vk_device, vk_rend_done_sema, 0);
-
vkDestroyDevice(vk_device, 0);
- vkDestroyInstance(vkinst, 0);
- vkinst = 0;
+ vkDestroyInstance(vk_instance, 0);
+ vk_instance = 0;
}
delete [] phys_devices;
phys_devices = 0;
}
-bool vku_create_semaphores()
-{
- VkSemaphoreCreateInfo sinf;
- memset(&sinf, 0, sizeof sinf);
-
- sinf.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
- if(vkCreateSemaphore(vk_device, &sinf, 0, &vk_img_avail_sema) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create semaphore\n");
- return false;
- }
-
- if(vkCreateSemaphore(vk_device, &sinf, 0, &vk_rend_done_sema) != VK_SUCCESS) {
- fprintf(stderr, "Failed to create semaphore\n");
- return false;
- }
-
- return true;
-}
-
VkCommandBuffer vku_alloc_cmdbuf(VkCommandPool pool, VkCommandBufferLevel level)
{
VkCommandBuffer cmdbuf;
}
}
+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) {
+ fprintf(stderr, "Failed to map memory.\n");
+ return false;
+ }
+ memcpy(pdata, data, size);
+ vkUnmapMemory(vk_device, buf->mem_pool);
+
+ return true;
+}
+
void vku_cmd_copybuf(VkCommandBuffer cmdbuf, VkBuffer dest, int doffs,
VkBuffer src, int soffs, int size)
{
sprintf(str, "%ld.%ld %s", sz / 10, sz % 10, unitstr[uidx]);
return str;
}
+
+vku_descriptor *vku_create_descriptor(VkDescriptorType type,
+ VkFlags stage, int binding_point,
+ int size, int num_desc)
+{
+ vku_descriptor *desc = new vku_descriptor;
+
+ desc->type = type;
+ desc->size = size;
+ desc->stage_flags = stage;
+ desc->binding_point = binding_point;
+
+ VkDescriptorSetLayoutBinding dslb;
+ memset(&dslb, 0, sizeof dslb);
+
+ dslb.binding = binding_point;
+ dslb.descriptorType = type;
+ dslb.descriptorCount = num_desc;
+ dslb.stageFlags = stage;
+
+ VkDescriptorSetLayoutCreateInfo dslinf;
+ memset(&dslinf, 0, sizeof dslinf);
+
+ dslinf.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
+ dslinf.bindingCount = 1;
+ dslinf.pBindings = &dslb;
+
+ if(vkCreateDescriptorSetLayout(vk_device, &dslinf, 0, &desc->layout) != VK_SUCCESS) {
+ fprintf(stderr, "Failed to create vku_descriptor.\n");
+ return 0;
+ }
+
+ return desc;
+}
+
+void vku_destroy_descriptor(vku_descriptor *desc)
+{
+ vkDestroyDescriptorSetLayout(vk_device, desc->layout, 0);
+ delete desc;
+}
+
+bool vku_create_descriptor_pool(vku_descriptor **descriptors, int num_desc)
+{
+ if(vk_dpool)
+ vkDestroyDescriptorPool(vk_device, vk_dpool, 0);
+
+ VkDescriptorPoolCreateInfo dpinf;
+ memset(&dpinf, 0, sizeof dpinf);
+ dpinf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_POOL_CREATE_INFO;
+ dpinf.maxSets = 1;
+
+ dpinf.poolSizeCount = num_desc;
+
+ std::vector<VkDescriptorPoolSize> sizes;
+ for(int i=0; i<num_desc; i++) {
+ VkDescriptorPoolSize psz;
+ psz.type = descriptors[i]->type;
+ psz.descriptorCount = 1;
+ sizes.push_back(psz);
+ }
+
+ dpinf.pPoolSizes = sizes.data();
+
+ if(vkCreateDescriptorPool(vk_device, &dpinf, 0, &vk_dpool) != VK_SUCCESS) {
+ fprintf(stderr, "Failed to create descriptor pool.\n");
+ return false;
+ }
+
+ return true;
+}
+
+void vku_destroy_descriptor_pool()
+{
+ vkDestroyDescriptorPool(vk_device, vk_dpool, 0);
+}
+
+bool vku_allocate_descriptor_sets(vku_descriptor **desc, int num_desc, VkDescriptorSet set)
+{
+ VkDescriptorSetAllocateInfo dainf;
+ memset(&dainf, 0, sizeof dainf);
+
+ dainf.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO;
+ dainf.descriptorPool = vk_dpool;
+ dainf.descriptorSetCount = num_desc;
+
+ std::vector<VkDescriptorSetLayout> layouts;
+ for(int i=0; i<num_desc; i++) {
+ layouts.push_back(desc[i]->layout);
+ }
+
+ dainf.pSetLayouts = layouts.data();
+
+ if(vkAllocateDescriptorSets(vk_device, &dainf, &set) != VK_SUCCESS) {
+ fprintf(stderr, "Failed to allocate descriptor sets.\n");
+ return false;
+ }
+ return true;
+}
+
+void vku_free_descriptor_sets(VkDescriptorSet *sets, int num)
+{
+ vkFreeDescriptorSets(vk_device, vk_dpool, num, sets);
+}
+
+
extern VkQueue vk_queue;
extern VkSwapchainKHR vk_swapchain;
extern VkSurfaceKHR vk_surface;
-
-extern VkPipeline *vkgparent_pipeline;
-extern VkDescriptorSet *vkdescset;
-extern VkFramebuffer *vkfbufs;
-extern VkRenderPass vkrpass;
-extern VkInstance vkinst;
-extern VkCommandBuffer vkcmdbuf; /* primary command buffer */
-extern int vkqfamily;
-
-/* presentation */
-extern int vknum_swapchain_images;
-extern VkImage *vkswapchain_images;
-extern VkImageView *vkswapchain_views;
-extern int vk_curr_swapchain_image;
-extern VkSemaphore vk_img_avail_sema;
-extern VkSemaphore vk_rend_done_sema;
+extern VkInstance vk_instance;
+extern int vk_qfamily;
+extern VkDescriptorPool vk_dpool;
struct vku_buffer {
VkBuffer buf;
int mem_start, mem_size;
};
+struct vku_descriptor {
+ VkDescriptorSetLayout layout;
+ VkDescriptorType type;
+ VkFlags stage_flags;
+ int binding_point;
+ int size;
+};
+
/* extensions */
bool vku_have_extension(const char *name);
bool vku_have_device_extension(const char *name);
bool vku_create_device();
void vku_cleanup();
-/* semaphores */
-bool vku_create_semaphores();
-
/* command buffers */
VkCommandBuffer vku_alloc_cmdbuf(VkCommandPool pool, VkCommandBufferLevel level);
bool vku_alloc_cmdbufs(VkCommandPool pool, VkCommandBufferLevel level, unsigned int count, VkCommandBuffer *buf_array);
/* buffers */
vku_buffer *vku_create_buffer(int sz, unsigned int usage);
void vku_destroy_buffer(vku_buffer *buf);
+bool vku_update_buffer(vku_buffer *buf, int size, void *data);
+
void vku_cmd_copybuf(VkCommandBuffer cmdbuf, VkBuffer dest, int doffs,
VkBuffer src, int soffs, int size);
/* other */
const char *vku_get_vulkan_error_str(VkResult error);
+/* pipelines */
+vku_descriptor *vku_create_descriptor(VkDescriptorType type, VkFlags stage,
+ int binding_point, int size);
+void vku_destroy_descriptor(vku_descriptor *descriptor);
+
+bool vku_create_descriptor_pool(vku_descriptor **descriptors, int num_desc, VkDescriptorSet set);
+void vku_destroy_descriptor_pool();
#endif // VKUTIL_H_
projects / demo / commitdiff