sbgl_types.h

Go to the documentation of this file.

#ifndef SBGL_TYPES_H
#define SBGL_TYPES_H
 
#include <stdbool.h>
 
#include <stdint.h>
 
#define SBGL_INVALID_HANDLE 0
#define SBGL_INVALID_OFFSET ((uint32_t)-1)
 
#include "sbgl_math.h"
 
typedef struct {
  sbgl_Mat4 transform; 
  sbgl_Vec4 color;   
} sbgl_InstanceData;
 
typedef struct {
  int16_t position[4]; 
  uint32_t color;     
  uint32_t _padding;   
} sbgl_Vertex;
 
typedef uint32_t sbgl_Buffer;
 
typedef uint32_t sbgl_Shader;
 
typedef uint32_t sbgl_Pipeline;
 
typedef uint32_t sbgl_ComputePipeline;
 
typedef uint64_t sbgl_SortKey;
 
#define SBGL_PACKET_MESH_MASK 0x7FF
#define SBGL_PACKET_MAT_MASK 0x7FF
#define SBGL_PACKET_BLEND_MASK 0x3
#define SBGL_PACKET_SIDED_MASK 0x1
#define SBGL_PACKET_TAGS_MASK 0x7F
 
#define SBGL_PACKET_MAT_SHIFT 11
#define SBGL_PACKET_BLEND_SHIFT 22
#define SBGL_PACKET_SIDED_SHIFT 24
#define SBGL_PACKET_TAGS_SHIFT 25
 
/* Voxel instance layout: 
   Word 0: 18 bits VoxelID, 8 bits Y-Scale, 6 bits MaterialID
   Word 1: 16 bits AO (8 corners * 2 bits), 16 bits Reserved */
#define SBGL_VOXEL_ID_MASK 0x3FFFF
#define SBGL_VOXEL_SCALE_MASK 0xFF
#define SBGL_VOXEL_SCALE_SHIFT 18
#define SBGL_VOXEL_MAT_MASK 0x3F
#define SBGL_VOXEL_MAT_SHIFT 26
 
#define SBGL_PACK_VOXEL_INSTANCE(id, scale, mat) \
  (((id) & SBGL_VOXEL_ID_MASK) | (((scale) & SBGL_VOXEL_SCALE_MASK) << SBGL_VOXEL_SCALE_SHIFT) | (((mat) & SBGL_VOXEL_MAT_MASK) << SBGL_VOXEL_MAT_SHIFT))
 
#define SBGL_PACK_HEADER(mesh, mat, blend, sided, tags)                                            \
  (((mesh) & SBGL_PACKET_MESH_MASK) |                                                            \
   (((mat) & SBGL_PACKET_MAT_MASK) << SBGL_PACKET_MAT_SHIFT) |                                   \
   (((blend) & SBGL_PACKET_BLEND_MASK) << SBGL_PACKET_BLEND_SHIFT) |                             \
   (((sided) & SBGL_PACKET_SIDED_MASK) << SBGL_PACKET_SIDED_SHIFT) |                             \
   (((tags) & SBGL_PACKET_TAGS_MASK) << SBGL_PACKET_TAGS_SHIFT))
 
#define SBGL_GET_MESH_ID(h) ((h) & SBGL_PACKET_MESH_MASK)
#define SBGL_GET_MAT_ID(h) (((h) >> SBGL_PACKET_MAT_SHIFT) & SBGL_PACKET_MAT_MASK)
#define SBGL_GET_BLEND_MODE(h) (((h) >> SBGL_PACKET_BLEND_SHIFT) & SBGL_PACKET_BLEND_MASK)
 
typedef struct {
  sbgl_SortKey key;  
  uint32_t header;   
  uint32_t _padding; 
} sbgl_DrawPacket;
 
typedef struct sbgl_RenderQueue sbgl_RenderQueue;
 
typedef struct {
  uint32_t indexCount;    
  uint32_t instanceCount; 
  uint32_t firstIndex;    
  int32_t vertexOffset;   
  uint32_t firstInstance; 
} sbgl_IndirectCommand;
 
typedef enum {
  SBGL_BUFFER_USAGE_VERTEX = 0x01,
  SBGL_BUFFER_USAGE_INDEX = 0x02,
  SBGL_BUFFER_USAGE_STORAGE = 0x04,
  SBGL_BUFFER_USAGE_INDIRECT = 0x08,
  SBGL_BUFFER_USAGE_TRANSFER_DST = 0x10,
} sbgl_BufferUsage;
 
typedef enum {
  SBGL_SHADER_STAGE_VERTEX = 0x01,
  SBGL_SHADER_STAGE_FRAGMENT = 0x02,
  SBGL_SHADER_STAGE_COMPUTE = 0x04,
} sbgl_ShaderStage;
 
