2017-10-31 08:14:09 +00:00
|
|
|
#include <stdbool.h>
|
2022-04-21 09:16:17 +00:00
|
|
|
#include <stdint.h>
|
2022-05-24 06:10:11 +00:00
|
|
|
#include <stddef.h>
|
2016-09-21 07:55:53 +00:00
|
|
|
|
2017-01-26 10:20:30 +00:00
|
|
|
#pragma once
|
2016-09-27 06:48:09 +00:00
|
|
|
|
2022-05-09 18:47:06 +00:00
|
|
|
struct Blob;
|
2022-04-30 03:38:34 +00:00
|
|
|
struct Image;
|
2022-06-19 00:43:12 +00:00
|
|
|
struct Rasterizer;
|
2022-07-04 00:26:31 +00:00
|
|
|
struct ModelData;
|
2022-04-30 03:38:34 +00:00
|
|
|
|
2022-04-26 22:32:54 +00:00
|
|
|
typedef struct Buffer Buffer;
|
2022-04-30 03:38:34 +00:00
|
|
|
typedef struct Texture Texture;
|
2022-05-01 22:47:17 +00:00
|
|
|
typedef struct Sampler Sampler;
|
2022-05-09 18:47:06 +00:00
|
|
|
typedef struct Shader Shader;
|
2022-06-17 06:49:09 +00:00
|
|
|
typedef struct Material Material;
|
2022-06-19 00:43:12 +00:00
|
|
|
typedef struct Font Font;
|
2023-06-11 05:06:29 +00:00
|
|
|
typedef struct Mesh Mesh;
|
2022-07-04 00:26:31 +00:00
|
|
|
typedef struct Model Model;
|
2022-07-14 07:05:58 +00:00
|
|
|
typedef struct Readback Readback;
|
2022-04-29 05:30:31 +00:00
|
|
|
typedef struct Pass Pass;
|
2022-04-26 22:32:54 +00:00
|
|
|
|
2022-08-03 05:00:11 +00:00
|
|
|
typedef struct {
|
|
|
|
bool debug;
|
|
|
|
bool vsync;
|
|
|
|
bool stencil;
|
|
|
|
bool antialias;
|
2022-08-03 05:05:12 +00:00
|
|
|
void* cacheData;
|
|
|
|
size_t cacheSize;
|
2022-08-03 05:00:11 +00:00
|
|
|
} GraphicsConfig;
|
|
|
|
|
2022-04-21 09:16:17 +00:00
|
|
|
typedef struct {
|
2022-04-22 20:28:59 +00:00
|
|
|
uint32_t deviceId;
|
|
|
|
uint32_t vendorId;
|
2022-04-21 09:16:17 +00:00
|
|
|
const char* name;
|
|
|
|
const char* renderer;
|
|
|
|
uint32_t subgroupSize;
|
2022-04-22 20:28:59 +00:00
|
|
|
bool discrete;
|
2022-04-21 09:16:17 +00:00
|
|
|
} GraphicsDevice;
|
|
|
|
|
|
|
|
typedef struct {
|
2022-04-26 22:31:51 +00:00
|
|
|
bool textureBC;
|
|
|
|
bool textureASTC;
|
2022-04-21 09:16:17 +00:00
|
|
|
bool wireframe;
|
|
|
|
bool depthClamp;
|
2023-01-23 07:26:15 +00:00
|
|
|
bool depthResolve;
|
2022-04-21 09:16:17 +00:00
|
|
|
bool indirectDrawFirstInstance;
|
|
|
|
bool float64;
|
|
|
|
bool int64;
|
|
|
|
bool int16;
|
|
|
|
} GraphicsFeatures;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
uint32_t textureSize2D;
|
|
|
|
uint32_t textureSize3D;
|
|
|
|
uint32_t textureSizeCube;
|
|
|
|
uint32_t textureLayers;
|
|
|
|
uint32_t renderSize[3];
|
2022-06-01 03:16:16 +00:00
|
|
|
uint32_t uniformBuffersPerStage;
|
|
|
|
uint32_t storageBuffersPerStage;
|
|
|
|
uint32_t sampledTexturesPerStage;
|
|
|
|
uint32_t storageTexturesPerStage;
|
|
|
|
uint32_t samplersPerStage;
|
|
|
|
uint32_t resourcesPerShader;
|
2022-04-21 09:16:17 +00:00
|
|
|
uint32_t uniformBufferRange;
|
|
|
|
uint32_t storageBufferRange;
|
|
|
|
uint32_t uniformBufferAlign;
|
|
|
|
uint32_t storageBufferAlign;
|
|
|
|
uint32_t vertexAttributes;
|
|
|
|
uint32_t vertexBufferStride;
|
|
|
|
uint32_t vertexShaderOutputs;
|
2022-04-26 22:31:51 +00:00
|
|
|
uint32_t clipDistances;
|
|
|
|
uint32_t cullDistances;
|
|
|
|
uint32_t clipAndCullDistances;
|
2022-08-06 20:06:42 +00:00
|
|
|
uint32_t workgroupCount[3];
|
|
|
|
uint32_t workgroupSize[3];
|
|
|
|
uint32_t totalWorkgroupSize;
|
2022-04-21 09:16:17 +00:00
|
|
|
uint32_t computeSharedMemory;
|
|
|
|
uint32_t shaderConstantSize;
|
|
|
|
uint32_t indirectDrawCount;
|
|
|
|
uint32_t instances;
|
|
|
|
float anisotropy;
|
|
|
|
float pointSize;
|
|
|
|
} GraphicsLimits;
|
|
|
|
|
2022-04-30 00:12:10 +00:00
|
|
|
enum {
|
2023-11-02 22:33:29 +00:00
|
|
|
TEXTURE_FEATURE_SAMPLE = (1 << 0),
|
|
|
|
TEXTURE_FEATURE_RENDER = (1 << 1),
|
|
|
|
TEXTURE_FEATURE_STORAGE = (1 << 2),
|
|
|
|
TEXTURE_FEATURE_BLIT = (1 << 3)
|
2022-04-30 00:12:10 +00:00
|
|
|
};
|
|
|
|
|
2022-08-03 05:00:11 +00:00
|
|
|
bool lovrGraphicsInit(GraphicsConfig* config);
|
2019-02-17 22:39:51 +00:00
|
|
|
void lovrGraphicsDestroy(void);
|
2022-11-08 03:12:11 +00:00
|
|
|
bool lovrGraphicsIsInitialized(void);
|
2022-04-21 09:16:17 +00:00
|
|
|
|
|
|
|
void lovrGraphicsGetDevice(GraphicsDevice* device);
|
|
|
|
void lovrGraphicsGetFeatures(GraphicsFeatures* features);
|
|
|
|
void lovrGraphicsGetLimits(GraphicsLimits* limits);
|
2023-07-11 02:21:11 +00:00
|
|
|
uint32_t lovrGraphicsGetFormatSupport(uint32_t format, uint32_t features);
|
2022-08-03 05:05:12 +00:00
|
|
|
void lovrGraphicsGetShaderCache(void* data, size_t* size);
|
2022-04-26 22:32:54 +00:00
|
|
|
|
2022-08-14 04:10:58 +00:00
|
|
|
void lovrGraphicsGetBackgroundColor(float background[4]);
|
|
|
|
void lovrGraphicsSetBackgroundColor(float background[4]);
|
2022-08-06 04:05:02 +00:00
|
|
|
|
2023-05-07 06:36:33 +00:00
|
|
|
bool lovrGraphicsIsTimingEnabled(void);
|
|
|
|
void lovrGraphicsSetTimingEnabled(bool enable);
|
2022-04-29 05:30:31 +00:00
|
|
|
void lovrGraphicsSubmit(Pass** passes, uint32_t count);
|
2022-08-04 07:06:54 +00:00
|
|
|
void lovrGraphicsPresent(void);
|
2022-04-29 05:37:03 +00:00
|
|
|
void lovrGraphicsWait(void);
|
2022-04-29 05:30:31 +00:00
|
|
|
|
2022-04-26 22:32:54 +00:00
|
|
|
// Buffer
|
|
|
|
|
|
|
|
typedef enum {
|
2023-06-24 02:11:30 +00:00
|
|
|
TYPE_I8x4,
|
|
|
|
TYPE_U8x4,
|
|
|
|
TYPE_SN8x4,
|
|
|
|
TYPE_UN8x4,
|
2024-01-21 01:18:54 +00:00
|
|
|
TYPE_SN10x3,
|
2023-06-24 02:11:30 +00:00
|
|
|
TYPE_UN10x3,
|
|
|
|
TYPE_I16,
|
|
|
|
TYPE_I16x2,
|
|
|
|
TYPE_I16x4,
|
|
|
|
TYPE_U16,
|
|
|
|
TYPE_U16x2,
|
|
|
|
TYPE_U16x4,
|
|
|
|
TYPE_SN16x2,
|
|
|
|
TYPE_SN16x4,
|
|
|
|
TYPE_UN16x2,
|
|
|
|
TYPE_UN16x4,
|
|
|
|
TYPE_I32,
|
|
|
|
TYPE_I32x2,
|
|
|
|
TYPE_I32x3,
|
|
|
|
TYPE_I32x4,
|
|
|
|
TYPE_U32,
|
|
|
|
TYPE_U32x2,
|
|
|
|
TYPE_U32x3,
|
|
|
|
TYPE_U32x4,
|
|
|
|
TYPE_F16x2,
|
|
|
|
TYPE_F16x4,
|
|
|
|
TYPE_F32,
|
|
|
|
TYPE_F32x2,
|
|
|
|
TYPE_F32x3,
|
|
|
|
TYPE_F32x4,
|
|
|
|
TYPE_MAT2,
|
|
|
|
TYPE_MAT3,
|
|
|
|
TYPE_MAT4,
|
|
|
|
TYPE_INDEX16,
|
2023-08-25 20:42:09 +00:00
|
|
|
TYPE_INDEX32
|
2023-06-24 02:11:30 +00:00
|
|
|
} DataType;
|
2022-04-26 22:32:54 +00:00
|
|
|
|
2023-06-24 04:14:19 +00:00
|
|
|
typedef struct DataField {
|
2023-01-16 13:15:13 +00:00
|
|
|
const char* name;
|
2023-08-25 20:42:09 +00:00
|
|
|
uint32_t hash;
|
|
|
|
DataType type;
|
2022-06-16 03:46:43 +00:00
|
|
|
uint32_t offset;
|
2023-01-16 13:15:13 +00:00
|
|
|
uint32_t length;
|
|
|
|
uint32_t stride;
|
2023-08-25 20:42:09 +00:00
|
|
|
uint32_t fieldCount;
|
|
|
|
struct DataField* fields;
|
2024-04-16 22:04:20 +00:00
|
|
|
struct DataField* parent;
|
2023-06-24 04:14:19 +00:00
|
|
|
} DataField;
|
2022-04-26 22:32:54 +00:00
|
|
|
|
2023-08-25 20:42:09 +00:00
|
|
|
typedef enum {
|
|
|
|
LAYOUT_PACKED,
|
|
|
|
LAYOUT_STD140,
|
|
|
|
LAYOUT_STD430
|
|
|
|
} DataLayout;
|
|
|
|
|
|
|
|
uint32_t lovrGraphicsAlignFields(DataField* parent, DataLayout layout);
|
|
|
|
|
2022-04-26 22:32:54 +00:00
|
|
|
typedef struct {
|
2023-01-16 13:15:13 +00:00
|
|
|
uint32_t size;
|
2022-04-26 22:32:54 +00:00
|
|
|
uint32_t fieldCount;
|
2023-08-25 20:42:09 +00:00
|
|
|
DataField* format;
|
2022-04-26 22:32:54 +00:00
|
|
|
const char* label;
|
|
|
|
uintptr_t handle;
|
|
|
|
} BufferInfo;
|
|
|
|
|
2022-07-13 07:07:15 +00:00
|
|
|
Buffer* lovrBufferCreate(const BufferInfo* info, void** data);
|
2022-04-26 22:32:54 +00:00
|
|
|
void lovrBufferDestroy(void* ref);
|
|
|
|
const BufferInfo* lovrBufferGetInfo(Buffer* buffer);
|
2023-04-30 01:25:58 +00:00
|
|
|
void* lovrBufferGetData(Buffer* buffer, uint32_t offset, uint32_t extent);
|
|
|
|
void* lovrBufferSetData(Buffer* buffer, uint32_t offset, uint32_t extent);
|
|
|
|
void lovrBufferCopy(Buffer* src, Buffer* dst, uint32_t srcOffset, uint32_t dstOffset, uint32_t extent);
|
2023-09-19 06:05:27 +00:00
|
|
|
void lovrBufferClear(Buffer* buffer, uint32_t offset, uint32_t extent, uint32_t value);
|
2022-04-29 05:30:31 +00:00
|
|
|
|
2022-04-30 03:38:34 +00:00
|
|
|
// Texture
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
TEXTURE_2D,
|
2022-04-30 03:56:23 +00:00
|
|
|
TEXTURE_3D,
|
2022-04-30 03:38:34 +00:00
|
|
|
TEXTURE_CUBE,
|
|
|
|
TEXTURE_ARRAY
|
|
|
|
} TextureType;
|
|
|
|
|
|
|
|
enum {
|
2022-05-07 00:26:59 +00:00
|
|
|
TEXTURE_SAMPLE = (1 << 0),
|
|
|
|
TEXTURE_RENDER = (1 << 1),
|
|
|
|
TEXTURE_STORAGE = (1 << 2),
|
|
|
|
TEXTURE_TRANSFER = (1 << 3)
|
2022-04-30 03:38:34 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
TextureType type;
|
|
|
|
uint32_t format;
|
|
|
|
uint32_t width;
|
|
|
|
uint32_t height;
|
2022-07-30 22:08:30 +00:00
|
|
|
uint32_t layers;
|
2022-04-30 03:38:34 +00:00
|
|
|
uint32_t mipmaps;
|
2022-04-30 10:06:14 +00:00
|
|
|
uint32_t usage;
|
2022-04-30 03:38:34 +00:00
|
|
|
bool srgb;
|
2022-08-06 01:36:51 +00:00
|
|
|
bool xr;
|
2022-05-01 01:49:46 +00:00
|
|
|
uint32_t imageCount;
|
2022-04-30 03:38:34 +00:00
|
|
|
struct Image** images;
|
|
|
|
const char* label;
|
2024-02-26 23:08:34 +00:00
|
|
|
uintptr_t handle;
|
2022-04-30 03:38:34 +00:00
|
|
|
} TextureInfo;
|
|
|
|
|
2024-02-26 23:08:34 +00:00
|
|
|
typedef struct {
|
|
|
|
TextureType type;
|
|
|
|
uint32_t layerIndex;
|
|
|
|
uint32_t layerCount;
|
|
|
|
uint32_t levelIndex;
|
|
|
|
uint32_t levelCount;
|
|
|
|
const char* label;
|
|
|
|
} TextureViewInfo;
|
|
|
|
|
2023-04-30 01:25:58 +00:00
|
|
|
typedef enum {
|
|
|
|
FILTER_NEAREST,
|
|
|
|
FILTER_LINEAR
|
|
|
|
} FilterMode;
|
|
|
|
|
2022-05-11 22:28:04 +00:00
|
|
|
Texture* lovrGraphicsGetWindowTexture(void);
|
2022-07-13 07:07:15 +00:00
|
|
|
Texture* lovrTextureCreate(const TextureInfo* info);
|
2024-02-26 23:08:34 +00:00
|
|
|
Texture* lovrTextureCreateView(Texture* parent, const TextureViewInfo* info);
|
2022-04-30 03:38:34 +00:00
|
|
|
void lovrTextureDestroy(void* ref);
|
|
|
|
const TextureInfo* lovrTextureGetInfo(Texture* texture);
|
2023-04-30 01:25:58 +00:00
|
|
|
struct Image* lovrTextureGetPixels(Texture* texture, uint32_t offset[4], uint32_t extent[3]);
|
|
|
|
void lovrTextureSetPixels(Texture* texture, struct Image* image, uint32_t texOffset[4], uint32_t imgOffset[4], uint32_t extent[3]);
|
|
|
|
void lovrTextureCopy(Texture* src, Texture* dst, uint32_t srcOffset[4], uint32_t dstOffset[4], uint32_t extent[3]);
|
|
|
|
void lovrTextureBlit(Texture* src, Texture* dst, uint32_t srcOffset[4], uint32_t dstOffset[4], uint32_t srcExtent[3], uint32_t dstExtent[3], FilterMode filter);
|
|
|
|
void lovrTextureClear(Texture* texture, float value[4], uint32_t layer, uint32_t layerCount, uint32_t level, uint32_t levelCount);
|
|
|
|
void lovrTextureGenerateMipmaps(Texture* texture, uint32_t base, uint32_t count);
|
2023-10-31 23:08:00 +00:00
|
|
|
Material* lovrTextureToMaterial(Texture* texture);
|
2022-04-30 03:38:34 +00:00
|
|
|
|
2022-05-01 22:47:17 +00:00
|
|
|
// Sampler
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
WRAP_CLAMP,
|
|
|
|
WRAP_REPEAT,
|
|
|
|
WRAP_MIRROR
|
|
|
|
} WrapMode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
COMPARE_NONE,
|
|
|
|
COMPARE_EQUAL,
|
|
|
|
COMPARE_NEQUAL,
|
|
|
|
COMPARE_LESS,
|
|
|
|
COMPARE_LEQUAL,
|
|
|
|
COMPARE_GREATER,
|
|
|
|
COMPARE_GEQUAL
|
|
|
|
} CompareMode;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
FilterMode min, mag, mip;
|
|
|
|
WrapMode wrap[3];
|
|
|
|
CompareMode compare;
|
|
|
|
float anisotropy;
|
|
|
|
float range[2];
|
|
|
|
} SamplerInfo;
|
|
|
|
|
2022-06-08 03:42:10 +00:00
|
|
|
Sampler* lovrGraphicsGetDefaultSampler(FilterMode mode);
|
2022-07-13 07:07:15 +00:00
|
|
|
Sampler* lovrSamplerCreate(const SamplerInfo* info);
|
2022-05-01 22:47:17 +00:00
|
|
|
void lovrSamplerDestroy(void* ref);
|
|
|
|
const SamplerInfo* lovrSamplerGetInfo(Sampler* sampler);
|
|
|
|
|
2022-05-09 18:47:06 +00:00
|
|
|
// Shader
|
|
|
|
|
2022-05-28 03:47:07 +00:00
|
|
|
typedef enum {
|
|
|
|
SHADER_UNLIT,
|
2022-09-10 18:07:40 +00:00
|
|
|
SHADER_NORMAL,
|
2022-07-04 07:18:38 +00:00
|
|
|
SHADER_FONT,
|
2022-08-02 05:10:06 +00:00
|
|
|
SHADER_CUBEMAP,
|
|
|
|
SHADER_EQUIRECT,
|
2023-04-27 05:18:06 +00:00
|
|
|
SHADER_FILL_2D,
|
2022-08-26 16:56:33 +00:00
|
|
|
SHADER_FILL_ARRAY,
|
2023-04-27 04:36:30 +00:00
|
|
|
SHADER_ANIMATOR,
|
|
|
|
SHADER_BLENDER,
|
2023-04-30 06:02:37 +00:00
|
|
|
SHADER_TALLY_MERGE,
|
2022-05-28 03:47:07 +00:00
|
|
|
DEFAULT_SHADER_COUNT
|
|
|
|
} DefaultShader;
|
|
|
|
|
2024-02-20 23:07:30 +00:00
|
|
|
typedef enum {
|
|
|
|
SHADER_GRAPHICS,
|
|
|
|
SHADER_COMPUTE
|
|
|
|
} ShaderType;
|
|
|
|
|
2022-05-09 18:47:06 +00:00
|
|
|
typedef enum {
|
|
|
|
STAGE_VERTEX,
|
|
|
|
STAGE_FRAGMENT,
|
2024-02-20 23:07:30 +00:00
|
|
|
STAGE_COMPUTE
|
2022-05-09 18:47:06 +00:00
|
|
|
} ShaderStage;
|
|
|
|
|
2022-07-10 06:09:02 +00:00
|
|
|
typedef struct {
|
2024-02-20 23:07:30 +00:00
|
|
|
ShaderStage stage;
|
2022-07-10 06:09:02 +00:00
|
|
|
const void* code;
|
|
|
|
size_t size;
|
|
|
|
} ShaderSource;
|
|
|
|
|
2022-05-09 18:47:06 +00:00
|
|
|
typedef struct {
|
|
|
|
const char* name;
|
|
|
|
uint32_t id;
|
|
|
|
double value;
|
|
|
|
} ShaderFlag;
|
|
|
|
|
|
|
|
typedef struct {
|
2024-02-20 23:07:30 +00:00
|
|
|
ShaderType type;
|
|
|
|
ShaderSource* stages;
|
|
|
|
uint32_t stageCount;
|
2022-05-09 18:47:06 +00:00
|
|
|
ShaderFlag* flags;
|
2024-02-20 23:07:30 +00:00
|
|
|
uint32_t flagCount;
|
2022-05-09 18:47:06 +00:00
|
|
|
const char* label;
|
2024-02-24 22:34:29 +00:00
|
|
|
bool isDefault;
|
2022-05-09 18:47:06 +00:00
|
|
|
} ShaderInfo;
|
|
|
|
|
2023-09-29 05:03:08 +00:00
|
|
|
typedef void* ShaderIncluder(const char* filename, size_t* bytesRead);
|
|
|
|
|
2024-02-20 23:07:30 +00:00
|
|
|
void lovrGraphicsCompileShader(ShaderSource* stages, ShaderSource* outputs, uint32_t count, ShaderIncluder* includer);
|
2022-08-02 05:10:06 +00:00
|
|
|
ShaderSource lovrGraphicsGetDefaultShaderSource(DefaultShader type, ShaderStage stage);
|
2022-05-28 03:47:07 +00:00
|
|
|
Shader* lovrGraphicsGetDefaultShader(DefaultShader type);
|
2022-07-13 07:07:15 +00:00
|
|
|
Shader* lovrShaderCreate(const ShaderInfo* info);
|
2022-05-22 22:10:07 +00:00
|
|
|
Shader* lovrShaderClone(Shader* parent, ShaderFlag* flags, uint32_t count);
|
2022-05-09 18:47:06 +00:00
|
|
|
void lovrShaderDestroy(void* ref);
|
|
|
|
const ShaderInfo* lovrShaderGetInfo(Shader* shader);
|
2022-07-04 05:59:49 +00:00
|
|
|
bool lovrShaderHasStage(Shader* shader, ShaderStage stage);
|
2022-07-04 06:04:56 +00:00
|
|
|
bool lovrShaderHasAttribute(Shader* shader, const char* name, uint32_t location);
|
2022-08-06 20:06:42 +00:00
|
|
|
void lovrShaderGetWorkgroupSize(Shader* shader, uint32_t size[3]);
|
2023-08-25 20:42:09 +00:00
|
|
|
const DataField* lovrShaderGetBufferFormat(Shader* shader, const char* name, uint32_t* fieldCount);
|
2022-05-09 18:47:06 +00:00
|
|
|
|
2022-06-17 06:49:09 +00:00
|
|
|
// Material
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
float color[4];
|
|
|
|
float glow[4];
|
|
|
|
float uvShift[2];
|
|
|
|
float uvScale[2];
|
2022-06-21 01:17:37 +00:00
|
|
|
float sdfRange[2];
|
2022-06-17 06:49:09 +00:00
|
|
|
float metalness;
|
|
|
|
float roughness;
|
|
|
|
float clearcoat;
|
|
|
|
float clearcoatRoughness;
|
|
|
|
float occlusionStrength;
|
|
|
|
float normalScale;
|
|
|
|
float alphaCutoff;
|
|
|
|
} MaterialData;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
MaterialData data;
|
|
|
|
Texture* texture;
|
|
|
|
Texture* glowTexture;
|
|
|
|
Texture* metalnessTexture;
|
|
|
|
Texture* roughnessTexture;
|
|
|
|
Texture* clearcoatTexture;
|
2022-09-02 22:33:18 +00:00
|
|
|
Texture* occlusionTexture;
|
2022-06-17 06:49:09 +00:00
|
|
|
Texture* normalTexture;
|
|
|
|
} MaterialInfo;
|
|
|
|
|
2022-07-13 07:07:15 +00:00
|
|
|
Material* lovrMaterialCreate(const MaterialInfo* info);
|
2022-06-17 06:49:09 +00:00
|
|
|
void lovrMaterialDestroy(void* ref);
|
|
|
|
const MaterialInfo* lovrMaterialGetInfo(Material* material);
|
|
|
|
|
2022-06-19 00:43:12 +00:00
|
|
|
// Font
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
struct Rasterizer* rasterizer;
|
|
|
|
double spread;
|
|
|
|
} FontInfo;
|
|
|
|
|
2022-06-30 03:17:26 +00:00
|
|
|
typedef struct ColoredString {
|
2022-06-28 04:42:51 +00:00
|
|
|
float color[4];
|
|
|
|
const char* string;
|
|
|
|
size_t length;
|
2022-06-28 04:43:23 +00:00
|
|
|
} ColoredString;
|
2022-06-28 04:42:51 +00:00
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
ALIGN_LEFT,
|
|
|
|
ALIGN_CENTER,
|
|
|
|
ALIGN_RIGHT
|
|
|
|
} HorizontalAlign;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
ALIGN_TOP,
|
|
|
|
ALIGN_MIDDLE,
|
|
|
|
ALIGN_BOTTOM
|
|
|
|
} VerticalAlign;
|
|
|
|
|
2022-07-04 05:40:05 +00:00
|
|
|
typedef struct {
|
|
|
|
struct { float x, y; } position;
|
|
|
|
struct { uint16_t u, v; } uv;
|
|
|
|
struct { uint8_t r, g, b, a; } color;
|
|
|
|
} GlyphVertex;
|
|
|
|
|
2022-07-30 22:20:01 +00:00
|
|
|
Font* lovrGraphicsGetDefaultFont(void);
|
2022-07-13 07:07:15 +00:00
|
|
|
Font* lovrFontCreate(const FontInfo* info);
|
2022-06-19 00:43:12 +00:00
|
|
|
void lovrFontDestroy(void* ref);
|
|
|
|
const FontInfo* lovrFontGetInfo(Font* font);
|
|
|
|
float lovrFontGetPixelDensity(Font* font);
|
|
|
|
void lovrFontSetPixelDensity(Font* font, float pixelDensity);
|
2022-06-26 02:54:13 +00:00
|
|
|
float lovrFontGetLineSpacing(Font* font);
|
|
|
|
void lovrFontSetLineSpacing(Font* font, float spacing);
|
2022-07-04 22:22:54 +00:00
|
|
|
float lovrFontGetKerning(Font* font, uint32_t first, uint32_t second);
|
2022-07-01 00:25:47 +00:00
|
|
|
float lovrFontGetWidth(Font* font, ColoredString* strings, uint32_t count);
|
2022-07-01 00:07:47 +00:00
|
|
|
void lovrFontGetLines(Font* font, ColoredString* strings, uint32_t count, float wrap, void (*callback)(void* context, const char* string, size_t length), void* context);
|
2022-07-17 15:59:39 +00:00
|
|
|
void lovrFontGetVertices(Font* font, ColoredString* strings, uint32_t count, float wrap, HorizontalAlign halign, VerticalAlign valign, GlyphVertex* vertices, uint32_t* glyphCount, uint32_t* lineCount, Material** material, bool flip);
|
2022-06-19 00:43:12 +00:00
|
|
|
|
2023-06-11 05:06:29 +00:00
|
|
|
// Mesh
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
MESH_CPU,
|
|
|
|
MESH_GPU
|
|
|
|
} MeshStorage;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
DRAW_POINTS,
|
|
|
|
DRAW_LINES,
|
|
|
|
DRAW_TRIANGLES
|
|
|
|
} DrawMode;
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
Buffer* vertexBuffer;
|
2023-08-25 20:42:09 +00:00
|
|
|
DataField* vertexFormat;
|
2023-06-11 05:06:29 +00:00
|
|
|
MeshStorage storage;
|
|
|
|
} MeshInfo;
|
|
|
|
|
|
|
|
Mesh* lovrMeshCreate(const MeshInfo* info, void** data);
|
|
|
|
void lovrMeshDestroy(void* ref);
|
|
|
|
const DataField* lovrMeshGetVertexFormat(Mesh* mesh);
|
|
|
|
Buffer* lovrMeshGetVertexBuffer(Mesh* mesh);
|
|
|
|
Buffer* lovrMeshGetIndexBuffer(Mesh* mesh);
|
|
|
|
void lovrMeshSetIndexBuffer(Mesh* mesh, Buffer* buffer);
|
|
|
|
void* lovrMeshGetVertices(Mesh* mesh, uint32_t index, uint32_t count);
|
|
|
|
void* lovrMeshSetVertices(Mesh* mesh, uint32_t index, uint32_t count);
|
2023-08-25 20:42:09 +00:00
|
|
|
void* lovrMeshGetIndices(Mesh* mesh, uint32_t* count, DataType* type);
|
2023-06-11 05:06:29 +00:00
|
|
|
void* lovrMeshSetIndices(Mesh* mesh, uint32_t count, DataType type);
|
|
|
|
void lovrMeshGetTriangles(Mesh* mesh, float** vertices, uint32_t** indices, uint32_t* vertexCount, uint32_t* indexCount);
|
|
|
|
bool lovrMeshGetBoundingBox(Mesh* mesh, float box[6]);
|
|
|
|
void lovrMeshSetBoundingBox(Mesh* mesh, float box[6]);
|
|
|
|
bool lovrMeshComputeBoundingBox(Mesh* mesh);
|
|
|
|
DrawMode lovrMeshGetDrawMode(Mesh* mesh);
|
|
|
|
void lovrMeshSetDrawMode(Mesh* mesh, DrawMode mode);
|
|
|
|
void lovrMeshGetDrawRange(Mesh* mesh, uint32_t* start, uint32_t* count, uint32_t* offset);
|
|
|
|
void lovrMeshSetDrawRange(Mesh* mesh, uint32_t start, uint32_t count, uint32_t offset);
|
|
|
|
Material* lovrMeshGetMaterial(Mesh* mesh);
|
|
|
|
void lovrMeshSetMaterial(Mesh* mesh, Material* material);
|
|
|
|
|
2022-07-04 00:26:31 +00:00
|
|
|
// Model
|
|
|
|
|
|
|
|
typedef struct {
|
|
|
|
struct ModelData* data;
|
2023-06-10 01:32:54 +00:00
|
|
|
bool materials;
|
2022-07-04 00:26:31 +00:00
|
|
|
bool mipmaps;
|
|
|
|
} ModelInfo;
|
|
|
|
|
|
|
|
typedef enum {
|
2022-08-18 05:33:43 +00:00
|
|
|
ORIGIN_ROOT,
|
|
|
|
ORIGIN_PARENT
|
|
|
|
} OriginType;
|
2022-07-04 00:26:31 +00:00
|
|
|
|
2022-07-13 07:07:15 +00:00
|
|
|
Model* lovrModelCreate(const ModelInfo* info);
|
2023-05-10 07:47:16 +00:00
|
|
|
Model* lovrModelClone(Model* model);
|
2022-07-04 00:26:31 +00:00
|
|
|
void lovrModelDestroy(void* ref);
|
2022-07-07 02:22:02 +00:00
|
|
|
const ModelInfo* lovrModelGetInfo(Model* model);
|
2022-07-13 02:35:23 +00:00
|
|
|
void lovrModelResetNodeTransforms(Model* model);
|
2023-10-18 22:51:52 +00:00
|
|
|
void lovrModelResetBlendShapes(Model* model);
|
2022-07-04 00:26:31 +00:00
|
|
|
void lovrModelAnimate(Model* model, uint32_t animationIndex, float time, float alpha);
|
2023-03-15 06:25:49 +00:00
|
|
|
float lovrModelGetBlendShapeWeight(Model* model, uint32_t index);
|
|
|
|
void lovrModelSetBlendShapeWeight(Model* model, uint32_t index, float weight);
|
2023-09-22 05:24:57 +00:00
|
|
|
void lovrModelGetNodeTransform(Model* model, uint32_t node, float* position, float* scale, float* rotation, OriginType origin);
|
|
|
|
void lovrModelSetNodeTransform(Model* model, uint32_t node, float* position, float* scale, float* rotation, float alpha);
|
2022-07-04 00:26:31 +00:00
|
|
|
Buffer* lovrModelGetVertexBuffer(Model* model);
|
|
|
|
Buffer* lovrModelGetIndexBuffer(Model* model);
|
2023-06-11 05:06:29 +00:00
|
|
|
Mesh* lovrModelGetMesh(Model* model, uint32_t index);
|
|
|
|
Texture* lovrModelGetTexture(Model* model, uint32_t index);
|
|
|
|
Material* lovrModelGetMaterial(Model* model, uint32_t index);
|
2022-07-04 00:26:31 +00:00
|
|
|
|
2022-07-14 07:05:58 +00:00
|
|
|
// Readback
|
|
|
|
|
2023-04-30 01:25:58 +00:00
|
|
|
Readback* lovrReadbackCreateBuffer(Buffer* buffer, uint32_t offset, uint32_t extent);
|
2023-10-03 13:41:37 +00:00
|
|
|
Readback* lovrReadbackCreateTexture(Texture* texture, uint32_t offset[4], uint32_t extent[3]);
|
2022-07-14 07:05:58 +00:00
|
|
|
void lovrReadbackDestroy(void* ref);
|
|
|
|
bool lovrReadbackIsComplete(Readback* readback);
|
|
|
|
bool lovrReadbackWait(Readback* readback);
|
2023-10-04 14:43:00 +00:00
|
|
|
void* lovrReadbackGetData(Readback* readback, DataField** format, uint32_t* count);
|
2022-07-17 16:50:15 +00:00
|
|
|
struct Blob* lovrReadbackGetBlob(Readback* readback);
|
2022-07-14 07:05:58 +00:00
|
|
|
struct Image* lovrReadbackGetImage(Readback* readback);
|
|
|
|
|
2022-04-29 05:30:31 +00:00
|
|
|
// Pass
|
|
|
|
|
2023-04-30 06:02:37 +00:00
|
|
|
typedef struct {
|
|
|
|
uint32_t draws;
|
|
|
|
uint32_t computes;
|
2023-06-23 21:41:39 +00:00
|
|
|
uint32_t drawsCulled;
|
2023-09-12 03:19:36 +00:00
|
|
|
size_t cpuMemoryReserved;
|
|
|
|
size_t cpuMemoryUsed;
|
2023-05-07 06:36:33 +00:00
|
|
|
double submitTime;
|
|
|
|
double gpuTime;
|
2023-04-30 06:02:37 +00:00
|
|
|
} PassStats;
|
|
|
|
|
2022-04-29 05:30:31 +00:00
|
|
|
typedef enum {
|
2023-04-30 06:02:37 +00:00
|
|
|
LOAD_CLEAR,
|
|
|
|
LOAD_DISCARD,
|
|
|
|
LOAD_KEEP
|
|
|
|
} LoadAction;
|
2022-04-29 05:30:31 +00:00
|
|
|
|
2022-05-07 00:26:38 +00:00
|
|
|
typedef enum {
|
|
|
|
STACK_TRANSFORM,
|
2022-07-30 22:03:54 +00:00
|
|
|
STACK_STATE
|
2022-05-07 00:26:38 +00:00
|
|
|
} StackType;
|
|
|
|
|
2022-05-11 19:50:26 +00:00
|
|
|
typedef enum {
|
|
|
|
BLEND_ALPHA_MULTIPLY,
|
|
|
|
BLEND_PREMULTIPLIED
|
|
|
|
} BlendAlphaMode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
BLEND_ALPHA,
|
|
|
|
BLEND_ADD,
|
|
|
|
BLEND_SUBTRACT,
|
|
|
|
BLEND_MULTIPLY,
|
|
|
|
BLEND_LIGHTEN,
|
|
|
|
BLEND_DARKEN,
|
|
|
|
BLEND_SCREEN,
|
|
|
|
BLEND_NONE
|
|
|
|
} BlendMode;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
CULL_NONE,
|
|
|
|
CULL_FRONT,
|
|
|
|
CULL_BACK
|
|
|
|
} CullMode;
|
|
|
|
|
2022-06-22 07:05:26 +00:00
|
|
|
typedef enum {
|
|
|
|
STYLE_FILL,
|
|
|
|
STYLE_LINE
|
|
|
|
} DrawStyle;
|
|
|
|
|
2022-05-11 19:50:26 +00:00
|
|
|
typedef enum {
|
|
|
|
STENCIL_KEEP,
|
|
|
|
STENCIL_ZERO,
|
|
|
|
STENCIL_REPLACE,
|
|
|
|
STENCIL_INCREMENT,
|
|
|
|
STENCIL_DECREMENT,
|
|
|
|
STENCIL_INCREMENT_WRAP,
|
|
|
|
STENCIL_DECREMENT_WRAP,
|
|
|
|
STENCIL_INVERT
|
|
|
|
} StencilAction;
|
|
|
|
|
|
|
|
typedef enum {
|
|
|
|
WINDING_COUNTERCLOCKWISE,
|
|
|
|
WINDING_CLOCKWISE
|
|
|
|
} Winding;
|
|
|
|
|
2022-08-03 05:00:11 +00:00
|
|
|
Pass* lovrGraphicsGetWindowPass(void);
|
2023-04-30 06:02:37 +00:00
|
|
|
Pass* lovrPassCreate(void);
|
2022-04-29 05:30:31 +00:00
|
|
|
void lovrPassDestroy(void* ref);
|
2023-04-30 06:02:37 +00:00
|
|
|
void lovrPassReset(Pass* pass);
|
2023-06-23 21:41:39 +00:00
|
|
|
const PassStats* lovrPassGetStats(Pass* pass);
|
2023-04-30 06:02:37 +00:00
|
|
|
|
|
|
|
void lovrPassGetCanvas(Pass* pass, Texture* color[4], Texture** depthTexture, uint32_t* depthFormat, uint32_t* samples);
|
|
|
|
void lovrPassSetCanvas(Pass* pass, Texture* color[4], Texture* depthTexture, uint32_t depthFormat, uint32_t samples);
|
|
|
|
void lovrPassGetClear(Pass* pass, LoadAction loads[4], float clears[4][4], LoadAction* depthLoad, float* depthClear);
|
|
|
|
void lovrPassSetClear(Pass* pass, LoadAction loads[4], float clears[4][4], LoadAction depthLoad, float depthClear);
|
|
|
|
uint32_t lovrPassGetAttachmentCount(Pass* pass, bool* depth);
|
2022-08-03 05:00:11 +00:00
|
|
|
uint32_t lovrPassGetWidth(Pass* pass);
|
|
|
|
uint32_t lovrPassGetHeight(Pass* pass);
|
|
|
|
|
2023-09-30 20:19:31 +00:00
|
|
|
uint32_t lovrPassGetViewCount(Pass* pass);
|
2022-05-30 19:29:00 +00:00
|
|
|
void lovrPassGetViewMatrix(Pass* pass, uint32_t index, float viewMatrix[16]);
|
|
|
|
void lovrPassSetViewMatrix(Pass* pass, uint32_t index, float viewMatrix[16]);
|
|
|
|
void lovrPassGetProjection(Pass* pass, uint32_t index, float projection[16]);
|
|
|
|
void lovrPassSetProjection(Pass* pass, uint32_t index, float projection[16]);
|
2023-04-30 06:02:37 +00:00
|
|
|
void lovrPassGetViewport(Pass* pass, float viewport[6]);
|
|
|
|
void lovrPassSetViewport(Pass* pass, float viewport[6]);
|
|
|
|
void lovrPassGetScissor(Pass* pass, uint32_t scissor[4]);
|
|
|
|
void lovrPassSetScissor(Pass* pass, uint32_t scissor[4]);
|
2022-08-03 05:00:11 +00:00
|
|
|
|
2022-05-07 00:26:38 +00:00
|
|
|
void lovrPassPush(Pass* pass, StackType stack);
|
|
|
|
void lovrPassPop(Pass* pass, StackType stack);
|
|
|
|
void lovrPassOrigin(Pass* pass);
|
|
|
|
void lovrPassTranslate(Pass* pass, float* translation);
|
|
|
|
void lovrPassRotate(Pass* pass, float* rotation);
|
|
|
|
void lovrPassScale(Pass* pass, float* scale);
|
|
|
|
void lovrPassTransform(Pass* pass, float* transform);
|
2022-08-03 05:00:11 +00:00
|
|
|
|
2022-05-11 19:50:26 +00:00
|
|
|
void lovrPassSetAlphaToCoverage(Pass* pass, bool enabled);
|
2023-02-05 23:06:18 +00:00
|
|
|
void lovrPassSetBlendMode(Pass* pass, uint32_t index, BlendMode mode, BlendAlphaMode alphaMode);
|
2022-05-12 00:30:08 +00:00
|
|
|
void lovrPassSetColor(Pass* pass, float color[4]);
|
2023-02-05 23:06:18 +00:00
|
|
|
void lovrPassSetColorWrite(Pass* pass, uint32_t index, bool r, bool g, bool b, bool a);
|
2022-05-11 19:50:26 +00:00
|
|
|
void lovrPassSetDepthTest(Pass* pass, CompareMode test);
|
|
|
|
void lovrPassSetDepthWrite(Pass* pass, bool write);
|
|
|
|
void lovrPassSetDepthOffset(Pass* pass, float offset, float sloped);
|
|
|
|
void lovrPassSetDepthClamp(Pass* pass, bool clamp);
|
2023-06-23 21:41:39 +00:00
|
|
|
void lovrPassSetFaceCull(Pass* pass, CullMode mode);
|
2022-07-18 02:53:31 +00:00
|
|
|
void lovrPassSetFont(Pass* pass, Font* font);
|
2023-10-31 23:08:00 +00:00
|
|
|
void lovrPassSetMaterial(Pass* pass, Material* material);
|
2023-06-11 05:06:29 +00:00
|
|
|
void lovrPassSetMeshMode(Pass* pass, DrawMode mode);
|
2022-06-08 03:42:10 +00:00
|
|
|
void lovrPassSetSampler(Pass* pass, Sampler* sampler);
|
2022-05-11 19:50:26 +00:00
|
|
|
void lovrPassSetShader(Pass* pass, Shader* shader);
|
|
|
|
void lovrPassSetStencilTest(Pass* pass, CompareMode test, uint8_t value, uint8_t mask);
|
|
|
|
void lovrPassSetStencilWrite(Pass* pass, StencilAction actions[3], uint8_t value, uint8_t mask);
|
2023-06-23 21:41:39 +00:00
|
|
|
void lovrPassSetViewCull(Pass* pass, bool enable);
|
2022-05-11 19:50:26 +00:00
|
|
|
void lovrPassSetWinding(Pass* pass, Winding winding);
|
|
|
|
void lovrPassSetWireframe(Pass* pass, bool wireframe);
|
2022-08-03 05:00:11 +00:00
|
|
|
|
2024-02-05 23:03:28 +00:00
|
|
|
void lovrPassSendBuffer(Pass* pass, const char* name, size_t length, Buffer* buffer, uint32_t offset, uint32_t extent);
|
|
|
|
void lovrPassSendTexture(Pass* pass, const char* name, size_t length, Texture* texture);
|
|
|
|
void lovrPassSendSampler(Pass* pass, const char* name, size_t length, Sampler* sampler);
|
|
|
|
void lovrPassSendData(Pass* pass, const char* name, size_t length, void** data, DataField** format);
|
2022-08-03 05:00:11 +00:00
|
|
|
|
2022-05-30 22:36:31 +00:00
|
|
|
void lovrPassPoints(Pass* pass, uint32_t count, float** vertices);
|
2022-06-04 08:33:50 +00:00
|
|
|
void lovrPassLine(Pass* pass, uint32_t count, float** vertices);
|
2022-06-22 07:05:26 +00:00
|
|
|
void lovrPassPlane(Pass* pass, float* transform, DrawStyle style, uint32_t cols, uint32_t rows);
|
2023-01-27 05:24:37 +00:00
|
|
|
void lovrPassRoundrect(Pass* pass, float* transform, float radius, uint32_t segments);
|
2022-06-22 07:05:26 +00:00
|
|
|
void lovrPassBox(Pass* pass, float* transform, DrawStyle style);
|
|
|
|
void lovrPassCircle(Pass* pass, float* transform, DrawStyle style, float angle1, float angle2, uint32_t segments);
|
2022-06-24 04:23:16 +00:00
|
|
|
void lovrPassSphere(Pass* pass, float* transform, uint32_t segmentsH, uint32_t segmentsV);
|
2022-06-25 06:01:22 +00:00
|
|
|
void lovrPassCylinder(Pass* pass, float* transform, bool capped, float angle1, float angle2, uint32_t segments);
|
2022-07-17 23:38:00 +00:00
|
|
|
void lovrPassCone(Pass* pass, float* transform, uint32_t segments);
|
2022-07-09 23:38:25 +00:00
|
|
|
void lovrPassCapsule(Pass* pass, float* transform, uint32_t segments);
|
2022-06-24 02:52:37 +00:00
|
|
|
void lovrPassTorus(Pass* pass, float* transform, uint32_t segmentsT, uint32_t segmentsP);
|
2022-07-18 02:53:31 +00:00
|
|
|
void lovrPassText(Pass* pass, ColoredString* strings, uint32_t count, float* transform, float wrap, HorizontalAlign halign, VerticalAlign valign);
|
2022-07-04 07:18:38 +00:00
|
|
|
void lovrPassSkybox(Pass* pass, Texture* texture);
|
2022-06-25 02:59:48 +00:00
|
|
|
void lovrPassFill(Pass* pass, Texture* texture);
|
2022-06-22 03:05:57 +00:00
|
|
|
void lovrPassMonkey(Pass* pass, float* transform);
|
2023-06-11 05:06:29 +00:00
|
|
|
void lovrPassDrawModel(Pass* pass, Model* model, float* transform, uint32_t instances);
|
|
|
|
void lovrPassDrawMesh(Pass* pass, Mesh* mesh, float* transform, uint32_t instances);
|
2023-06-10 03:15:22 +00:00
|
|
|
void lovrPassDrawTexture(Pass* pass, Texture* texture, float* transform);
|
2024-01-18 00:05:37 +00:00
|
|
|
void lovrPassMesh(Pass* pass, Buffer* vertices, Buffer* indices, float* transform, uint32_t start, uint32_t count, uint32_t instances, uint32_t baseVertex);
|
2022-08-06 05:11:06 +00:00
|
|
|
void lovrPassMeshIndirect(Pass* pass, Buffer* vertices, Buffer* indices, Buffer* indirect, uint32_t count, uint32_t offset, uint32_t stride);
|
2022-08-03 05:00:11 +00:00
|
|
|
|
2023-06-01 01:56:09 +00:00
|
|
|
uint32_t lovrPassBeginTally(Pass* pass);
|
|
|
|
uint32_t lovrPassFinishTally(Pass* pass);
|
2023-05-04 05:24:04 +00:00
|
|
|
Buffer* lovrPassGetTallyBuffer(Pass* pass, uint32_t* offset);
|
|
|
|
void lovrPassSetTallyBuffer(Pass* pass, Buffer* buffer, uint32_t offset);
|
|
|
|
|
2022-06-04 18:54:05 +00:00
|
|
|
void lovrPassCompute(Pass* pass, uint32_t x, uint32_t y, uint32_t z, Buffer* indirect, uint32_t offset);
|
2023-05-03 23:45:01 +00:00
|
|
|
void lovrPassBarrier(Pass* pass);
|