2018-01-16 07:13:26 +00:00
|
|
|
#include "api.h"
|
2019-05-18 00:11:22 +00:00
|
|
|
#include "data/blob.h"
|
2018-02-11 23:22:04 +00:00
|
|
|
#include "data/modelData.h"
|
2018-01-22 16:40:47 +00:00
|
|
|
#include "data/rasterizer.h"
|
2018-07-06 03:23:46 +00:00
|
|
|
#include "data/soundData.h"
|
2018-02-11 23:22:04 +00:00
|
|
|
#include "data/textureData.h"
|
2019-06-02 07:20:10 +00:00
|
|
|
#include <stdlib.h>
|
2019-06-08 10:45:03 +00:00
|
|
|
#include <string.h>
|
2018-01-16 07:13:26 +00:00
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static int l_lovrDataNewBlob(lua_State* L) {
|
2018-02-20 05:04:53 +00:00
|
|
|
size_t size;
|
|
|
|
uint8_t* data = NULL;
|
|
|
|
int type = lua_type(L, 1);
|
|
|
|
if (type == LUA_TNUMBER) {
|
2019-02-18 02:43:52 +00:00
|
|
|
int isize = lua_tonumber(L, 1);
|
|
|
|
lovrAssert(isize > 0, "Blob size must be positive");
|
|
|
|
size = (size_t) isize;
|
2018-02-20 05:04:53 +00:00
|
|
|
data = calloc(1, size);
|
2019-01-29 10:49:09 +00:00
|
|
|
lovrAssert(data, "Out of memory");
|
2018-03-11 05:37:05 +00:00
|
|
|
} else if (type == LUA_TSTRING) {
|
2018-02-20 05:04:53 +00:00
|
|
|
const char* str = luaL_checklstring(L, 1, &size);
|
|
|
|
data = malloc(size + 1);
|
2019-01-29 10:49:09 +00:00
|
|
|
lovrAssert(data, "Out of memory");
|
2018-02-20 05:04:53 +00:00
|
|
|
memcpy(data, str, size);
|
|
|
|
data[size] = '\0';
|
2018-03-11 05:37:05 +00:00
|
|
|
} else {
|
2018-07-25 04:15:07 +00:00
|
|
|
Blob* blob = luax_checktype(L, 1, Blob);
|
2018-03-11 05:37:05 +00:00
|
|
|
size = blob->size;
|
|
|
|
data = malloc(size);
|
2019-01-29 10:49:09 +00:00
|
|
|
lovrAssert(data, "Out of memory");
|
2020-01-14 03:36:12 +00:00
|
|
|
memcpy(data, blob->data, size);
|
2018-02-20 05:04:53 +00:00
|
|
|
}
|
|
|
|
const char* name = luaL_optstring(L, 2, "");
|
|
|
|
Blob* blob = lovrBlobCreate(data, size, name);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, Blob, blob);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(blob, lovrBlobDestroy);
|
2018-02-20 05:04:53 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static int l_lovrDataNewModelData(lua_State* L) {
|
2018-01-23 02:24:39 +00:00
|
|
|
Blob* blob = luax_readblob(L, 1, "Model");
|
2019-12-08 09:46:54 +00:00
|
|
|
ModelData* modelData = lovrModelDataCreate(blob, luax_readfile);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, ModelData, modelData);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(blob, lovrBlobDestroy);
|
|
|
|
lovrRelease(modelData, lovrModelDataDestroy);
|
2018-01-23 02:24:39 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static int l_lovrDataNewRasterizer(lua_State* L) {
|
2018-01-22 16:40:47 +00:00
|
|
|
Blob* blob = NULL;
|
|
|
|
float size;
|
|
|
|
|
|
|
|
if (lua_type(L, 1) == LUA_TNUMBER || lua_isnoneornil(L, 1)) {
|
2019-01-29 10:28:55 +00:00
|
|
|
size = luax_optfloat(L, 1, 32.f);
|
2018-01-22 16:40:47 +00:00
|
|
|
} else {
|
|
|
|
blob = luax_readblob(L, 1, "Font");
|
2019-01-29 10:28:55 +00:00
|
|
|
size = luax_optfloat(L, 2, 32.f);
|
2018-01-22 16:40:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Rasterizer* rasterizer = lovrRasterizerCreate(blob, size);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, Rasterizer, rasterizer);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(blob, lovrBlobDestroy);
|
|
|
|
lovrRelease(rasterizer, lovrRasterizerDestroy);
|
2018-01-21 21:26:00 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static int l_lovrDataNewSoundData(lua_State* L) {
|
2018-07-06 03:23:46 +00:00
|
|
|
if (lua_type(L, 1) == LUA_TNUMBER) {
|
2020-05-10 08:48:01 +00:00
|
|
|
uint64_t frames = luaL_checkinteger(L, 1);
|
2021-02-07 13:07:50 +00:00
|
|
|
SampleFormat format = luax_checkenum(L, 2, SampleFormat, "f32");
|
|
|
|
uint32_t channels = luaL_optinteger(L, 3, 2);
|
|
|
|
uint32_t sampleRate = luaL_optinteger(L, 4, 48000);
|
2020-05-10 08:48:01 +00:00
|
|
|
Blob* blob = luax_totype(L, 5, Blob);
|
2021-02-07 13:07:50 +00:00
|
|
|
const char* other = lua_tostring(L, 5);
|
|
|
|
bool stream = other && !strcmp(other, "stream");
|
|
|
|
SoundData* soundData = stream ?
|
|
|
|
lovrSoundDataCreateStream(frames, format, channels, sampleRate) :
|
|
|
|
lovrSoundDataCreateRaw(frames, format, channels, sampleRate, blob);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, SoundData, soundData);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(soundData, lovrSoundDataDestroy);
|
2018-07-06 03:23:46 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Blob* blob = luax_readblob(L, 1, "SoundData");
|
2020-05-10 08:48:01 +00:00
|
|
|
bool decode = lua_toboolean(L, 2);
|
|
|
|
SoundData* soundData = lovrSoundDataCreateFromFile(blob, decode);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, SoundData, soundData);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(blob, lovrBlobDestroy);
|
|
|
|
lovrRelease(soundData, lovrSoundDataDestroy);
|
2018-07-06 03:23:46 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static int l_lovrDataNewTextureData(lua_State* L) {
|
2018-02-11 01:27:29 +00:00
|
|
|
TextureData* textureData = NULL;
|
|
|
|
if (lua_type(L, 1) == LUA_TNUMBER) {
|
2019-01-12 06:37:54 +00:00
|
|
|
int width = luaL_checkinteger(L, 1);
|
|
|
|
int height = luaL_checkinteger(L, 2);
|
2020-09-28 00:13:00 +00:00
|
|
|
TextureFormat format = luax_checkenum(L, 3, TextureFormat, "rgba");
|
2020-03-29 19:32:32 +00:00
|
|
|
Blob* blob = lua_isnoneornil(L, 4) ? NULL : luax_checktype(L, 4, Blob);
|
|
|
|
textureData = lovrTextureDataCreate(width, height, blob, 0x0, format);
|
2018-02-11 01:27:29 +00:00
|
|
|
} else {
|
2020-03-29 19:32:32 +00:00
|
|
|
TextureData* source = luax_totype(L, 1, TextureData);
|
|
|
|
if (source) {
|
|
|
|
textureData = lovrTextureDataCreate(source->width, source->height, source->blob, 0x0, source->format);
|
|
|
|
} else {
|
|
|
|
Blob* blob = luax_readblob(L, 1, "Texture");
|
|
|
|
bool flip = lua_isnoneornil(L, 2) ? true : lua_toboolean(L, 2);
|
|
|
|
textureData = lovrTextureDataCreateFromBlob(blob, flip);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(blob, lovrBlobDestroy);
|
2020-03-29 19:32:32 +00:00
|
|
|
}
|
2018-02-11 01:27:29 +00:00
|
|
|
}
|
|
|
|
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_pushtype(L, TextureData, textureData);
|
2021-02-09 00:52:26 +00:00
|
|
|
lovrRelease(textureData, lovrTextureDataDestroy);
|
2018-02-11 01:27:29 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2018-09-27 01:27:38 +00:00
|
|
|
static const luaL_Reg lovrData[] = {
|
2018-02-20 05:04:53 +00:00
|
|
|
{ "newBlob", l_lovrDataNewBlob },
|
2018-01-23 02:24:39 +00:00
|
|
|
{ "newModelData", l_lovrDataNewModelData },
|
2018-01-22 16:40:47 +00:00
|
|
|
{ "newRasterizer", l_lovrDataNewRasterizer },
|
2018-07-06 03:23:46 +00:00
|
|
|
{ "newSoundData", l_lovrDataNewSoundData },
|
2018-01-21 05:33:09 +00:00
|
|
|
{ "newTextureData", l_lovrDataNewTextureData },
|
2018-01-16 07:13:26 +00:00
|
|
|
{ NULL, NULL }
|
|
|
|
};
|
2018-09-27 01:27:38 +00:00
|
|
|
|
2019-08-26 22:53:10 +00:00
|
|
|
int luaopen_lovr_data(lua_State* L) {
|
2018-09-27 01:27:38 +00:00
|
|
|
lua_newtable(L);
|
2020-08-19 19:12:06 +00:00
|
|
|
luax_register(L, lovrData);
|
2019-04-05 10:48:36 +00:00
|
|
|
luax_registertype(L, Blob);
|
|
|
|
luax_registertype(L, ModelData);
|
|
|
|
luax_registertype(L, Rasterizer);
|
2019-06-02 07:20:10 +00:00
|
|
|
luax_registertype(L, SoundData);
|
|
|
|
luax_registertype(L, TextureData);
|
2018-09-27 01:27:38 +00:00
|
|
|
return 1;
|
|
|
|
}
|