Structs.h

Go to the documentation of this file.

 
#pragma once
#include <vulkan/vulkan.h>
#include <stdbool.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define VK2D_MAX_CAMERAS 10
 
// For opaque pointer types
#define VK2D_OPAQUE_POINTER(type) typedef struct type##_t *type;
 
// For user-modifiable and user-visible structures
#define VK2D_USER_STRUCT(type) typedef struct type type;
 
typedef enum {
    VK2D_VERTEX_TYPE_TEXTURE = 0, 
    VK2D_VERTEX_TYPE_SHAPE = 1,   
    VK2D_VERTEX_TYPE_MODEL = 2,   
    VK2D_VERTEX_TYPE_OTHER = 3,   
    VK2D_VERTEX_TYPE_MAX = 4      
} VK2DVertexType;
 
typedef enum {
    VK2D_BLEND_MODE_BLEND = 0,    
    VK2D_BLEND_MODE_NONE = 1,     
    VK2D_BLEND_MODE_ADD = 2,      
    VK2D_BLEND_MODE_SUBTRACT = 3, 
    VK2D_BLEND_MODE_MAX = 4       
} VK2DBlendMode;
 
typedef enum {
    VK2D_MSAA_1X = VK_SAMPLE_COUNT_1_BIT,   
    VK2D_MSAA_2X = VK_SAMPLE_COUNT_2_BIT,   
    VK2D_MSAA_4X = VK_SAMPLE_COUNT_4_BIT,   
    VK2D_MSAA_8X = VK_SAMPLE_COUNT_8_BIT,   
    VK2D_MSAA_16X = VK_SAMPLE_COUNT_16_BIT, 
    VK2D_MSAA_32X = VK_SAMPLE_COUNT_32_BIT, 
} VK2DMSAA;
 
typedef enum {
    VK2D_SCREEN_MODE_IMMEDIATE = VK_PRESENT_MODE_IMMEDIATE_KHR,  
    VK2D_SCREEN_MODE_VSYNC = VK_PRESENT_MODE_FIFO_KHR,           
    VK2D_SCREEN_MODE_TRIPLE_BUFFER = VK_PRESENT_MODE_MAILBOX_KHR 
} VK2DScreenMode;
 
typedef enum {
    VK2D_FILTER_TYPE_LINEAR = VK_FILTER_LINEAR,  
    VK2D_FILTER_TYPE_NEAREST = VK_FILTER_NEAREST 
} VK2DFilterType;
 
typedef enum {
    VK2D_SHADER_STAGE_FRAGMENT = VK_SHADER_STAGE_FRAGMENT_BIT, 
    VK2D_SHADER_STAGE_VERTEX = VK_SHADER_STAGE_VERTEX_BIT      
} VK2DShaderStage;
 
typedef enum {
    VK2D_CAMERA_STATE_NORMAL = 0,   
    VK2D_CAMERA_STATE_DISABLED = 1, 
    VK2D_CAMERA_STATE_DELETED = 2,  
    VK2D_CAMERA_STATE_RESET = 3,    
    VK2D_CAMERA_STATE_MAX = 4       
} VK2DCameraState;
 
typedef enum {
    VK2D_CAMERA_TYPE_DEFAULT = 0,      
    VK2D_CAMERA_TYPE_ORTHOGRAPHIC = 1, 
    VK2D_CAMERA_TYPE_PERSPECTIVE = 2,  
    VK2D_CAMERA_TYPE_MAX = 3           
} VK2DCameraType;
 
typedef enum {
    VK2D_PIPELINE_TYPE_DEFAULT = 0,     
    VK2D_PIPELINE_TYPE_3D = 1,          
    VK2D_PIPELINE_TYPE_INSTANCING = 2,  
    VK2D_PIPELINE_TYPE_SHADOWS = 3,     
    VK2D_PIPELINE_TYPE_USER_SHADER = 4, 
    VK2D_PIPELINE_TYPE_MAX = 5,         
} VK2DPipelineType;
 
typedef enum {
    VK2D_SUCCESS = 0,         
    VK2D_RESET_SWAPCHAIN = 1, 
    VK2D_ERROR = -1           
} VK2DResult;
 
