lpnf
/
lovr
mirror of https://github.com/bjornbytes/lovr.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

lovr*Create -> lovr*Init; lovr*Create macro;

This commit is contained in:
bjorn 2018-12-19 00:15:08 -08:00 committed by Bjorn Swenson
parent 60a12a6b7e
commit 155a0c1449
48 changed files with 142 additions and 263 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
src/audio/microphone.c
View File

@ -1,23 +1,14 @@
#include "audio/microphone.h"
#include "audio/audio.h"
Microphone* lovrMicrophoneCreate(const char* name, int samples, int sampleRate, int bitDepth, int channelCount) {
Microphone* microphone = lovrAlloc(Microphone, lovrMicrophoneDestroy);
if (!microphone) return NULL;
Microphone* lovrMicrophoneInit(Microphone* microphone, const char* name, int samples, int sampleRate, int bitDepth, int channelCount) {
ALCdevice* device = alcCaptureOpenDevice(name, sampleRate, lovrAudioConvertFormat(bitDepth, channelCount), samples);
if (!device) {
free(microphone);
return NULL;
}
lovrAssert(device, "Error opening capture device for microphone '%s'", name);
microphone->device = device;
microphone->name = name ? name : alcGetString(device, ALC_CAPTURE_DEVICE_SPECIFIER);
microphone->sampleRate = sampleRate;
microphone->bitDepth = bitDepth;
microphone->channelCount = channelCount;
return microphone;
}

3
src/audio/microphone.h
View File

@ -16,7 +16,8 @@ typedef struct {
int channelCount;
} Microphone;
Microphone* lovrMicrophoneCreate(const char* name, int samples, int sampleRate, int bitDepth, int channelCount);
Microphone* lovrMicrophoneInit(Microphone* microphone, const char* name, int samples, int sampleRate, int bitDepth, int channelCount);
#define lovrMicrophoneCreate(...) lovrMicrophoneInit(lovrAlloc(Microphone, lovrMicrophoneDestroy), __VA_ARGS__)
void lovrMicrophoneDestroy(void* ref);
int lovrMicrophoneGetBitDepth(Microphone* microphone);
int lovrMicrophoneGetChannelCount(Microphone* microphone);

12
src/audio/source.c
View File

@ -11,10 +11,7 @@ static ALenum lovrSourceGetState(Source* source) {
return state;
}
Source* lovrSourceCreateStatic(SoundData* soundData) {
Source* source = lovrAlloc(Source, lovrSourceDestroy);
if (!source) return NULL;
Source* lovrSourceInitStatic(Source* source, SoundData* soundData) {
ALenum format = lovrAudioConvertFormat(soundData->bitDepth, soundData->channelCount);
source->type = SOURCE_STATIC;
source->soundData = soundData;
@ -23,20 +20,15 @@ Source* lovrSourceCreateStatic(SoundData* soundData) {
alBufferData(source->buffers[0], format, soundData->blob.data, soundData->blob.size, soundData->sampleRate);
alSourcei(source->id, AL_BUFFER, source->buffers[0]);
lovrRetain(soundData);
return source;
}
Source* lovrSourceCreateStream(AudioStream* stream) {
Source* source = lovrAlloc(Source, lovrSourceDestroy);
if (!source) return NULL;
Source* lovrSourceInitStream(Source* source, AudioStream* stream) {
source->type = SOURCE_STREAM;
source->stream = stream;
alGenSources(1, &source->id);
alGenBuffers(SOURCE_BUFFERS, source->buffers);
lovrRetain(stream);
return source;
}

6
src/audio/source.h
View File

@ -29,8 +29,10 @@ typedef struct {
bool isLooping;
} Source;
Source* lovrSourceCreateStatic(SoundData* soundData);
Source* lovrSourceCreateStream(AudioStream* stream);
Source* lovrSourceInitStatic(Source* source, SoundData* soundData);
Source* lovrSourceInitStream(Source* source, AudioStream* stream);
#define lovrSourceCreateStatic(...) lovrSourceInitStatic(lovrAlloc(Source, lovrSourceDestroy), __VA_ARGS__)
#define lovrSourceCreateStream(...) lovrSourceInitStream(lovrAlloc(Source, lovrSourceDestroy), __VA_ARGS__)
void lovrSourceDestroy(void* ref);
SourceType lovrSourceGetType(Source* source);
int lovrSourceGetBitDepth(Source* source);

11
src/data/audioStream.c
View File

@ -3,16 +3,9 @@
#include "util.h"
#include <stdlib.h>
AudioStream* lovrAudioStreamCreate(Blob* blob, size_t bufferSize) {
AudioStream* stream = lovrAlloc(AudioStream, lovrAudioStreamDestroy);
if (!stream) return NULL;
AudioStream* lovrAudioStreamInit(AudioStream* stream, Blob* blob, size_t bufferSize) {
stb_vorbis* decoder = stb_vorbis_open_memory(blob->data, blob->size, NULL, NULL);
if (!decoder) {
free(stream);
return NULL;
}
lovrAssert(decoder, "Could not create audio stream for '%s'", blob->name);
stb_vorbis_info info = stb_vorbis_get_info(decoder);

3
src/data/audioStream.h
View File

@ -15,7 +15,8 @@ typedef struct {
Blob* blob;
} AudioStream;
AudioStream* lovrAudioStreamCreate(Blob* blob, size_t bufferSize);
AudioStream* lovrAudioStreamInit(AudioStream* stream, Blob* blob, size_t bufferSize);
#define lovrAudioStreamCreate(...) lovrAudioStreamInit(lovrAlloc(AudioStream, lovrAudioStreamDestroy), __VA_ARGS__)
void lovrAudioStreamDestroy(void* ref);
int lovrAudioStreamDecode(AudioStream* stream, short* destination, size_t size);
void lovrAudioStreamRewind(AudioStream* stream);

6
src/data/blob.c
View File

@ -1,13 +1,9 @@
#include "data/blob.h"
Blob* lovrBlobCreate(void* data, size_t size, const char* name) {
Blob* blob = lovrAlloc(Blob, lovrBlobDestroy);
if (!blob) return NULL;
Blob* lovrBlobInit(Blob* blob, void* data, size_t size, const char* name) {
blob->data = data;
blob->size = size;
blob->name = name;
return blob;
}

3
src/data/blob.h
View File

@ -11,5 +11,6 @@ typedef struct {
size_t seek;
} Blob;
Blob* lovrBlobCreate(void* data, size_t size, const char* name);
Blob* lovrBlobInit(Blob* blob, void* data, size_t size, const char* name);
#define lovrBlobCreate(...) lovrBlobInit(lovrAlloc(Blob, lovrBlobDestroy), __VA_ARGS__)
void lovrBlobDestroy(void* ref);

16
src/data/modelData.c
View File

@ -273,10 +273,7 @@ static void assimpFileClose(struct aiFileIO* io, struct aiFile* assimpFile) {
free(assimpFile);
}
ModelData* lovrModelDataCreate(Blob* blob) {
ModelData* modelData = lovrAlloc(ModelData, lovrModelDataDestroy);
if (!modelData) return NULL;
ModelData* lovrModelDataInit(ModelData* modelData, Blob* blob) {
struct aiFileIO assimpIO;
assimpIO.OpenProc = assimpFileOpen;
assimpIO.CloseProc = assimpFileClose;
@ -288,10 +285,7 @@ ModelData* lovrModelDataCreate(Blob* blob) {
unsigned int flags = aiProcessPreset_TargetRealtime_MaxQuality | aiProcess_OptimizeGraph | aiProcess_SplitByBoneCount;
const struct aiScene* scene = aiImportFileExWithProperties(blob->name, flags, &assimpIO, propertyStore);
aiReleasePropertyStore(propertyStore);
if (!scene) {
lovrThrow("Unable to load model from '%s': %s\n", blob->name, aiGetErrorString());
}
lovrAssert(scene, "Unable to load model from '%s': %s", blob->name, aiGetErrorString());
uint32_t vertexCount = 0;
bool hasNormals = false;
@ -543,15 +537,11 @@ ModelData* lovrModelDataCreate(Blob* blob) {
}
#else
static void aabbIterator(ModelData* modelData, ModelNode* node, float aabb[6]) {}
ModelData* lovrModelDataCreate(Blob* blob) {
ModelData* lovrModelDataInit(ModelData* modelData, Blob* blob) {
return NULL;
}
#endif
ModelData* lovrModelDataCreateEmpty() {
return lovrAlloc(ModelData, lovrModelDataDestroy);
}
void lovrModelDataDestroy(void* ref) {
ModelData* modelData = ref;

4
src/data/modelData.h
View File

@ -89,7 +89,7 @@ typedef struct {
int materialCount;
} ModelData;
ModelData* lovrModelDataCreate(Blob* blob);
ModelData* lovrModelDataCreateEmpty();
ModelData* lovrModelDataInit(ModelData* modelData, Blob* blob);
#define lovrModelDataCreate(...) lovrModelDataInit(lovrAlloc(ModelData, lovrModelDataDestroy), __VA_ARGS__)
void lovrModelDataDestroy(void* ref);
void lovrModelDataGetAABB(ModelData* modelData, float aabb[6]);

5
src/data/rasterizer.c
View File

@ -5,10 +5,7 @@
#include "msdfgen-c.h"
#include <math.h>
Rasterizer* lovrRasterizerCreate(Blob* blob, int size) {
Rasterizer* rasterizer = lovrAlloc(Rasterizer, lovrRasterizerDestroy);
if (!rasterizer) return NULL;
Rasterizer* lovrRasterizerInit(Rasterizer* rasterizer, Blob* blob, int size) {
stbtt_fontinfo* font = &rasterizer->font;
unsigned char* data = blob ? blob->data : VarelaRound_ttf;
if (!stbtt_InitFont(font, data, stbtt_GetFontOffsetForIndex(data, 0))) {

3
src/data/rasterizer.h
View File

@ -38,7 +38,8 @@ typedef struct {
typedef map_t(Glyph) map_glyph_t;
Rasterizer* lovrRasterizerCreate(Blob* blob, int size);
Rasterizer* lovrRasterizerInit(Rasterizer* rasterizer, Blob* blob, int size);
#define lovrRasterizerCreate(...) lovrRasterizerInit(lovrAlloc(Rasterizer, lovrRasterizerDestroy), __VA_ARGS__)
void lovrRasterizerDestroy(void* ref);
bool lovrRasterizerHasGlyph(Rasterizer* fontData, uint32_t character);
bool lovrRasterizerHasGlyphs(Rasterizer* fontData, const char* str);

17
src/data/soundData.c
View File

@ -2,24 +2,17 @@
#include "lib/stb/stb_vorbis.h"
#include <limits.h>
SoundData* lovrSoundDataCreate(int samples, int sampleRate, int bitDepth, int channelCount) {
SoundData* soundData = lovrAlloc(SoundData, lovrSoundDataDestroy);
if (!soundData) return NULL;
SoundData* lovrSoundDataInit(SoundData* soundData, int samples, int sampleRate, int bitDepth, int channelCount) {
soundData->samples = samples;
soundData->sampleRate = sampleRate;
soundData->bitDepth = bitDepth;
soundData->channelCount = channelCount;
soundData->blob.size = samples * channelCount * (bitDepth / 8);
soundData->blob.data = calloc(1, soundData->blob.size);
return soundData;
}
SoundData* lovrSoundDataCreateFromAudioStream(AudioStream* audioStream) {
SoundData* soundData = lovrAlloc(SoundData, lovrSoundDataDestroy);
if (!soundData) return NULL;
SoundData* lovrSoundDataInitFromAudioStream(SoundData* soundData, AudioStream* audioStream) {
soundData->samples = audioStream->samples;
soundData->sampleRate = audioStream->sampleRate;
soundData->bitDepth = audioStream->bitDepth;
@ -38,14 +31,10 @@ SoundData* lovrSoundDataCreateFromAudioStream(AudioStream* audioStream) {
return soundData;
}
SoundData* lovrSoundDataCreateFromBlob(Blob* blob) {
SoundData* soundData = lovrAlloc(SoundData, lovrSoundDataDestroy);
if (!soundData) return NULL;
SoundData* lovrSoundDataInitFromBlob(SoundData* soundData, Blob* blob) {
soundData->bitDepth = 16;
soundData->samples = stb_vorbis_decode_memory(blob->data, blob->size, &soundData->channelCount, &soundData->sampleRate, (short**) &soundData->blob.data);
soundData->blob.size = soundData->samples * soundData->channelCount * (soundData->bitDepth / 8);
return soundData;
}

9
src/data/soundData.h
View File

@ -11,9 +11,12 @@ typedef struct {
int bitDepth;
} SoundData;
SoundData* lovrSoundDataCreate(int samples, int sampleRate, int bitDepth, int channels);
SoundData* lovrSoundDataCreateFromAudioStream(AudioStream* audioStream);
SoundData* lovrSoundDataCreateFromBlob(Blob* blob);
SoundData* lovrSoundDataInit(SoundData* soundData, int samples, int sampleRate, int bitDepth, int channels);
SoundData* lovrSoundDataInitFromAudioStream(SoundData* soundData, AudioStream* audioStream);
SoundData* lovrSoundDataInitFromBlob(SoundData* soundData, Blob* blob);
#define lovrSoundDataCreate(...) lovrSoundDataInit(lovrAlloc(SoundData, lovrSoundDataDestroy), __VA_ARGS__)
#define lovrSoundDataCreateFromAudioStream(...) lovrSoundDataInitFromAudioStream(lovrAlloc(SoundData, lovrSoundDataDestroy), __VA_ARGS__)
#define lovrSoundDataCreateFromBlob(...) lovrSoundDataInitFromBlob(lovrAlloc(SoundData, lovrSoundDataDestroy), __VA_ARGS__)
float lovrSoundDataGetSample(SoundData* soundData, int index);
void lovrSoundDataSetSample(SoundData* soundData, int index, float value);
void lovrSoundDataDestroy(void* ref);

10
src/data/textureData.c
View File

@ -112,10 +112,7 @@ static int parseDDS(uint8_t* data, size_t size, TextureData* textureData) {
return 0;
}
TextureData* lovrTextureDataCreate(int width, int height, uint8_t value, TextureFormat format) {
TextureData* textureData = lovrAlloc(TextureData, lovrTextureDataDestroy);
if (!textureData) return NULL;
TextureData* lovrTextureDataInit(TextureData* textureData, int width, int height, uint8_t value, TextureFormat format) {
size_t pixelSize = 0;
switch (format) {
case FORMAT_RGB: pixelSize = 3; break;
@ -152,10 +149,7 @@ TextureData* lovrTextureDataCreate(int width, int height, uint8_t value, Texture
return textureData;
}
TextureData* lovrTextureDataCreateFromBlob(Blob* blob, bool flip) {
TextureData* textureData = lovrAlloc(TextureData, lovrTextureDataDestroy);
if (!textureData) return NULL;
TextureData* lovrTextureDataInitFromBlob(TextureData* textureData, Blob* blob, bool flip) {
vec_init(&textureData->mipmaps);
if (!parseDDS(blob->data, blob->size, textureData)) {

6
src/data/textureData.h
View File

@ -45,8 +45,10 @@ typedef struct {
vec_mipmap_t mipmaps;
} TextureData;
TextureData* lovrTextureDataCreate(int width, int height, uint8_t value, TextureFormat format);
TextureData* lovrTextureDataCreateFromBlob(Blob* blob, bool flip);
TextureData* lovrTextureDataInit(TextureData* textureData, int width, int height, uint8_t value, TextureFormat format);
TextureData* lovrTextureDataInitFromBlob(TextureData* textureData, Blob* blob, bool flip);
#define lovrTextureDataCreate(...) lovrTextureDataInit(lovrAlloc(TextureData, lovrTextureDataDestroy), __VA_ARGS__)
#define lovrTextureDataCreateFromBlob(...) lovrTextureDataInitFromBlob(lovrAlloc(TextureData, lovrTextureDataDestroy), __VA_ARGS__)
Color lovrTextureDataGetPixel(TextureData* textureData, int x, int y);
void lovrTextureDataSetPixel(TextureData* textureData, int x, int y, Color color);
bool lovrTextureDataEncode(TextureData* textureData, const char* filename);

5
src/data/vertexData.c
View File

@ -14,10 +14,7 @@ void vertexFormatAppend(VertexFormat* format, const char* name, AttributeType ty
format->stride += size * count;
}
VertexData* lovrVertexDataCreate(uint32_t count, VertexFormat* format) {
VertexData* vertexData = lovrAlloc(VertexData, lovrBlobDestroy);
if (!vertexData) return NULL;
VertexData* lovrVertexDataInit(VertexData* vertexData, uint32_t count, VertexFormat* format) {
if (format) {
vertexData->format = *format;
} else {

4
src/data/vertexData.h
View File

@ -46,4 +46,6 @@ typedef struct {
void vertexFormatInit(VertexFormat* format);
void vertexFormatAppend(VertexFormat* format, const char* name, AttributeType type, int count);
VertexData* lovrVertexDataCreate(uint32_t count, VertexFormat* format);
VertexData* lovrVertexDataInit(VertexData* vertexData, uint32_t count, VertexFormat* format);
#define lovrVertexDataCreate(...) lovrVertexDataInit(lovrAlloc(VertexData, lovrVertexDataDestroy), __VA_ARGS__)
#define lovrVertexDataDestroy lovrBlobDestroy

6
src/filesystem/file.c
View File

@ -2,12 +2,8 @@
#include <physfs.h>
#include <stdlib.h>
File* lovrFileCreate(const char* path) {
File* file = lovrAlloc(File, lovrFileDestroy);
if (!file) return NULL;
File* lovrFileInit(File* file ,const char* path) {
file->path = path;
return file;
}

3
src/filesystem/file.h
View File

@ -15,7 +15,8 @@ typedef struct {
FileMode mode;
} File;
File* lovrFileCreate(const char* filename);
File* lovrFileInit(File* file, const char* filename);
#define lovrFileCreate(...) lovrFileInit(lovrAlloc(File, lovrFileDestroy), __VA_ARGS__)
void lovrFileDestroy(void* ref);
int lovrFileOpen(File* file, FileMode mode);
void lovrFileClose(File* file);

5
src/graphics/animator.c
View File

@ -12,10 +12,7 @@ static int trackSortCallback(const void* a, const void* b) {
return ((Track*) a)->priority < ((Track*) b)->priority;
}
Animator* lovrAnimatorCreate(ModelData* modelData) {
Animator* animator = lovrAlloc(Animator, lovrAnimatorDestroy);
if (!animator) return NULL;
Animator* lovrAnimatorInit(Animator* animator, ModelData* modelData) {
lovrRetain(modelData);
animator->modelData = modelData;
map_init(&animator->trackMap);

3
src/graphics/animator.h
View File

@ -27,7 +27,8 @@ typedef struct {
float speed;
} Animator;
Animator* lovrAnimatorCreate(ModelData* modelData);
Animator* lovrAnimatorInit(Animator* animator, ModelData* modelData);
#define lovrAnimatorCreate(...) lovrAnimatorInit(lovrAlloc(Animator, lovrAnimatorDestroy), __VA_ARGS__)
void lovrAnimatorDestroy(void* ref);
void lovrAnimatorReset(Animator* animator);
void lovrAnimatorUpdate(Animator* animator, float dt);

3
src/graphics/buffer.h
View File

@ -17,7 +17,8 @@ typedef struct {
GPU_BUFFER_FIELDS
} Buffer;
Buffer* lovrBufferCreate(size_t size, void* data, BufferUsage usage, bool readable);
Buffer* lovrBufferInit(Buffer* buffer, size_t size, void* data, BufferUsage usage, bool readable);
#define lovrBufferCreate(...) lovrBufferInit(lovrAlloc(Buffer, lovrBufferDestroy), __VA_ARGS__)
void lovrBufferDestroy(void* ref);
size_t lovrBufferGetSize(Buffer* buffer);
BufferUsage lovrBufferGetUsage(Buffer* buffer);

6
src/graphics/canvas.h
View File

@ -35,8 +35,10 @@ typedef struct {
GPU_CANVAS_FIELDS
} Canvas;
Canvas* lovrCanvasCreate(int width, int height, CanvasFlags flags);
Canvas* lovrCanvasCreateFromHandle(int width, int height, CanvasFlags flags, uint32_t framebuffer, uint32_t depthBuffer, uint32_t resolveBuffer, int attachmentCount, bool immortal);
Canvas* lovrCanvasInit(Canvas* canvas, int width, int height, CanvasFlags flags);
Canvas* lovrCanvasInitFromHandle(Canvas* canvas, int width, int height, CanvasFlags flags, uint32_t framebuffer, uint32_t depthBuffer, uint32_t resolveBuffer, int attachmentCount, bool immortal);
#define lovrCanvasCreate(...) lovrCanvasInit(lovrAlloc(Canvas, lovrCanvasDestroy), __VA_ARGS__)
#define lovrCanvasCreateFromHandle(...) lovrCanvasInitFromHandle(lovrAlloc(Canvas, lovrCanvasDestroy), __VA_ARGS__)
void lovrCanvasDestroy(void* ref);
const Attachment* lovrCanvasGetAttachments(Canvas* canvas, int* count);
void lovrCanvasSetAttachments(Canvas* canvas, Attachment* attachments, int count);

5
src/graphics/font.c
View File

@ -23,10 +23,7 @@ static float* lovrFontAlignLine(float* x, float* lineEnd, float width, Horizonta
return x;
}
Font* lovrFontCreate(Rasterizer* rasterizer) {
Font* font = lovrAlloc(Font, lovrFontDestroy);
if (!font) return NULL;
Font* lovrFontInit(Font* font, Rasterizer* rasterizer) {
lovrRetain(rasterizer);
font->rasterizer = rasterizer;
font->lineHeight = 1.f;

3
src/graphics/font.h
View File

@ -38,7 +38,8 @@ typedef struct {
float pixelDensity;
} Font;
Font* lovrFontCreate(Rasterizer* rasterizer);
Font* lovrFontInit(Font* font, Rasterizer* rasterizer);
#define lovrFontCreate(...) lovrFontInit(lovrAlloc(Font, lovrFontDestroy), __VA_ARGS__)
void lovrFontDestroy(void* ref);
Rasterizer* lovrFontGetRasterizer(Font* font);
void lovrFontRender(Font* font, const char* str, float wrap, HorizontalAlign halign, VerticalAlign valign, float* vertices, float* offsety, uint32_t* vertexCount);

6
src/graphics/material.c
View File

@ -3,10 +3,7 @@
#include <math.h>
#include <stdlib.h>
Material* lovrMaterialCreate() {
Material* material = lovrAlloc(Material, lovrMaterialDestroy);
if (!material) return NULL;
Material* lovrMaterialInit(Material* material) {
for (int i = 0; i < MAX_MATERIAL_SCALARS; i++) {
material->scalars[i] = 1.f;
}
@ -20,7 +17,6 @@ Material* lovrMaterialCreate() {
}
lovrMaterialSetTransform(material, 0, 0, 1, 1, 0);
return material;
}

3
src/graphics/material.h
View File

@ -37,7 +37,8 @@ typedef struct {
bool dirty;
} Material;
Material* lovrMaterialCreate();
Material* lovrMaterialInit(Material* material);
#define lovrMaterialCreate() lovrMaterialInit(lovrAlloc(Material, lovrMaterialDestroy))
void lovrMaterialDestroy(void* ref);
void lovrMaterialBind(Material* material, Shader* shader);
bool lovrMaterialIsDirty(Material* material);

3
src/graphics/mesh.h
View File

@ -53,7 +53,8 @@ typedef struct {
GPU_MESH_FIELDS
} Mesh;
Mesh* lovrMeshCreate(uint32_t count, VertexFormat format, DrawMode drawMode, BufferUsage usage, bool readable);
Mesh* lovrMeshInit(Mesh* mesh, uint32_t count, VertexFormat format, DrawMode drawMode, BufferUsage usage, bool readable);
#define lovrMeshCreate(...) lovrMeshInit(lovrAlloc(Mesh, lovrMeshDestroy), __VA_ARGS__)
void lovrMeshDestroy(void* ref);
void lovrMeshAttachAttribute(Mesh* mesh, const char* name, MeshAttribute* attribute);
void lovrMeshDetachAttribute(Mesh* mesh, const char* name);

5
src/graphics/model.c
View File

@ -54,10 +54,7 @@ static void renderNode(Model* model, int nodeIndex, int instances) {
}
}
Model* lovrModelCreate(ModelData* modelData) {
Model* model = lovrAlloc(Model, lovrModelDestroy);
if (!model) return NULL;
Model* lovrModelInit(Model* model, ModelData* modelData) {
lovrRetain(modelData);
model->modelData = modelData;
model->aabbDirty = true;

3
src/graphics/model.h
View File

@ -23,7 +23,8 @@ typedef struct {
bool aabbDirty;
} Model;
Model* lovrModelCreate(ModelData* modelData);
Model* lovrModelInit(Model* model, ModelData* modelData);
#define lovrModelCreate(...) lovrModelInit(lovrAlloc(Model, lovrModelDestroy), __VA_ARGS__)
void lovrModelDestroy(void* ref);
void lovrModelDraw(Model* model, mat4 transform, int instances);
Animator* lovrModelGetAnimator(Model* model);

58
src/graphics/opengl.c
View File

@ -875,10 +875,7 @@ const GpuStats* lovrGpuGetStats() {
// Texture
Texture* lovrTextureCreate(TextureType type, TextureData** slices, int sliceCount, bool srgb, bool mipmaps, int msaa) {
Texture* texture = lovrAlloc(Texture, lovrTextureDestroy);
if (!texture) return NULL;
Texture* lovrTextureInit(Texture* texture, TextureType type, TextureData** slices, int sliceCount, bool srgb, bool mipmaps, int msaa) {
texture->type = type;
texture->srgb = srgb;
texture->mipmaps = mipmaps;
@ -904,10 +901,7 @@ Texture* lovrTextureCreate(TextureType type, TextureData** slices, int sliceCoun
return texture;
}
Texture* lovrTextureCreateFromHandle(uint32_t handle, TextureType type) {
Texture* texture = lovrAlloc(Texture, lovrTextureDestroy);
if (!texture) return NULL;
Texture* lovrTextureInitFromHandle(Texture* texture, uint32_t handle, TextureType type) {
texture->type = type;
texture->id = handle;
texture->target = convertTextureTarget(type);
@ -1147,10 +1141,7 @@ void lovrTextureSetWrap(Texture* texture, TextureWrap wrap) {
// Canvas
Canvas* lovrCanvasCreate(int width, int height, CanvasFlags flags) {
Canvas* canvas = lovrAlloc(Canvas, lovrCanvasDestroy);
if (!canvas) return NULL;
Canvas* lovrCanvasInit(Canvas* canvas, int width, int height, CanvasFlags flags) {
canvas->width = width;
canvas->height = height;
canvas->flags = flags;
@ -1181,10 +1172,7 @@ Canvas* lovrCanvasCreate(int width, int height, CanvasFlags flags) {
return canvas;
}
Canvas* lovrCanvasCreateFromHandle(int width, int height, CanvasFlags flags, uint32_t framebuffer, uint32_t depthBuffer, uint32_t resolveBuffer, int attachmentCount, bool immortal) {
Canvas* canvas = lovrAlloc(Canvas, lovrCanvasDestroy);
if (!canvas) return NULL;
Canvas* lovrCanvasInitFromHandle(Canvas* canvas, int width, int height, CanvasFlags flags, uint32_t framebuffer, uint32_t depthBuffer, uint32_t resolveBuffer, int attachmentCount, bool immortal) {
canvas->framebuffer = framebuffer;
canvas->depthBuffer = depthBuffer;
canvas->resolveBuffer = resolveBuffer;
@ -1193,7 +1181,6 @@ Canvas* lovrCanvasCreateFromHandle(int width, int height, CanvasFlags flags, uin
canvas->height = height;
canvas->flags = flags;
canvas->immortal = immortal;
return canvas;
}
@ -1397,10 +1384,7 @@ TextureData* lovrCanvasNewTextureData(Canvas* canvas, int index) {
// Buffer
Buffer* lovrBufferCreate(size_t size, void* data, BufferUsage usage, bool readable) {
Buffer* buffer = lovrAlloc(Buffer, lovrBufferDestroy);
if (!buffer) return NULL;
Buffer* lovrBufferInit(Buffer* buffer, size_t size, void* data, BufferUsage usage, bool readable) {
buffer->size = size;
buffer->usage = usage;
glGenBuffers(1, &buffer->id);
@ -1725,10 +1709,7 @@ static void lovrShaderSetupUniforms(Shader* shader) {
}
}
Shader* lovrShaderCreateGraphics(const char* vertexSource, const char* fragmentSource) {
Shader* shader = lovrAlloc(Shader, lovrShaderDestroy);
if (!shader) return NULL;
Shader* lovrShaderInitGraphics(Shader* shader, const char* vertexSource, const char* fragmentSource) {
#if defined(EMSCRIPTEN) || defined(__ANDROID__)
const char* vertexHeader = "#version 300 es\nprecision mediump float;\nprecision mediump int;\n";
const char* fragmentHeader = vertexHeader;
@ -1796,10 +1777,7 @@ Shader* lovrShaderCreateGraphics(const char* vertexSource, const char* fragmentS
return shader;
}
Shader* lovrShaderCreateCompute(const char* source) {
Shader* shader = lovrAlloc(Shader, lovrShaderDestroy);
if (!shader) return NULL;
Shader* lovrShaderInitCompute(Shader* shader, const char* source) {
#ifdef EMSCRIPTEN
lovrThrow("Compute shaders are not supported on this system");
#else
@ -1818,13 +1796,13 @@ Shader* lovrShaderCreateCompute(const char* source) {
return shader;
}
Shader* lovrShaderCreateDefault(DefaultShader type) {
Shader* lovrShaderInitDefault(Shader* shader, DefaultShader type) {
switch (type) {
case SHADER_DEFAULT: return lovrShaderCreateGraphics(NULL, NULL);
case SHADER_CUBE: return lovrShaderCreateGraphics(lovrCubeVertexShader, lovrCubeFragmentShader);
case SHADER_PANO: return lovrShaderCreateGraphics(lovrCubeVertexShader, lovrPanoFragmentShader);
case SHADER_FONT: return lovrShaderCreateGraphics(NULL, lovrFontFragmentShader);
case SHADER_FILL: return lovrShaderCreateGraphics(lovrFillVertexShader, NULL);
case SHADER_DEFAULT: return lovrShaderInitGraphics(shader, NULL, NULL);
case SHADER_CUBE: return lovrShaderInitGraphics(shader, lovrCubeVertexShader, lovrCubeFragmentShader);
case SHADER_PANO: return lovrShaderInitGraphics(shader, lovrCubeVertexShader, lovrPanoFragmentShader);
case SHADER_FONT: return lovrShaderInitGraphics(shader, NULL, lovrFontFragmentShader);
case SHADER_FILL: return lovrShaderInitGraphics(shader, lovrFillVertexShader, NULL);
default: lovrThrow("Unknown default shader type"); return NULL;
}
}
@ -2084,10 +2062,7 @@ void lovrShaderSetBlock(Shader* shader, const char* name, ShaderBlock* source, U
// ShaderBlock
ShaderBlock* lovrShaderBlockCreate(vec_uniform_t* uniforms, BlockType type, BufferUsage usage) {
ShaderBlock* block = lovrAlloc(ShaderBlock, lovrShaderBlockDestroy);
if (!block) return NULL;
ShaderBlock* lovrShaderBlockInit(ShaderBlock* block, vec_uniform_t* uniforms, BlockType type, BufferUsage usage) {
lovrAssert(type != BLOCK_STORAGE || state.features.computeShaders, "Writable ShaderBlocks are not supported on this system");
vec_init(&block->uniforms);
@ -2193,10 +2168,7 @@ Buffer* lovrShaderBlockGetBuffer(ShaderBlock* block) {
// Mesh
Mesh* lovrMeshCreate(uint32_t count, VertexFormat format, DrawMode mode, BufferUsage usage, bool readable) {
Mesh* mesh = lovrAlloc(Mesh, lovrMeshDestroy);
if (!mesh) return NULL;
Mesh* lovrMeshInit(Mesh* mesh, uint32_t count, VertexFormat format, DrawMode mode, BufferUsage usage, bool readable) {
mesh->count = count;
mesh->mode = mode;
mesh->format = format;

12
src/graphics/shader.h
View File

@ -104,9 +104,12 @@ typedef struct {
GPU_SHADER_FIELDS
} Shader;
Shader* lovrShaderCreateGraphics(const char* vertexSource, const char* fragmentSource);
Shader* lovrShaderCreateCompute(const char* source);
Shader* lovrShaderCreateDefault(DefaultShader type);
Shader* lovrShaderInitGraphics(Shader* shader, const char* vertexSource, const char* fragmentSource);
Shader* lovrShaderInitCompute(Shader* shader, const char* source);
Shader* lovrShaderInitDefault(Shader* shader, DefaultShader type);
#define lovrShaderCreateGraphics(...) lovrShaderInitGraphics(lovrAlloc(Shader, lovrShaderDestroy), __VA_ARGS__)
#define lovrShaderCreateCompute(...) lovrShaderInitCompute(lovrAlloc(Shader, lovrShaderDestroy), __VA_ARGS__)
#define lovrShaderCreateDefault(...) lovrShaderInitDefault(lovrAlloc(Shader, lovrShaderDestroy), __VA_ARGS__)
void lovrShaderDestroy(void* ref);
ShaderType lovrShaderGetType(Shader* shader);
void lovrShaderBind(Shader* shader);
@ -122,7 +125,8 @@ void lovrShaderSetImages(Shader* shader, const char* name, Image* data, int star
void lovrShaderSetColor(Shader* shader, const char* name, Color color);
void lovrShaderSetBlock(Shader* shader, const char* name, ShaderBlock* block, UniformAccess access);
ShaderBlock* lovrShaderBlockCreate(vec_uniform_t* uniforms, BlockType type, BufferUsage usage);
ShaderBlock* lovrShaderBlockInit(ShaderBlock* block, vec_uniform_t* uniforms, BlockType type, BufferUsage usage);
#define lovrShaderBlockCreate(...) lovrShaderBlockInit(lovrAlloc(ShaderBlock, lovrShaderBlockDestroy), __VA_ARGS__)
void lovrShaderBlockDestroy(void* ref);
BlockType lovrShaderBlockGetType(ShaderBlock* block);
char* lovrShaderBlockGetShaderCode(ShaderBlock* block, const char* blockName, size_t* length);

6
src/graphics/texture.h
View File

@ -52,8 +52,10 @@ typedef struct {
GPU_TEXTURE_FIELDS
} Texture;
Texture* lovrTextureCreate(TextureType type, TextureData** slices, int sliceCount, bool srgb, bool mipmaps, int msaa);
Texture* lovrTextureCreateFromHandle(uint32_t handle, TextureType type);
Texture* lovrTextureInit(Texture* texture, TextureType type, TextureData** slices, int sliceCount, bool srgb, bool mipmaps, int msaa);
Texture* lovrTextureInitFromHandle(Texture* texture, uint32_t handle, TextureType type);
#define lovrTextureCreate(...) lovrTextureInit(lovrAlloc(Texture, lovrTextureDestroy), __VA_ARGS__)
#define lovrTextureCreateFromHandle(...) lovrTextureInitFromHandle(lovrAlloc(Texture, lovrTextureDestroy), __VA_ARGS__)
void lovrTextureDestroy(void* ref);
void lovrTextureAllocate(Texture* texture, int width, int height, int depth, TextureFormat format);
void lovrTextureReplacePixels(Texture* texture, TextureData* data, int x, int y, int slice, int mipmap);

3
src/headset/openvr.c
View File

@ -416,8 +416,7 @@ static ModelData* openvrControllerNewModelData(Controller* controller) {
RenderModel_t* vrModel = state.deviceModels[id];
ModelData* modelData = lovrModelDataCreateEmpty();
if (!modelData) return NULL;
ModelData* modelData = lovrAlloc(ModelData, lovrModelDataDestroy);
VertexFormat format;
vertexFormatInit(&format);

6
src/math/curve.c
View File

@ -37,13 +37,9 @@ static void evaluate(float* P, int n, float t, vec3 p) {
}
}
Curve* lovrCurveCreate(int sizeHint) {
Curve* curve = lovrAlloc(Curve, lovrCurveDestroy);
if (!curve) return NULL;
Curve* lovrCurveInit(Curve* curve, int sizeHint) {
vec_init(&curve->points);
lovrAssert(!vec_reserve(&curve->points, sizeHint * 3), "Out of memory");
return curve;
}

3
src/math/curve.h
View File

@ -7,7 +7,8 @@ typedef struct {
vec_float_t points;
} Curve;
Curve* lovrCurveCreate(int sizeHint);
Curve* lovrCurveInit(Curve* curve, int sizeHint);
#define lovrCurveCreate(...) lovrCurveInit(lovrAlloc(Curve, lovrCurveDestroy), __VA_ARGS__)
void lovrCurveDestroy(void* ref);
void lovrCurveEvaluate(Curve* curve, float t, vec3 point);
void lovrCurveGetTangent(Curve* curve, float t, vec3 point);

1
src/math/math.c
View File

@ -3,6 +3,7 @@
#include "util.h"
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
static MathState state;

6
src/math/pool.c
View File

@ -7,16 +7,12 @@ static const size_t sizeOfMathType[] = {
[MATH_MAT4] = 16 * sizeof(float)
};
Pool* lovrPoolCreate(size_t size) {
Pool* pool = lovrAlloc(Pool, lovrPoolDestroy);
if (!pool) return NULL;
Pool* lovrPoolInit(Pool* pool, size_t size) {
pool->size = size;
pool->data = calloc(1, size + POOL_ALIGN - 1);
pool->head = (uint8_t*) ALIGN((uint8_t*) pool->data + POOL_ALIGN - 1, POOL_ALIGN);
lovrAssert(pool->data, "Could not allocate Pool memory");
pool->usage = 0;
return pool;
}

3
src/math/pool.h
View File

@ -20,7 +20,8 @@ typedef struct {
uint8_t* head;
} Pool;
Pool* lovrPoolCreate(size_t size);
Pool* lovrPoolInit(Pool* pool, size_t size);
#define lovrPoolCreate(...) lovrPoolInit(lovrAlloc(Pool, lovrPoolDestroy), __VA_ARGS__)
void lovrPoolDestroy(void* ref);
float* lovrPoolAllocate(Pool* pool, MathType type);
void lovrPoolDrain(Pool* pool);

6
src/math/randomGenerator.c
View File

@ -22,14 +22,10 @@ static uint64_t wangHash64(uint64_t key) {
// George Marsaglia, "Xorshift RNGs", Journal of Statistical Software, Vol.8 (Issue 14), 2003
// Use an 'Xorshift*' variant, as shown here: http://xorshift.di.unimi.it
RandomGenerator* lovrRandomGeneratorCreate() {
RandomGenerator* generator = lovrAlloc(RandomGenerator, free);
if (!generator) return NULL;
RandomGenerator* lovrRandomGeneratorInit(RandomGenerator* generator) {
Seed seed = { .b32 = { .lo = 0xCBBF7A44, .hi = 0x0139408D } };
lovrRandomGeneratorSetSeed(generator, seed);
generator->lastRandomNormal = INFINITY;
return generator;
}

4
src/math/randomGenerator.h
View File

@ -20,7 +20,9 @@ typedef struct {
double lastRandomNormal;
} RandomGenerator;
RandomGenerator* lovrRandomGeneratorCreate();
RandomGenerator* lovrRandomGeneratorInit(RandomGenerator* generator);
#define lovrRandomGeneratorCreate() lovrRandomGeneratorInit(lovrAlloc(RandomGenerator, lovrRandomGeneratorDestroy))
#define lovrRandomGeneratorDestroy free
Seed lovrRandomGeneratorGetSeed(RandomGenerator* generator);
void lovrRandomGeneratorSetSeed(RandomGenerator* generator, Seed seed);
void lovrRandomGeneratorGetState(RandomGenerator* generator, char* state, size_t length);

59
src/physics/physics.c
View File

@ -43,10 +43,7 @@ void lovrPhysicsDestroy() {
initialized = false;
}
World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char** tags, int tagCount) {
World* world = lovrAlloc(World, lovrWorldDestroy);
if (!world) return NULL;
World* lovrWorldInit(World* world, float xg, float yg, float zg, bool allowSleep, const char** tags, int tagCount) {
world->id = dWorldCreate();
world->space = dHashSpaceCreate(0);
dHashSpaceSetLevels(world->space, -4, 8);
@ -273,10 +270,7 @@ int lovrWorldIsCollisionEnabledBetween(World* world, const char* tag1, const cha
return (world->masks[*index1] & (1 << *index2)) && (world->masks[*index2] & (1 << *index1));
}
Collider* lovrColliderCreate(World* world, float x, float y, float z) {
Collider* collider = lovrAlloc(Collider, lovrColliderDestroy);
if (!collider) return NULL;
Collider* lovrColliderInit(Collider* collider, World* world, float x, float y, float z) {
collider->body = dBodyCreate(world->id);
collider->world = world;
collider->friction = 0;
@ -299,7 +293,6 @@ Collider* lovrColliderCreate(World* world, float x, float y, float z) {
// The world owns a reference to the collider
lovrRetain(collider);
return collider;
}
@ -790,14 +783,10 @@ void lovrShapeGetAABB(Shape* shape, float aabb[6]) {
dGeomGetAABB(shape->id, aabb);
}
SphereShape* lovrSphereShapeCreate(float radius) {
SphereShape* sphere = lovrAlloc(SphereShape, lovrShapeDestroy);
if (!sphere) return NULL;
SphereShape* lovrSphereShapeInit(SphereShape* sphere, float radius) {
sphere->type = SHAPE_SPHERE;
sphere->id = dCreateSphere(0, radius);
dGeomSetData(sphere->id, sphere);
return sphere;
}
@ -809,14 +798,10 @@ void lovrSphereShapeSetRadius(SphereShape* sphere, float radius) {
dGeomSphereSetRadius(sphere->id, radius);
}
BoxShape* lovrBoxShapeCreate(float x, float y, float z) {
BoxShape* box = lovrAlloc(BoxShape, lovrShapeDestroy);
if (!box) return NULL;
BoxShape* lovrBoxShapeInit(BoxShape* box, float x, float y, float z) {
box->type = SHAPE_BOX;
box->id = dCreateBox(0, x, y, z);
dGeomSetData(box->id, box);
return box;
}
@ -832,14 +817,10 @@ void lovrBoxShapeSetDimensions(BoxShape* box, float x, float y, float z) {
dGeomBoxSetLengths(box->id, x, y, z);
}
CapsuleShape* lovrCapsuleShapeCreate(float radius, float length) {
CapsuleShape* capsule = lovrAlloc(CapsuleShape, lovrShapeDestroy);
if (!capsule) return NULL;
CapsuleShape* lovrCapsuleShapeInit(CapsuleShape* capsule, float radius, float length) {
capsule->type = SHAPE_CAPSULE;
capsule->id = dCreateCapsule(0, radius, length);
dGeomSetData(capsule->id, capsule);
return capsule;
}
@ -863,14 +844,10 @@ void lovrCapsuleShapeSetLength(CapsuleShape* capsule, float length) {
dGeomCapsuleSetParams(capsule->id, lovrCapsuleShapeGetRadius(capsule), length);
}
CylinderShape* lovrCylinderShapeCreate(float radius, float length) {
CylinderShape* cylinder = lovrAlloc(CylinderShape, lovrShapeDestroy);
if (!cylinder) return NULL;
CylinderShape* lovrCylinderShapeInit(CylinderShape* cylinder, float radius, float length) {
cylinder->type = SHAPE_CYLINDER;
cylinder->id = dCreateCylinder(0, radius, length);
dGeomSetData(cylinder->id, cylinder);
return cylinder;
}
@ -932,18 +909,14 @@ void lovrJointSetUserData(Joint* joint, void* data) {
joint->userdata = data;
}
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float x, float y, float z) {
BallJoint* lovrBallJointInit(BallJoint* joint, Collider* a, Collider* b, float x, float y, float z) {
lovrAssert(a->world == b->world, "Joint bodies must exist in same World");
BallJoint* joint = lovrAlloc(BallJoint, lovrJointDestroy);
if (!joint) return NULL;
joint->type = JOINT_BALL;
joint->id = dJointCreateBall(a->world->id, 0);
dJointSetData(joint->id, joint);
dJointAttach(joint->id, a->body, b->body);
lovrBallJointSetAnchor(joint, x, y, z);
lovrRetain(joint);
return joint;
}
@ -963,18 +936,14 @@ void lovrBallJointSetAnchor(BallJoint* joint, float x, float y, float z) {
dJointSetBallAnchor(joint->id, x, y, z);
}
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float x1, float y1, float z1, float x2, float y2, float z2) {
DistanceJoint* lovrDistanceJointInit(DistanceJoint* joint, Collider* a, Collider* b, float x1, float y1, float z1, float x2, float y2, float z2) {
lovrAssert(a->world == b->world, "Joint bodies must exist in same World");
DistanceJoint* joint = lovrAlloc(DistanceJoint, lovrJointDestroy);
if (!joint) return NULL;
joint->type = JOINT_DISTANCE;
joint->id = dJointCreateDBall(a->world->id, 0);
dJointSetData(joint->id, joint);
dJointAttach(joint->id, a->body, b->body);
lovrDistanceJointSetAnchors(joint, x1, y1, z1, x2, y2, z2);
lovrRetain(joint);
return joint;
}
@ -1003,11 +972,8 @@ void lovrDistanceJointSetDistance(DistanceJoint* joint, float distance) {
dJointSetDBallDistance(joint->id, distance);
}
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float x, float y, float z, float ax, float ay, float az) {
HingeJoint* lovrHingeJointInit(HingeJoint* joint, Collider* a, Collider* b, float x, float y, float z, float ax, float ay, float az) {
lovrAssert(a->world == b->world, "Joint bodies must exist in same World");
HingeJoint* joint = lovrAlloc(HingeJoint, lovrJointDestroy);
if (!joint) return NULL;
joint->type = JOINT_HINGE;
joint->id = dJointCreateHinge(a->world->id, 0);
dJointSetData(joint->id, joint);
@ -1015,7 +981,6 @@ HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float x, float y, flo
lovrHingeJointSetAnchor(joint, x, y, z);
lovrHingeJointSetAxis(joint, ax, ay, az);
lovrRetain(joint);
return joint;
}
@ -1067,18 +1032,14 @@ void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit) {
dJointSetHingeParam(joint->id, dParamHiStop, limit);
}
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float ax, float ay, float az) {
SliderJoint* lovrSliderJointInit(SliderJoint* joint, Collider* a, Collider* b, float ax, float ay, float az) {
lovrAssert(a->world == b->world, "Joint bodies must exist in the same world");
SliderJoint* joint = lovrAlloc(SliderJoint, lovrJointDestroy);
if (!joint) return NULL;
joint->type = JOINT_SLIDER;
joint->id = dJointCreateSlider(a->world->id, 0);
dJointSetData(joint->id, joint);
dJointAttach(joint->id, a->body, b->body);
lovrSliderJointSetAxis(joint, ax, ay, az);
lovrRetain(joint);
return joint;
}

30
src/physics/physics.h
View File

@ -88,7 +88,8 @@ typedef struct {
bool lovrPhysicsInit();
void lovrPhysicsDestroy();
World* lovrWorldCreate(float xg, float yg, float zg, bool allowSleep, const char** tags, int tagCount);
World* lovrWorldInit(World* world, float xg, float yg, float zg, bool allowSleep, const char** tags, int tagCount);
#define lovrWorldCreate(...) lovrWorldInit(lovrAlloc(World, lovrWorldDestroy), __VA_ARGS__)
void lovrWorldDestroy(void* ref);
void lovrWorldDestroyData(World* world);
void lovrWorldUpdate(World* world, float dt, CollisionResolver resolver, void* userdata);
@ -109,7 +110,8 @@ int lovrWorldDisableCollisionBetween(World* world, const char* tag1, const char*
int lovrWorldEnableCollisionBetween(World* world, const char* tag1, const char* tag2);
int lovrWorldIsCollisionEnabledBetween(World* world, const char* tag1, const char* tag);
Collider* lovrColliderCreate(World* world, float x, float y, float z);
Collider* lovrColliderInit(Collider* collider, World* world, float x, float y, float z);
#define lovrColliderCreate(...) lovrColliderInit(lovrAlloc(Collider, lovrColliderDestroy), __VA_ARGS__)
void lovrColliderDestroy(void* ref);
void lovrColliderDestroyData(Collider* collider);
World* lovrColliderGetWorld(Collider* collider);
@ -176,21 +178,25 @@ void lovrShapeSetOrientation(Shape* shape, float angle, float x, float y, float
void lovrShapeGetMass(Shape* shape, float density, float* cx, float* cy, float* cz, float* mass, float inertia[6]);
void lovrShapeGetAABB(Shape* shape, float aabb[6]);
SphereShape* lovrSphereShapeCreate(float radius);
SphereShape* lovrSphereShapeInit(SphereShape* sphere, float radius);
#define lovrSphereShapeCreate(...) lovrSphereShapeInit(lovrAlloc(SphereShape, lovrShapeDestroy), __VA_ARGS__)
float lovrSphereShapeGetRadius(SphereShape* sphere);
void lovrSphereShapeSetRadius(SphereShape* sphere, float radius);
BoxShape* lovrBoxShapeCreate(float x, float y, float z);
BoxShape* lovrBoxShapeInit(BoxShape* box, float x, float y, float z);
#define lovrBoxShapeCreate(...) lovrBoxShapeInit(lovrAlloc(BoxShape, lovrShapeDestroy), __VA_ARGS__)
void lovrBoxShapeGetDimensions(BoxShape* box, float* x, float* y, float* z);
void lovrBoxShapeSetDimensions(BoxShape* box, float x, float y, float z);
CapsuleShape* lovrCapsuleShapeCreate(float radius, float length);
CapsuleShape* lovrCapsuleShapeInit(CapsuleShape* capsule, float radius, float length);
#define lovrCapsuleShapeCreate(...) lovrCapsuleShapeInit(lovrAlloc(CapsuleShape, lovrShapeDestroy), __VA_ARGS__)
float lovrCapsuleShapeGetRadius(CapsuleShape* capsule);
void lovrCapsuleShapeSetRadius(CapsuleShape* capsule, float radius);
float lovrCapsuleShapeGetLength(CapsuleShape* capsule);
void lovrCapsuleShapeSetLength(CapsuleShape* capsule, float length);
CylinderShape* lovrCylinderShapeCreate(float radius, float length);
CylinderShape* lovrCylinderShapeInit(CylinderShape* cylinder, float radius, float length);
#define lovrCylinderShapeCreate(...) lovrCylinderShapeInit(lovrAlloc(CylinderShape, lovrShapeDestroy), __VA_ARGS__)
float lovrCylinderShapeGetRadius(CylinderShape* cylinder);
void lovrCylinderShapeSetRadius(CylinderShape* cylinder, float radius);
float lovrCylinderShapeGetLength(CylinderShape* cylinder);
@ -203,17 +209,20 @@ void lovrJointGetColliders(Joint* joint, Collider** a, Collider** b);
void* lovrJointGetUserData(Joint* joint);
void lovrJointSetUserData(Joint* joint, void* data);
BallJoint* lovrBallJointCreate(Collider* a, Collider* b, float x, float y, float z);
BallJoint* lovrBallJointInit(BallJoint* joint, Collider* a, Collider* b, float x, float y, float z);
#define lovrBallJointCreate(...) lovrBallJointInit(lovrAlloc(BallJoint, lovrJointDestroy), __VA_ARGS__)
void lovrBallJointGetAnchors(BallJoint* joint, float* x1, float* y1, float* z1, float* x2, float* y2, float* z2);
void lovrBallJointSetAnchor(BallJoint* joint, float x, float y, float z);
DistanceJoint* lovrDistanceJointCreate(Collider* a, Collider* b, float x1, float y1, float z1, float x2, float y2, float z2);
DistanceJoint* lovrDistanceJointInit(DistanceJoint* joint, Collider* a, Collider* b, float x1, float y1, float z1, float x2, float y2, float z2);
#define lovrDistanceJointCreate(...) lovrDistanceJointInit(lovrAlloc(DistanceJoint, lovrJointDestroy), __VA_ARGS__)
void lovrDistanceJointGetAnchors(DistanceJoint* joint, float* x1, float* y1, float* z1, float* x2, float* y2, float* z2);
void lovrDistanceJointSetAnchors(DistanceJoint* joint, float x1, float y1, float z1, float x2, float y2, float z2);
float lovrDistanceJointGetDistance(DistanceJoint* joint);
void lovrDistanceJointSetDistance(DistanceJoint* joint, float distance);
HingeJoint* lovrHingeJointCreate(Collider* a, Collider* b, float x, float y, float z, float ax, float ay, float az);
HingeJoint* lovrHingeJointInit(HingeJoint* joint, Collider* a, Collider* b, float x, float y, float z, float ax, float ay, float az);
#define lovrHingeJointCreate(...) lovrHingeJointInit(lovrAlloc(HingeJoint, lovrJointDestroy), __VA_ARGS__)
void lovrHingeJointGetAnchors(HingeJoint* joint, float* x1, float* y1, float* z1, float* x2, float* y2, float* z2);
void lovrHingeJointSetAnchor(HingeJoint* joint, float x, float y, float z);
void lovrHingeJointGetAxis(HingeJoint* joint, float* x, float* y, float* z);
@ -224,7 +233,8 @@ void lovrHingeJointSetLowerLimit(HingeJoint* joint, float limit);
float lovrHingeJointGetUpperLimit(HingeJoint* joint);
void lovrHingeJointSetUpperLimit(HingeJoint* joint, float limit);
SliderJoint* lovrSliderJointCreate(Collider* a, Collider* b, float ax, float ay, float az);
SliderJoint* lovrSliderJointInit(SliderJoint* joint, Collider* a, Collider* b, float ax, float ay, float az);
#define lovrSliderJointCreate(...) lovrSliderJointInit(lovrAlloc(SliderJoint, lovrJointDestroy), __VA_ARGS__)
void lovrSliderJointGetAxis(SliderJoint* joint, float* x, float* y, float* z);
void lovrSliderJointSetAxis(SliderJoint* joint, float x, float y, float z);
float lovrSliderJointGetPosition(SliderJoint* joint);

6
src/thread/channel.c
View File

@ -3,14 +3,10 @@
#include <stdio.h>
#include <stdlib.h>
Channel* lovrChannelCreate() {
Channel* channel = lovrAlloc(Channel, lovrChannelDestroy);
if (!channel) return NULL;
Channel* lovrChannelInit(Channel* channel) {
vec_init(&channel->messages);
mtx_init(&channel->lock, mtx_plain | mtx_timed);
cnd_init(&channel->cond);
return channel;
}

3
src/thread/channel.h
View File

@ -16,7 +16,8 @@ struct Channel {
uint64_t received;
};
Channel* lovrChannelCreate();
Channel* lovrChannelInit(Channel* channel);
#define lovrChannelCreate() lovrChannelInit(lovrAlloc(Channel, lovrChannelDestroy))
void lovrChannelDestroy(void* ref);
bool lovrChannelPush(Channel* channel, Variant variant, double timeout, uint64_t* id);
bool lovrChannelPop(Channel* channel, Variant* variant, double timeout);

6
src/thread/thread.c
View File

@ -34,16 +34,12 @@ Channel* lovrThreadGetChannel(const char* name) {
}
}
Thread* lovrThreadCreate(int (*runner)(void*), const char* body) {
Thread* thread = lovrAlloc(Thread, lovrThreadDestroy);
if (!thread) return NULL;
Thread* lovrThreadInit(Thread* thread, int (*runner)(void*), const char* body) {
thread->runner = runner;
thread->body = body;
thread->error = NULL;
thread->running = false;
mtx_init(&thread->lock, mtx_plain);
return thread;
}

3
src/thread/thread.h
View File

@ -26,7 +26,8 @@ bool lovrThreadModuleInit();
void lovrThreadModuleDestroy();
struct Channel* lovrThreadGetChannel(const char* name);
Thread* lovrThreadCreate(int (*runner)(void*), const char* body);
Thread* lovrThreadInit(Thread* thread, int (*runner)(void*), const char* body);
#define lovrThreadCreate(...) lovrThreadInit(lovrAlloc(Thread, lovrThreadDestroy), __VA_ARGS__)
void lovrThreadDestroy(void* ref);
void lovrThreadStart(Thread* thread);
void lovrThreadWait(Thread* thread);