Renderer API reference

API Reference

namespace Renderer

Typedefs

using Vortex2D::Renderer::DescriptorTypeBindings = typedef std::map<uint32_t, vk::DescriptorType>
typedef std::vector<glm::vec2> Path

Functions

VORTEX2D_API void Vortex2D::Renderer::BufferBarrier(vk::Buffer buffer, vk::CommandBuffer commandBuffer, vk::AccessFlags oldAccess, vk::AccessFlags newAccess)

Inserts a barrier for the given buffer, command buffer and access.

Parameters
  • buffer: the vulkan buffer handle
  • commandBuffer: the command buffer to inserts the barrier
  • oldAccess: old access
  • newAccess: new access

template <template< typename > class BufferType, typename T>
void CopyTo(BufferType<T> &buffer, T &t)

Copy the content of a buffer in an object.

template <template< typename > class BufferType, typename T>
void CopyTo(BufferType<T> &buffer, std::vector<T> &t)

Copy the content of a buffer to a vector. Vector needs to have the correct size already.

template <template< typename > class BufferType, typename T>
void CopyFrom(BufferType<T> &buffer, const T &t)

Copy the content of an object to the buffer.

template <template< typename > class BufferType, typename T>
void CopyFrom(BufferType<T> &buffer, const std::vector<T> &t)

Copy the content of a vector to the buffer.

bool operator==(const ShaderLayout &left, const ShaderLayout &right)
bool operator==(const PipelineLayout &left, const PipelineLayout &right)
vk::DescriptorType GetDescriptorType(uint32_t bind, const PipelineLayout &layout)
VORTEX2D_API void Vortex2D::Renderer::Bind(const Device & device, DescriptorSet & dstSet, const PipelineLayout & layout, const std::vector< BindingInput > & bindingInputs)

Bind the resources (buffer or texture/sampler) to a DescriptorSet.

Parameters
  • device: vulkan device
  • dstSet: vulkan descriptor set
  • layout: pipeline layout
  • bindingInputs: list of resources (buffer or texture/sampler)

bool HasLayer(const char *extension, const std::vector<vk::LayerProperties> &availableExtensions)
bool HasExtension(const char *extension, const std::vector<vk::ExtensionProperties> &availableExtensions)
VORTEX2D_API vk::UniquePipeline Vortex2D::Renderer::MakeComputePipeline(vk::Device device, vk::ShaderModule shader, vk::PipelineLayout layout, SpecConstInfo specConstInfo = {})

Create a compute pipeline.

Return
compute pipeline
Parameters
  • device: vulkan device
  • shader: shader module
  • layout: layout of shader
  • specConstInfo: any specialisation constants

template <typename Type>
SpecConstInfo::Value<Type> SpecConstValue(uint32_t id, Type &&value)

Constructs a specialization constant value.

template <typename... Args>
SpecConstInfo SpecConst(Args&&... args)

Constructs a SpecConstInfo with given values of specialisation constants.

bool operator==(const RenderState &left, const RenderState right)
VORTEX2D_API vk::DeviceSize Vortex2D::Renderer::GetBytesPerPixel(vk::Format format)

Gets the number of bytes per pixel given the format.

Return
bytes per pixel
Parameters
  • format: of texture

VORTEX2D_API ComputeSize Vortex2D::Renderer::MakeStencilComputeSize(const glm::ivec2 & size, int radius)

Create a ComputeSize for a stencil type shader.

Return
calculate ComputeSize
Parameters
  • size: the domain size
  • radius: the stencil size

VORTEX2D_API ComputeSize Vortex2D::Renderer::MakeCheckerboardComputeSize(const glm::ivec2 & size)

Create a ComputeSize for a checkerboard type shader.

Return
calculate ComputeSize
Parameters
  • size: the domain size

class AbstractShape : public Vortex2D::Renderer::Shape
#include <Shapes.h>

An polygonal shape where the fragment shader can be specified for customisation.

Subclassed by Vortex2D::Renderer::IntRectangle, Vortex2D::Renderer::Rectangle

Public Functions

AbstractShape(const Device &device, const SpirvBinary &fragShader, const std::vector<glm::vec2> &vertices)
AbstractShape(AbstractShape &&other)
~AbstractShape()
void Initialize(const RenderState &renderState)

Initialize the drawable for a particular state. This might include creating the correct pipeline. If it was already initialized, it will do nothing.

Parameters
  • renderState: the state to initialize with.

void Update(const glm::mat4 &projection, const glm::mat4 &view)

Update the MVP matrix of the drawable.