typedef enum {
    VK2D_STATUS_NONE                     = 0,     
    VK2D_STATUS_FILE_NOT_FOUND           = 1<<0,  
    VK2D_STATUS_BAD_FORMAT               = 1<<1,  
    VK2D_STATUS_TOO_MANY_CAMERAS         = 1<<2,  
    VK2D_STATUS_DEVICE_LOST              = 1<<3,  
    VK2D_STATUS_VULKAN_ERROR             = 1<<4,  
    VK2D_STATUS_OUT_OF_RAM               = 1<<5,  
    VK2D_STATUS_OUT_OF_VRAM              = 1<<6,  
    VK2D_STATUS_RENDERER_NOT_INITIALIZED = 1<<7,  
    VK2D_STATUS_SDL_ERROR                = 1<<8,  
    VK2D_STATUS_BEYOND_LIMIT             = 1<<9,  
    VK2D_STATUS_BAD_ASSET                = 1<<10, 
} VK2DStatus;
 
typedef enum {
    VK2D_ASSET_TYPE_TEXTURE_FILE = 1,   
    VK2D_ASSET_TYPE_TEXTURE_MEMORY = 2, 
    VK2D_ASSET_TYPE_MODEL_FILE = 3,     
    VK2D_ASSET_TYPE_MODEL_MEMORY = 4,   
    VK2D_ASSET_TYPE_SHADER_FILE = 5,    
    VK2D_ASSET_TYPE_SHADER_MEMORY = 6,  
} VK2DAssetType;
 
typedef enum {
    VK2D_ASSET_TYPE_ASSET = 0,   
    VK2D_ASSET_TYPE_PENDING = 1, 
    VK2D_ASSET_TYPE_NONE = 2,    
} VK2DAssetState;
 
typedef enum {
    VK2D_LOG_SEVERITY_DEBUG = 0,
    VK2D_LOG_SEVERITY_INFO = 1,
    VK2D_LOG_SEVERITY_WARN = 2,
    VK2D_LOG_SEVERITY_ERROR = 3,
    VK2D_LOG_SEVERITY_FATAL = 4,
    VK2D_LOG_SEVERITY_UNKNOWN = 5,
} VK2DLogSeverity;
 
// VK2D pointers
VK2D_OPAQUE_POINTER(VK2DRenderer)
VK2D_OPAQUE_POINTER(VK2DImage)
VK2D_OPAQUE_POINTER(VK2DLogicalDevice)
VK2D_OPAQUE_POINTER(VK2DPhysicalDevice)
VK2D_OPAQUE_POINTER(VK2DBuffer)
VK2D_OPAQUE_POINTER(VK2DPipeline)
VK2D_OPAQUE_POINTER(VK2DTexture)
VK2D_OPAQUE_POINTER(VK2DDescCon)
VK2D_OPAQUE_POINTER(VK2DPolygon)
VK2D_OPAQUE_POINTER(VK2DShader)
VK2D_OPAQUE_POINTER(VK2DModel)
VK2D_OPAQUE_POINTER(VK2DDescriptorBuffer)
VK2D_OPAQUE_POINTER(VK2DShadowEnvironment)
 
 
typedef float vec2[2];
 
typedef float vec3[3];
 
typedef float vec4[4];
 
typedef float mat4[16];
 
typedef int32_t VK2DShadowObject;
 
typedef int32_t VK2DCameraIndex;
 
struct VK2DVertexColour {
    vec3 pos;    
    vec4 colour; 
};
 
struct VK2DVertex3D {
    vec3 pos; 
    vec2 uv;  
};
 
struct VK2DUniformBufferObject {
    mat4 viewproj[VK2D_MAX_CAMERAS]; 
};
 
struct VK2DShaderPushBuffer {
    int32_t cameraIndex;   
    uint32_t textureIndex; 
    vec2 _padding;         
    vec4 texturePos;       
    vec4 colour;           
    mat4 model;            
};
 
struct VK2DPushBuffer {
    mat4 model;           
    vec4 colourMod;       
    int32_t cameraIndex; 
};
 
struct VK2D3DPushBuffer {
    mat4 model;            
    vec4 colourMod;        
    uint32_t textureIndex; 
    uint32_t cameraIndex;  
};
 
struct VK2DShadowsPushBuffer {
    mat4 model;           
    vec2 lightSource;     
    vec2 _alignment;      
    vec4 colour;          
    uint32_t cameraIndex; 
};
 
struct VK2DConfiguration {
    const char *applicationName; 
    const char *engineName;      
    uint32_t applicationVersion; 
    uint32_t engineVersion;      
    uint32_t apiVersion;         
};
 