typedef enum {
  SBGL_BARRIER_COMPUTE_TO_COMPUTE = 0,
  SBGL_BARRIER_COMPUTE_TO_INDIRECT = 1,
  SBGL_BARRIER_COMPUTE_TO_GRAPHICS = 2,
  SBGL_BARRIER_GRAPHICS_TO_COMPUTE = 3,
  SBGL_BARRIER_HOST_TO_COMPUTE = 4,
  SBGL_BARRIER_HOST_TO_GRAPHICS = 5,
} sbgl_BarrierType;
 
typedef enum {
  SBGL_FORMAT_R32_SFLOAT = 0,
  SBGL_FORMAT_R32G32_SFLOAT = 1,
  SBGL_FORMAT_R32G32B32_SFLOAT = 2,
  SBGL_FORMAT_R32G32B32A32_SFLOAT = 3,
  SBGL_FORMAT_R16G16B16A16_SNORM = 4,
  SBGL_FORMAT_R8G8B8A8_UNORM = 5,
} sbgl_Format;
 
typedef struct {
  uint32_t location;  
  uint32_t offset;  
  sbgl_Format format; 
} sbgl_VertexAttribute;
 
typedef struct {
  float cpu_frame_time;    
  float cpu_sort_time;     
  float gpu_render_time;   
  uint32_t draw_calls;     
  uint32_t instance_count; 
} sbgl_Telemetry;
 
typedef struct {
  uint32_t stride;
  uint32_t attributeCount;
  const sbgl_VertexAttribute* attributes;
} sbgl_VertexLayout;
 
typedef enum {
  SBGL_BLEND_MODE_NONE = 0,
  SBGL_BLEND_MODE_ALPHA = 1,
  SBGL_BLEND_MODE_ADDITIVE = 2,
} sbgl_BlendMode;
 
typedef struct {
  sbgl_Shader vertexShader;
  sbgl_Shader fragmentShader;
  sbgl_VertexLayout vertexLayout;
  sbgl_BlendMode blendMode;
} sbgl_PipelineConfig;
 
typedef enum {
  SBGL_SUCCESS = 0,
  SBGL_ERROR_NULL_CONTEXT = 1,
  SBGL_ERROR_INVALID_ARGUMENT = 2,
  SBGL_ERROR_INITIALIZATION_FAILED = 3,
  SBGL_ERROR_WINDOW_CREATION_FAILED = 4,
  SBGL_ERROR_GRAPHICS_FAILED = 5,
  SBGL_ERROR_OUT_OF_MEMORY = 6,
  SBGL_ERROR_DEVICE_BUSY = 7,
  SBGL_ERROR_INVALID_HANDLE = 8,
  SBGL_ERROR_SWAPCHAIN_FAILED = 9,
  SBGL_ERROR_SHADER_FAILED = 10,
  SBGL_ERROR_PIPELINE_FAILED = 11,
  SBGL_ERROR_PLATFORM_FAILED = 12,
} sbgl_Result;
 
typedef enum {
  SBGL_PLATFORM_SUCCESS = 0,
  SBGL_PLATFORM_ERROR_WINDOW_FAILED = 1,
  SBGL_PLATFORM_ERROR_NO_DISPLAY = 2,
  SBGL_PLATFORM_ERROR_INIT_FAILED = 3,
} sbgl_platform_Result;
 
typedef enum {
  SBGL_BACKEND_VULKAN = 0,
} sbgl_BackendType;
 
typedef struct {
  sbgl_BackendType type;  
  sbgl_Result      coreResult;  
  int32_t          vkResult;    
  uint32_t         extension;    
} sbgl_ErrorDetail;
 
typedef struct sbgl_Context {
  void* inner;
 
  sbgl_Result result;
} sbgl_Context;
 
typedef struct {
  uint32_t maxBuffers;   
  uint32_t maxShaders;   
  uint32_t maxPipelines; 
} sbgl_ResourceLimits;
 
typedef struct {
  uint32_t windowWidth;        
  uint32_t windowHeight;       
  const char* windowTitle;     
  sbgl_ResourceLimits limits;  
  bool enableValidation;       
} sbgl_InitConfig;
 
#define sbgl_DefaultInitConfig ((sbgl_InitConfig){ \
  .windowWidth = 800, \
  .windowHeight = 600, \
  .windowTitle = "SBgl Application", \
  .limits = { .maxBuffers = 1024, .maxShaders = 256, .maxPipelines = 256 }, \
  .enableValidation = true \
})
 
typedef struct {
  sbgl_Context* ctx;
  sbgl_Result error;
} sbgl_InitResult;
 
typedef struct sbgl_Window sbgl_Window;
 
#endif // SBGL_TYPES_H