Parameters
  • projection: the projection matrix
  • view: the view matrix

void Draw(vk::CommandBuffer commandBuffer, const RenderState &renderState)

Draw for the given render state. This has to be initialized before.

Parameters
  • commandBuffer: the command buffer to record into.
  • renderState: the render state to use.

class AbstractSprite : public Vortex2D::Renderer::Drawable, public Vortex2D::Renderer::Transformable
#include <Sprite.h>

a Sprite, i.e. a drawable that can render a texture. The fragment shader can be specified for customisation.

Subclassed by Vortex2D::Fluid::DistanceField, Vortex2D::Renderer::Sprite

Public Functions

AbstractSprite(const Device &device, const SpirvBinary &fragShaderName, Texture &texture)
AbstractSprite(AbstractSprite &&other)
~AbstractSprite()
void Initialize(const RenderState &renderState)

Initialize the drawable for a particular state. This might include creating the correct pipeline. If it was already initialized, it will do nothing.

Parameters
  • renderState: the state to initialize with.

void Update(const glm::mat4 &projection, const glm::mat4 &view)

Update the MVP matrix of the drawable.

Parameters
  • projection: the projection matrix
  • view: the view matrix

void Draw(vk::CommandBuffer commandBuffer, const RenderState &renderState)

Draw for the given render state. This has to be initialized before.

Parameters
  • commandBuffer: the command buffer to record into.
  • renderState: the render state to use.

template <typename T>
void PushConstant(vk::CommandBuffer commandBuffer, uint32_t offset, const T &data)

Public Members

glm::vec4 Colour = {1.0f, 1.0f, 1.0f, 1.0f}
struct BindingInput
#include <DescriptorSet.h>

The texture/sampler or buffer that can be binded to a shader.

Public Functions

BindingInput(Renderer::GenericBuffer &buffer, uint32_t bind = DefaultBind)
BindingInput(Renderer::Texture &texture, uint32_t bind = DefaultBind)
BindingInput(vk::Sampler sampler, Renderer::Texture &texture, uint32_t bind = DefaultBind)

Public Members

uint32_t Bind
mapbox::util::variant<Renderer::GenericBuffer *, DescriptorImage> Input

Public Static Attributes

constexpr uint32_t DefaultBind = static_cast<uint32_t>(-1)
template <typename T>
class Buffer : public Vortex2D::Renderer::GenericBuffer
#include <Buffer.h>

a storage buffer type of buffer

Public Functions