struct VK2DStartupOptions {
    bool enableDebug;       
    bool stdoutLogging;     
    bool quitOnError;       
    const char *errorFile;  
    uint32_t maxTextures;   
 
    uint64_t vramPageSize;
 
};
 
struct VK2DRendererConfig {
    VK2DMSAA msaa;             
    VK2DScreenMode screenMode; 
    VK2DFilterType filterMode; 
};
 
struct VK2DCameraSpec {
    VK2DCameraType  type; 
    float x;              
    float y;              
    float w;              
    float h;              
    float zoom;           
    float rot;            
    float xOnScreen;      
    float yOnScreen;      
    float wOnScreen;      
    float hOnScreen;      
 
    struct {
        vec3 eyes;   
        vec3 centre; 
        vec3 up;     
        float fov;   
    } Perspective;
};
 
struct VK2DRendererLimits {
    VK2DMSAA maxMSAA;                
    bool supportsTripleBuffering;    
    bool supportsImmediate;          
    bool supportsWireframe;          
    float maxLineWidth;              
    uint64_t maxInstancedDraws;      
    uint64_t maxShaderBufferSize;    
    uint64_t maxGeometryVertices;    
    bool supportsMultiThreadLoading; 
    bool supportsVRAMUsage;          
};
 
struct VK2DDrawInstance {
    vec4 texturePos;       
    vec4 colour;           
    uint32_t textureIndex; 
    vec3 padding;          
    mat4 model;            
};
 
struct VK2DDrawCommand {
    vec4 texturePos;       
    vec4 colour;           
    vec2 pos;              
    vec2 origin;           
    vec2 scale;            
    float rotation;        
    uint32_t textureIndex; 
};
 
struct VK2DInstancedPushBuffer {
    uint32_t cameraIndex; 
};
 
struct VK2DComputePushBuffer {
    uint32_t drawCount; 
};
 
struct VK2DShadowObjectInfo {
    bool enabled;       
    int startingVertex; 
    int vertexCount;    
    mat4 model;         
};
 
struct VK2DAssetLoad {
    VK2DAssetType type;   
    VK2DAssetState state; 
    union {
        struct {
            const char *filename;         
            const char *fragmentFilename; 
        };
        struct {
            int size;           
            void *data;         
            int fragmentSize;   
            void *fragmentData; 
        };
    } Load; 
 
    union {
        struct {
            int uniformBufferSize; 
        } Shader; 
        struct {
            VK2DTexture *tex; 
        } Model; 
    } Data; 
 
    union {
        VK2DShader *shader;   
        VK2DModel *model;     
        VK2DTexture *texture; 
    } Output; 
};
 
 
typedef void (*VK2DLoggerLogFn)(void *context, VK2DLogSeverity severity, const char *message);
 
typedef void (*VK2DLoggerDestroyFn)(void *context);
 
typedef VK2DLogSeverity (*VK2DLoggerSeverityFn)(void *context);
 
struct VK2DLogger {
    VK2DLoggerLogFn log;
    VK2DLoggerDestroyFn destroy;
    VK2DLoggerSeverityFn severityFn;
    void *context;
};
 
VK2D_USER_STRUCT(VK2DVertexColour)
VK2D_USER_STRUCT(VK2DVertex3D)
VK2D_USER_STRUCT(VK2DUniformBufferObject)
VK2D_USER_STRUCT(VK2DPushBuffer)
VK2D_USER_STRUCT(VK2D3DPushBuffer)
VK2D_USER_STRUCT(VK2DShadowsPushBuffer)
VK2D_USER_STRUCT(VK2DShaderPushBuffer)
VK2D_USER_STRUCT(VK2DConfiguration)
VK2D_USER_STRUCT(VK2DStartupOptions)
VK2D_USER_STRUCT(VK2DRendererConfig)
VK2D_USER_STRUCT(VK2DCameraSpec)
VK2D_USER_STRUCT(VK2DRendererLimits)
VK2D_USER_STRUCT(VK2DDrawInstance)
VK2D_USER_STRUCT(VK2DDrawCommand)
VK2D_USER_STRUCT(VK2DAssetLoad)
VK2D_USER_STRUCT(VK2DShadowObjectInfo)
VK2D_USER_STRUCT(VK2DInstancedPushBuffer)
VK2D_USER_STRUCT(VK2DComputePushBuffer)
VK2D_USER_STRUCT(VK2DLogger)
 
#ifdef __cplusplus
}
#endif