Buffer(const Device &device, std::size_t size = 1, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
class Clear : public Vortex2D::Renderer::Drawable
#include <Shapes.h>

A drawable that simply clears the target.

Public Functions

Clear(const glm::vec4 &colour)
~Clear()
void Initialize(const RenderState &renderState)

Initialize the drawable for a particular state. This might include creating the correct pipeline. If it was already initialized, it will do nothing.

Parameters
  • renderState: the state to initialize with.

void Update(const glm::mat4 &projection, const glm::mat4 &view)

Update the MVP matrix of the drawable.

Parameters
  • projection: the projection matrix
  • view: the view matrix

void Draw(vk::CommandBuffer commandBuffer, const RenderState &renderState)

Draw for the given render state. This has to be initialized before.

Parameters
  • commandBuffer: the command buffer to record into.
  • renderState: the render state to use.

struct ColorBlendState
#include <RenderState.h>

The blend state and blend constant.

Public Functions

ColorBlendState()

Public Members

vk::PipelineColorBlendAttachmentState ColorBlend
std::array<float, 4> BlendConstants
class CommandBuffer
#include <CommandBuffer.h>

Can record commands, then submit them (multiple times). A fence can used to wait on the completion of the commands.

Public Types

using CommandFn = std::function<void(vk::CommandBuffer)>

Public Functions

CommandBuffer(const Device &device, bool synchronise = true)

Creates a command buffer which can be synchronized.

Parameters
  • device: vulkan device
  • synchronise: flag to determine if the command buffer can be waited on.

~CommandBuffer()
CommandBuffer(CommandBuffer &&other)
CommandBuffer &operator=(CommandBuffer &&other)
CommandBuffer &Record(CommandFn commandFn)

Record some commands. The commads are recorded in the lambda which is immediately executed.

Parameters
  • commandFn: a functor, or simply a lambda, where commands are recorded.

CommandBuffer &Record(const RenderTarget &renderTarget, vk::Framebuffer framebuffer, CommandFn commandFn)

Record some commands inside a render pass. The commads are recorded in the lambda which is immediately executed.

Parameters
  • renderTarget: the render target which contains the render pass to record into
  • framebuffer: the frame buffer where the render pass will render.
  • commandFn: a functor, or simply a lambda, where commands are recorded.

CommandBuffer &Wait()

Wait for the command submit to finish. Does nothing if the synchronise flag was false.

CommandBuffer &Reset()

Reset the command buffer so it can be recorded again.

CommandBuffer &Submit(const std::initializer_list<vk::Semaphore> &waitSemaphores = {}, const std::initializer_list<vk::Semaphore> &signalSemaphores = {})

submit the command buffer

operator bool() const

explicit conversion operator to bool, indicates if the command was properly recorded and can be sumitted.

struct ComputeSize
#include <Work.h>

Used for a compute shader, and defines the group size, local size and domain size.

Public Functions

ComputeSize(const glm::ivec2 &size, const glm::ivec2 &localSize = GetLocalSize2D())

Creates a ComputeSize using a 2D domain size and the default 2D local size.

Parameters
  • size: the domain size
  • localSize: the local size of the shader

ComputeSize(int size, int localSize = GetLocalSize1D())

Creates a ComputeSize using a 1D domain size and the default 1D local size.

Parameters
  • size: the domain size
  • localSize: the local size of the shader

Public Members

glm::ivec2 DomainSize
glm::ivec2 WorkSize
glm::ivec2 LocalSize

Public Static Functions

glm::ivec2 GetLocalSize2D()

The default local size for 2D compute shaders.

Return
a 2d vector

int GetLocalSize1D()

The default local size for 1D compute shaders.

Return
a integer value

glm::ivec2 GetWorkSize(const glm::ivec2 &size, const glm::ivec2 &localSize = GetLocalSize2D())

Computes the 2D group size given a domain size.

Return
the group size
Parameters
  • size: the domain size of the shader
  • localSize: the local size of the shader

glm::ivec2 GetWorkSize(int size, int localSize = GetLocalSize1D())

Computes the 1D group size given a domain size.

Return
the group size
Parameters
  • size: the domain size of the shader
  • localSize: the local size of the shader

ComputeSize Default2D()

A default ComputeSize using the default 2D local size. The domain size is (1,1)

Return
a default compute size

ComputeSize Default1D()

A default ComputeSize using the default 1D local size. The domain size is (1,1)

Return
a default compute size

struct DescriptorImage
#include <DescriptorSet.h>

The texture or sampler that can be binded to a shader.

Public Functions

DescriptorImage(vk::Sampler sampler, Renderer::Texture &texture)
DescriptorImage(Renderer::Texture &texture)

Public Members

vk::Sampler Sampler
Renderer::Texture *Texture
struct DescriptorSet
#include <DescriptorSet.h>

The binding of an object for a shader.

Public Members

vk::UniqueDescriptorSet descriptorSet
vk::PipelineLayout pipelineLayout
vk::DescriptorSetLayout descriptorSetLayout
class Device
#include <Device.h>

Encapsulation around the vulkan device. Allows to create command buffers, layout, bindings, memory and shaders.

Public Functions

Device(vk::PhysicalDevice physicalDevice, bool validation = true)
Device(vk::PhysicalDevice physicalDevice, vk::SurfaceKHR surface, bool validation = true)
Device(vk::PhysicalDevice physicalDevice, int familyIndex, bool validation = true)
~Device()
Device(Device&&)
Device &operator=(Device&&)
vk::Device Handle() const
vk::Queue Queue() const
vk::PhysicalDevice GetPhysicalDevice() const
int GetFamilyIndex() const
vk::CommandBuffer CreateCommandBuffer() const
void FreeCommandBuffer(vk::CommandBuffer commandBuffer) const
void Execute(CommandBuffer::CommandFn commandFn) const
VmaAllocator Allocator() const
LayoutManager &GetLayoutManager() const
vk::ShaderModule GetShaderModule(const SpirvBinary &spirv) const
struct DispatchParams
#include <Work.h>

Parameters for indirect compute: group size, local size, etc.

Public Functions

DispatchParams(int count)

Public Members

vk::DispatchIndirectCommand workSize
uint32_t count
struct Drawable
#include <Drawable.h>

Interface of a drawable object.

Subclassed by Vortex2D::Fluid::Circle, Vortex2D::Fluid::Polygon, Vortex2D::Renderer::AbstractSprite, Vortex2D::Renderer::Clear, Vortex2D::Renderer::Shape

Public Functions

virtual ~Drawable()
virtual void Initialize(const RenderState &renderState) = 0

Initialize the drawable for a particular state. This might include creating the correct pipeline. If it was already initialized, it will do nothing.

Parameters
  • renderState: the state to initialize with.

virtual void Update(const glm::mat4 &projection, const glm::mat4 &view) = 0

Update the MVP matrix of the drawable.

Parameters
  • projection: the projection matrix
  • view: the view matrix

virtual void Draw(vk::CommandBuffer commandBuffer, const RenderState &renderState) = 0

Draw for the given render state. This has to be initialized before.

Parameters
  • commandBuffer: the command buffer to record into.
  • renderState: the render state to use.

class Ellipse : public Vortex2D::Renderer::Shape
#include <Shapes.h>

A solid colour ellipse. Implements the Drawable interface and Transformable interface.

Public Functions

Ellipse(const Device &device, const glm::vec2 &radius)
~Ellipse()
void Initialize(const RenderState &renderState)

Initialize the drawable for a particular state. This might include creating the correct pipeline. If it was already initialized, it will do nothing.

Parameters
  • renderState: the state to initialize with.

void Update(const glm::mat4 &projection, const glm::mat4 &view)

Update the MVP matrix of the drawable.

Parameters
  • projection: the projection matrix
  • view: the view matrix

void Draw(vk::CommandBuffer commandBuffer, const RenderState &renderState)

Draw for the given render state. This has to be initialized before.

Parameters
  • commandBuffer: the command buffer to record into.
  • renderState: the render state to use.

class GenericBuffer
#include <Buffer.h>

A vulkan buffer which can be on the host or the device.

Subclassed by Vortex2D::Renderer::Buffer< float >, Vortex2D::Renderer::Buffer< glm::ivec2 >, Vortex2D::Renderer::Buffer< glm::vec2 >, Vortex2D::Renderer::Buffer< int >, Vortex2D::Renderer::Buffer< Vortex2D::Fluid::Particle >, Vortex2D::Renderer::Buffer< Vortex2D::Fluid::RigidBody::Velocity >, Vortex2D::Renderer::Buffer< Vortex2D::Renderer::DispatchParams >, Vortex2D::Renderer::IndirectBuffer< Vortex2D::Renderer::DispatchParams >, Vortex2D::Renderer::UniformBuffer< glm::mat4 >, Vortex2D::Renderer::UniformBuffer< glm::vec2 >, Vortex2D::Renderer::UniformBuffer< glm::vec4 >, Vortex2D::Renderer::UniformBuffer< Size >, Vortex2D::Renderer::UniformBuffer< Vortex2D::Fluid::RigidBody::Velocity >, Vortex2D::Renderer::VertexBuffer< glm::vec2 >, Vortex2D::Renderer::VertexBuffer< Vortex2D::Renderer::AbstractSprite::Vertex >, Vortex2D::Renderer::Buffer< T >, Vortex2D::Renderer::IndexBuffer< T >, Vortex2D::Renderer::IndirectBuffer< T >, Vortex2D::Renderer::UniformBuffer< T >, Vortex2D::Renderer::VertexBuffer< T >

Public Functions

GenericBuffer(const Device &device, vk::BufferUsageFlags usageFlags, VmaMemoryUsage memoryUsage, vk::DeviceSize deviceSize)
~GenericBuffer()
GenericBuffer(GenericBuffer &&other)
void CopyFrom(vk::CommandBuffer commandBuffer, GenericBuffer &srcBuffer)

Copy a buffer to this buffer.

Parameters
  • commandBuffer: command buffer to run the copy on.
  • srcBuffer: the source buffer.

void CopyFrom(vk::CommandBuffer commandBuffer, Texture &srcTexture)

Copy a texture to this buffer.

Parameters
  • commandBuffer: command buffer to run the copy on.
  • srcTexture: the source texture

vk::Buffer Handle() const

The vulkan handle.

vk::DeviceSize Size() const

The size in bytes of the buffer.

void Resize(vk::DeviceSize size)

Resize the buffer. Invalidates the buffer handle.

Parameters
  • size: buffer size

void Barrier(vk::CommandBuffer commandBuffer, vk::AccessFlags oldAccess, vk::AccessFlags newAccess)

Inserts a barrier for this buffer.

Parameters
  • commandBuffer: the command buffer to run the barrier
  • oldAccess: old access
  • newAccess: new access

void Clear(vk::CommandBuffer commandBuffer)

Clear the buffer with 0.

Parameters
  • commandBuffer: the command buffer to clear on

void CopyFrom(uint32_t offset, const void *data, uint32_t size)

copy from data to buffer

Parameters
  • offset: in the buffer
  • data: pointer
  • size: of data

void CopyTo(uint32_t offset, void *data, uint32_t size)

copy buffer to data

Parameters
  • offset: in the buffer
  • data: pointer
  • size: of data

class GraphicsPipeline
#include <Pipeline.h>

graphics pipeline which caches the pipeline per render states.

Public Functions

GraphicsPipeline()
GraphicsPipeline(Builder builder)
void Create(vk::Device device, const RenderState &renderState)
void Bind(vk::CommandBuffer commandBuffer, const RenderState &renderState)
class Builder
#include <Pipeline.h>

Builder for graphics pipeline.

Public Functions

Builder()
GraphicsPipeline::Builder &Shader(vk::ShaderModule shader, vk::ShaderStageFlagBits shaderStage)

Set the shader.

Return
*this
Parameters
  • shader: the loaded shader
  • shaderStage: shader state (vertex, fragment or compute)

GraphicsPipeline::Builder &VertexAttribute(uint32_t location, uint32_t binding, vk::Format format, uint32_t offset)

Sets the vertex attributes.

Return
*this
Parameters
  • location: location in the shader
  • binding: binding in the shader
  • format: vertex format
  • offset: offset in the vertex

GraphicsPipeline::Builder &VertexBinding(uint32_t binding, uint32_t stride, vk::VertexInputRate inputRate = vk::VertexInputRate::eVertex)

Sets the vertex binding.

Return
*this
Parameters
  • binding: binding in the shader
  • stride: stride in bytes
  • inputRate: inpute rate

GraphicsPipeline::Builder &Topology(vk::PrimitiveTopology topology)
GraphicsPipeline::Builder &Layout(vk::PipelineLayout pipelineLayout)
GraphicsPipeline::Builder &DynamicState(vk::DynamicState dynamicState)
vk::UniquePipeline Create(vk::Device device, const RenderState &renderState)
template <typename T>
class IndexBuffer : public Vortex2D::Renderer::GenericBuffer
#include <Buffer.h>

a index buffer type of buffer

Public Functions

IndexBuffer(const Device &device, std::size_t size, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
template <typename T>
class IndirectBuffer : public Vortex2D::Renderer::GenericBuffer
#include <Buffer.h>

an indirect buffer type of buffer, used for compute indirect dispatch

Public Functions

IndirectBuffer(const Device &device, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
class Instance
#include <Instance.h>

Vulkan instance, which extensions enabled.

Public Functions

Instance(const std::string &name, std::vector<const char *> extensions, bool validation)
~Instance()
vk::PhysicalDevice GetPhysicalDevice() const
vk::Instance GetInstance() const
class IntRectangle : public Vortex2D::Renderer::AbstractShape
#include <Shapes.h>

A solid colour rectangle as Rectangle, however uses integer colors and is meant to be drawn to a framebuffer wiht integer colours.

Public Functions

IntRectangle(const Device &device, const glm::vec2 &size)
class LayoutManager
#include <DescriptorSet.h>

Caches and creates layouts and bindings.

Public Functions

LayoutManager(const Device &device)
void CreateDescriptorPool()

Create or re-create the descriptor pool, will render invalid existing descriptor sets.

DescriptorSet MakeDescriptorSet(const PipelineLayout &layout)

Create the descriptor set given the layout.

Return
built descriptor set
Parameters
  • layout: pipeline/shader layout

vk::DescriptorSetLayout GetDescriptorSetLayout(const PipelineLayout &layout)

Create, cache and return a descriptor layout given the pipeline layout.

Return
cached descriptor set layout
Parameters
  • layout: pipeline layout

vk::PipelineLayout GetPipelineLayout(const PipelineLayout &layout)

create, cache and return a vulkan pipeline layout given the layout

Return
vulkan pipeline layout
Parameters
  • layout: pipeline layout

struct PipelineLayout
#include <DescriptorSet.h>

Represents the layout of a pipeline: vertex + fragment or compute.

Public Members

std::vector<ShaderLayout> layouts
class Rectangle : public Vortex2D::Renderer::AbstractShape
#include <Shapes.h>

A solid colour rectangle defined by two triangles. Implements the Drawable interface and Transformable interface.

Public Functions

Rectangle(const Device &device, const glm::vec2 &size)
class RenderCommand
#include <CommandBuffer.h>

A special command buffer that has been recorded by a RenderTarget. It can be used to submit the rendering. The object has to stay alive untill rendering is complete.

Public Functions

RenderCommand()
~RenderCommand()
RenderCommand(RenderCommand &&other)
RenderCommand &operator=(RenderCommand &&other)
RenderCommand &Submit(const glm::mat4 &view = glm::mat4(1.0f))

Submit the render command with a transform matrix.

Return
*this
Parameters
  • view: a transform matrix

void Wait()

Wait for the render command to complete.

operator bool() const

explicit conversion operator to bool, indicates if the command was properly recorded and can be sumitted.

Friends

friend Vortex2D::Renderer::RenderTexture
friend Vortex2D::Renderer::RenderWindow
class RenderpassBuilder
#include <RenderTarget.h>

Factory for a vulkan render pass.

Public Functions

RenderpassBuilder &Attachement(vk::Format format)

Format of the render pass.

Return
Parameters
  • format:

RenderpassBuilder &AttachementLoadOp(vk::AttachmentLoadOp value)

operation to perform when loading the framebuffer (clear, load, etc)

Return
Parameters
  • value:

RenderpassBuilder &AttachementStoreOp(vk::AttachmentStoreOp value)

operation to perform when storing the framebuffer (clear, save, etc)

Return
Parameters
  • value:

RenderpassBuilder &AttachementInitialLayout(vk::ImageLayout layout)

Layout of the image to be before render pass.

Return
Parameters
  • layout:

RenderpassBuilder &AttachementFinalLayout(vk::ImageLayout layout)

Layout of the image to be after render pass.

Return
Parameters
  • layout:

RenderpassBuilder &Subpass(vk::PipelineBindPoint bindPoint)

Define subpass of the render pass.

Return
Parameters
  • bindPoint:

RenderpassBuilder &SubpassColorAttachment(vk::ImageLayout layout, uint32_t attachment)

Set the color attachment with index.

Return
Parameters
  • layout:
  • attachment: index of the attachment

RenderpassBuilder &Dependency(uint32_t srcSubpass, uint32_t dstSubpass)

Dependency of the subpasses.

Return
Parameters
  • srcSubpass:
  • dstSubpass:

RenderpassBuilder &DependencySrcStageMask(vk::PipelineStageFlags value)
RenderpassBuilder &DependencyDstStageMask(vk::PipelineStageFlags value)
RenderpassBuilder &DependencySrcAccessMask(vk::AccessFlags value)
RenderpassBuilder &DependencyDstAccessMask(vk::AccessFlags value)
vk::UniqueRenderPass Create(vk::Device device)

Create the render pass.

Return
Parameters
  • device:

struct RenderState
#include <RenderState.h>

the various state to render to a target: size, render pass and blend.

Public Functions

RenderState(const RenderTarget &renderTarget)

Initialize for a render target with default blend.

Parameters
  • renderTarget:

RenderState(const RenderTarget &renderTarget, ColorBlendState blendState)

Initialize for a render target with a given blend.

Parameters
  • renderTarget:
  • colorBlend:

Public Members

uint32_t Width
uint32_t Height
vk::RenderPass RenderPass
ColorBlendState BlendState
struct RenderTarget
#include <RenderTarget.h>

A target that can be rendered to. This is implemented by the RenderWindow and the RenderTexture.

Subclassed by Vortex2D::Renderer::RenderTexture, Vortex2D::Renderer::RenderWindow

Public Types

using DrawableList = std::initializer_list<std::reference_wrapper<Drawable>>

Public Functions

RenderTarget(uint32_t width, uint32_t height)
RenderTarget(RenderTarget &&other)
~RenderTarget()
virtual VORTEX2D_API RenderCommand Vortex2D::Renderer::RenderTarget::Record(DrawableList drawables, ColorBlendState blendState = {}) = 0
virtual VORTEX2D_API void Vortex2D::Renderer::RenderTarget::Submit(RenderCommand & renderCommand) = 0

Public Members

uint32_t Width
uint32_t Height
glm::mat4 Orth
glm::mat4 View
vk::UniqueRenderPass RenderPass
class RenderTexture : public Vortex2D::Renderer::RenderTarget, public Vortex2D::Renderer::Texture
#include <RenderTexture.h>

A render target that renders into a texture.

Subclassed by Vortex2D::Fluid::Density, Vortex2D::Fluid::LevelSet, Vortex2D::Fluid::ParticleCount, Vortex2D::Fluid::Velocity

Public Functions

RenderTexture(const Device &device, uint32_t width, uint32_t height, vk::Format format)
RenderTexture(RenderTexture &&other)
~RenderTexture()
RenderCommand Record(DrawableList drawables, ColorBlendState blendState = {})
void Submit(RenderCommand &renderCommand)
class RenderWindow : public Vortex2D::Renderer::RenderTarget
#include <RenderWindow.h>

Render to a swapchain, i.e. to the window/surface.

Public Functions

RenderWindow(const Device &device, vk::SurfaceKHR surface, uint32_t width, uint32_t height)

Initialize with a given surface and size.

Parameters
  • device: vulkan device
  • surface: vulkan surface
  • width:
  • height:

~RenderWindow()
RenderCommand Record(DrawableList drawables, ColorBlendState blendState = {})
void Submit(RenderCommand &renderCommand)
void Display()

Submits all the render command and present the surface for display.

class SamplerBuilder
#include <Texture.h>

Factory for a vullkan sampler.

Public Functions

SamplerBuilder()
SamplerBuilder &AddressMode(vk::SamplerAddressMode mode)

Mode of the sampler: repeat, clamp, etc.

Return
*this
Parameters
  • mode: vulkan mode

SamplerBuilder &Filter(vk::Filter filter)

Filter of the sampler: linear, nearest, etc.

Return
*this
Parameters
  • filter: vulkan filter

vk::UniqueSampler Create(vk::Device device)

Create the vulkan sampler.

Return
unique sampler
Parameters
  • device: vulkan device

struct ShaderLayout
#include <DescriptorSet.h>

Represents the layout of a shader (vertex, fragment or compute)

Public Functions

ShaderLayout(const SPIRV::Reflection &reflection)

Public Members

vk::ShaderStageFlags shaderStage
DescriptorTypeBindings bindings
unsigned pushConstantSize
class Shape : public Vortex2D::Renderer::Drawable, public Vortex2D::Renderer::Transformable
#include <Shapes.h>

Shape interface which is drawable, transformable and has a color.

Subclassed by Vortex2D::Renderer::AbstractShape, Vortex2D::Renderer::Ellipse

Public Members

glm::vec4 Colour
struct SpecConstInfo
#include <Pipeline.h>

Defines and holds value of the specification constants for shaders.

Public Functions

SpecConstInfo()

Public Members

vk::SpecializationInfo info
std::vector<vk::SpecializationMapEntry> mapEntries
std::vector<char> data
template <typename Type>
struct Value

Public Members

uint32_t id
Type value
class SpirvBinary
#include <Device.h>

A binary SPIRV shader, to be feed to vulkan.

Public Functions

template <std::size_t N>
SpirvBinary(const uint32_t (&spirv)[N])
const uint32_t *data() const
std::size_t size() const
std::size_t words() const
class Sprite : public Vortex2D::Renderer::AbstractSprite
#include <Sprite.h>

A sprite that renders a texture with a simple pass-through fragment shader.

Subclassed by Vortex2D::Fluid::Density

Public Functions

Sprite(const Device &device, Texture &texture)
struct SwapChainSupportDetails

Public Functions

SwapChainSupportDetails(vk::PhysicalDevice device, vk::SurfaceKHR surface)
bool IsValid() const

Public Members

vk::SurfaceCapabilitiesKHR capabilities
std::vector<vk::SurfaceFormatKHR> formats
std::vector<vk::PresentModeKHR> presentModes
class Texture
#include <Texture.h>

A texture, or in vulkan terms, an image.

Subclassed by Vortex2D::Renderer::RenderTexture

Public Functions

Texture(const Device &device, uint32_t width, uint32_t height, vk::Format format, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
Texture(Texture &&other)
~Texture()
template <typename T>
void CopyFrom(const std::vector<T> &data)
template <typename T>
void CopyTo(std::vector<T> &data)
void CopyFrom(const void *data)

Copies width*heigh*bytesPerPixel amount of data.

Parameters
  • data: source data

void CopyTo(void *data)

Copies width*heigh*bytesPerPixel amount of data.

Parameters
  • data: destination data

void CopyFrom(vk::CommandBuffer commandBuffer, Texture &srcImage)
void Barrier(vk::CommandBuffer commandBuffer, vk::ImageLayout oldLayout, vk::AccessFlags oldAccess, vk::ImageLayout newLayout, vk::AccessFlags newAccess)
vk::ImageView GetView() const
uint32_t GetWidth() const
uint32_t GetHeight() const
vk::Format GetFormat() const
void Clear(vk::CommandBuffer commandBuffer, const std::array<int, 4> &colour)
void Clear(vk::CommandBuffer commandBuffer, const std::array<float, 4> &colour)
vk::Image Handle() const

Friends

friend Vortex2D::Renderer::GenericBuffer
class Timer
#include <Timer.h>

Calculates the ellapsed time on the GPU.

Public Functions

Timer(const Device &device)
void Start(vk::CommandBuffer commandBuffer)

Start the timer after the current last command buffer.

Parameters
  • commandBuffer: command buffer to write timestamp

void Stop(vk::CommandBuffer commandBuffer)

Start the timer after the current last command buffer.

Parameters
  • commandBuffer: command buffer to write timestamp

void Start()

Start the timer after the current last command buffer.

void Stop()

Stop the timer after the current last command buffer.

void Wait()

Wait for Start and Stop to finish before retrieving the results.

uint64_t GetElapsedNs()

Get the elapsed time between the Start and Stop calls. Blocking function which will download the timestamps from the GPU.

Return
timestamp in nanoseconds.

struct Transformable
#include <Transformable.h>

Class to represent the transformation of an object: position, scale, rotation and anchor.

Subclassed by Vortex2D::Fluid::Circle, Vortex2D::Fluid::Polygon, Vortex2D::Fluid::RigidBody, Vortex2D::Renderer::AbstractSprite, Vortex2D::Renderer::Shape

Public Functions

Transformable()
virtual ~Transformable()
const glm::mat4 &GetTransform() const

Returns the transform matrix.

void Update()

Update the transormation matrix.

Public Members

glm::vec2 Position

absolute position

glm::vec2 Scale

scale for the x and y components

float Rotation

Rotation in radians.

glm::vec2 Anchor

An offset to the position (used for centering a shape)

template <typename T>
class UniformBuffer : public Vortex2D::Renderer::GenericBuffer
#include <Buffer.h>

a uniform buffer type of buffer

Public Functions

UniformBuffer(const Device &device, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
template <typename T>
class VertexBuffer : public Vortex2D::Renderer::GenericBuffer
#include <Buffer.h>

a vertex buffer type of buffer

Public Functions

VertexBuffer(const Device &device, std::size_t size, VmaMemoryUsage memoryUsage = VMA_MEMORY_USAGE_GPU_ONLY)
class Work
#include <Work.h>

Represents a compute shader. It simplifies the process of binding, setting push constants and recording.

Public Functions

Work(const Device &device, const ComputeSize &computeSize, const SpirvBinary &spirv, const SpecConstInfo &additionalSpecConstInfo = {})

Constructs an object using a SPIRV binary. It is not bound to any buffers or textures.

Parameters
  • device: vulkan device
  • computeSize: the compute size. Can be a default one with size (1,1) or one with an actual size.
  • spirv: binary spirv
  • additionalSpecConstInfo: additional specialization constants

Work::Bound Bind(const std::vector<BindingInput> &inputs)

Bind the buffers and/or textures.

Return
a bound object, ready to be recorded in a command buffer.
Parameters
  • inputs: a list of buffers and/or textures

VORTEX2D_API Bound Vortex2D::Renderer::Work::Bind(ComputeSize computeSize, const std::vector< BindingInput > & inputs)

Bind the buffers and/or textures. This overrides the provided compute size in Work.

Return
a bound object, ready to be recorded in a command buffer.
Parameters
  • computeSize: the compute shader compute size.
  • inputs: a list of buffers and/or textures

class Bound
#include <Work.h>

Is a bound version of Work. This means a buffer or texture was bound and this can be recorded in a command buffer.

Public Functions

Bound()
template <typename... Args>
void PushConstant(vk::CommandBuffer commandBuffer, Args&&... args)

Adds a constant value, i.e. a push constant.

Parameters
  • commandBuffer: the command buffer where the compute work will also be recorded.
  • data: the data to push. A total of 128 bytes can be used.

void Record(vk::CommandBuffer commandBuffer)

Record the compute work in this command buffer. This will also set two additional push constants: the 2D domain size.

Parameters
  • commandBuffer: the command buffer to record into.

void RecordIndirect(vk::CommandBuffer commandBuffer, IndirectBuffer<DispatchParams> &dispatchParams)

Record the compute work in this command buffer. Use the provided parameters to run the compute shader.

Parameters
  • commandBuffer: the command buffer to record into.
  • dispatchParams: the indirect buffer containing the parameters.

Friends

friend Vortex2D::Renderer::Work
namespace Detail

Functions

void InsertSpecConst(SpecConstInfo &specConstInfo)
template <typename Arg, typename... Args>
void InsertSpecConst(SpecConstInfo &specConstInfo, Arg &&arg, Args&&... args)