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

Convert stuff over to use new enum system;

This commit is contained in:
bjorn 2020-02-16 18:31:02 -08:00
parent d5487cbd40
commit 18dcb07b98
18 changed files with 364 additions and 361 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/api/api.c
View File

@ -154,7 +154,7 @@ void _luax_pushtype(lua_State* L, const char* type, uint64_t hash, void* object)
lua_remove(L, -2);
}
int luax_checkoption(lua_State* L, int index, const StringEntry* map, const char* fallback, const char* label) {
int luax_checkenum(lua_State* L, int index, const StringEntry* map, const char* fallback, const char* label) {
size_t length;
const char* string = fallback ? luaL_optlstring(L, index, fallback, &length) : luaL_checklstring(L, index, &length);

76
src/api/api.h
View File

@ -60,42 +60,6 @@ extern const luaL_Reg lovrVec3[];
extern const luaL_Reg lovrWorld[];
// Enums
extern const char* ArcModes[];
extern const char* AttributeTypes[];
extern const char* BlendAlphaModes[];
extern const char* BlendModes[];
extern const char* BlockTypes[];
extern const char* BufferUsages[];
extern const char* CompareModes[];
extern const char* CoordinateSpaces[];
extern const char* Devices[];
extern const char* DeviceAxes[];
extern const char* DeviceButtons[];
extern const char* DrawModes[];
extern const char* DrawStyles[];
extern const char* EventTypes[];
extern const char* FilterModes[];
extern const char* HeadsetDrivers[];
extern const char* HeadsetOrigins[];
extern const char* HorizontalAligns[];
extern const char* JointTypes[];
extern const char* MaterialColors[];
extern const char* MaterialScalars[];
extern const char* MaterialTextures[];
extern const char* ShaderTypes[];
extern const char* ShapeTypes[];
extern const char* SourceTypes[];
extern const char* StencilActions[];
extern const char* TextureFormats[];
extern const char* TextureTypes[];
extern const char* TimeUnits[];
extern const char* UniformAccesses[];
extern const char* VerticalAligns[];
extern const char* Windings[];
extern const char* WrapModes[];
// General helpers
typedef struct {
uint8_t length;
char string[31];
@ -103,6 +67,42 @@ typedef struct {
#define ENTRY(s) { sizeof(s) - 1, s }
extern StringEntry ArcModes[];
extern StringEntry AttributeTypes[];
extern StringEntry BlendAlphaModes[];
extern StringEntry BlendModes[];
extern StringEntry BlockTypes[];
extern StringEntry BufferUsages[];
extern StringEntry CompareModes[];
extern StringEntry CoordinateSpaces[];
extern StringEntry Devices[];
extern StringEntry DeviceAxes[];
extern StringEntry DeviceButtons[];
extern StringEntry DrawModes[];
extern StringEntry DrawStyles[];
extern StringEntry EventTypes[];
extern StringEntry FilterModes[];
extern StringEntry HeadsetDrivers[];
extern StringEntry HeadsetOrigins[];
extern StringEntry HorizontalAligns[];
extern StringEntry JointTypes[];
extern StringEntry MaterialColors[];
extern StringEntry MaterialScalars[];
extern StringEntry MaterialTextures[];
extern StringEntry ShaderTypes[];
extern StringEntry ShapeTypes[];
extern StringEntry SourceTypes[];
extern StringEntry StencilActions[];
extern StringEntry TextureFormats[];
extern StringEntry TextureTypes[];
extern StringEntry TimeUnits[];
extern StringEntry UniformAccesses[];
extern StringEntry VerticalAligns[];
extern StringEntry Windings[];
extern StringEntry WrapModes[];
// General helpers
typedef struct {
uint64_t hash;
void* object;
@ -117,7 +117,7 @@ typedef struct {
#define luax_totype(L, i, T) (T*) _luax_totype(L, i, hash64(#T, strlen(#T)))
#define luax_checktype(L, i, T) (T*) _luax_checktype(L, i, hash64(#T, strlen(#T)), #T)
#define luax_pushtype(L, T, o) _luax_pushtype(L, #T, hash64(#T, strlen(#T)), o)
#define luax_pushoption(L, m, x) lua_pushlstring(L, m[x].string, m[x].length)
#define luax_pushenum(L, m, x) lua_pushlstring(L, m[x].string, m[x].length)
#define luax_checkfloat(L, i) (float) luaL_checknumber(L, i)
#define luax_optfloat(L, i, x) (float) luaL_optnumber(L, i, x)
#define luax_geterror(L) lua_getfield(L, LUA_REGISTRYINDEX, "_lovrerror")
@ -128,7 +128,7 @@ void _luax_registertype(lua_State* L, const char* name, const luaL_Reg* function
void* _luax_totype(lua_State* L, int index, uint64_t hash);
void* _luax_checktype(lua_State* L, int index, uint64_t hash, const char* debug);
void _luax_pushtype(lua_State* L, const char* name, uint64_t hash, void* object);
int luax_checkoption(lua_State* L, int index, const StringEntry* map, const char* fallback, const char* label);
int luax_checkenum(lua_State* L, int index, const StringEntry* map, const char* fallback, const char* label);
void luax_registerloader(lua_State* L, lua_CFunction loader, int index);
void luax_vthrow(void* L, const char* format, va_list args);
void luax_traceback(lua_State* L, lua_State* T, const char* message, int level);

18
src/api/l_audio.c
View File

@ -9,16 +9,16 @@
#include "core/ref.h"
#include <stdlib.h>
const char* SourceTypes[] = {
[SOURCE_STATIC] = "static",
[SOURCE_STREAM] = "stream",
NULL
StringEntry SourceTypes[] = {
[SOURCE_STATIC] = ENTRY("static"),
[SOURCE_STREAM] = ENTRY("stream"),
{ 0 }
};
const char* TimeUnits[] = {
[UNIT_SECONDS] = "seconds",
[UNIT_SAMPLES] = "samples",
NULL
StringEntry TimeUnits[] = {
[UNIT_SECONDS] = ENTRY("seconds"),
[UNIT_SAMPLES] = ENTRY("samples"),
{ 0 }
};
static int l_lovrAudioUpdate(lua_State* L) {
@ -124,7 +124,7 @@ static int l_lovrAudioNewSource(lua_State* L) {
Source* source = NULL;
SoundData* soundData = luax_totype(L, 1, SoundData);
AudioStream* stream = luax_totype(L, 1, AudioStream);
bool isStatic = soundData || luaL_checkoption(L, 2, NULL, SourceTypes) == SOURCE_STATIC;
bool isStatic = soundData || luax_checkenum(L, 2, SourceTypes, NULL, "SourceType") == SOURCE_STATIC;
if (isStatic) {
if (soundData) {

8
src/api/l_audio_source.c
View File

@ -28,7 +28,7 @@ static int l_lovrSourceGetCone(lua_State* L) {
static int l_lovrSourceGetDuration(lua_State* L) {
Source* source = luax_checktype(L, 1, Source);
TimeUnit unit = luaL_checkoption(L, 2, "seconds", TimeUnits);
TimeUnit unit = luax_checkenum(L, 2, TimeUnits, "seconds", "TimeUnit");
size_t duration = lovrSourceGetDuration(source);
if (unit == UNIT_SECONDS) {
@ -101,7 +101,7 @@ static int l_lovrSourceGetSampleRate(lua_State* L) {
static int l_lovrSourceGetType(lua_State* L) {
Source* source = luax_checktype(L, 1, Source);
lua_pushstring(L, SourceTypes[lovrSourceGetType(source)]);
luax_pushenum(L, SourceTypes, lovrSourceGetType(source));
return 1;
}
@ -178,7 +178,7 @@ static int l_lovrSourceRewind(lua_State* L) {
static int l_lovrSourceSeek(lua_State* L) {
Source* source = luax_checktype(L, 1, Source);
TimeUnit unit = luaL_checkoption(L, 3, "seconds", TimeUnits);
TimeUnit unit = luax_checkenum(L, 3, TimeUnits, "seconds", "TimeUnit");
if (unit == UNIT_SECONDS) {
float seconds = luax_checkfloat(L, 2);
@ -278,7 +278,7 @@ static int l_lovrSourceStop(lua_State* L) {
static int l_lovrSourceTell(lua_State* L) {
Source* source = luax_checktype(L, 1, Source);
TimeUnit unit = luaL_checkoption(L, 2, "seconds", TimeUnits);
TimeUnit unit = luax_checkenum(L, 2, TimeUnits, "seconds", "TimeUnit");
size_t offset = lovrSourceTell(source);
if (unit == UNIT_SECONDS) {

2
src/api/l_data.c
View File

@ -118,7 +118,7 @@ static int l_lovrDataNewTextureData(lua_State* L) {
if (lua_type(L, 1) == LUA_TNUMBER) {
int width = luaL_checkinteger(L, 1);
int height = luaL_checkinteger(L, 2);
TextureFormat format = luaL_checkoption(L, 3, "rgba", TextureFormats);
TextureFormat format = luax_checkenum(L, 3, TextureFormats, "rgba", "TextureFormat");
textureData = lovrTextureDataCreate(width, height, 0x0, format);
} else {
Blob* blob = luax_readblob(L, 1, "Texture");

2
src/api/l_data_textureData.c
View File

@ -30,7 +30,7 @@ static int l_lovrTextureDataGetDimensions(lua_State* L) {
static int l_lovrTextureDataGetFormat(lua_State* L) {
TextureData* textureData = luax_checktype(L, 1, TextureData);
lua_pushstring(L, TextureFormats[textureData->format]);
luax_pushenum(L, TextureFormats, textureData->format);
return 1;
}

11
src/api/l_event.c
View File

@ -7,12 +7,13 @@
#include <stdlib.h>
#include <string.h>
const char* EventTypes[] = {
[EVENT_QUIT] = "quit",
[EVENT_FOCUS] = "focus",
StringEntry EventTypes[] = {
[EVENT_QUIT] = ENTRY("quit"),
[EVENT_FOCUS] = ENTRY("focus"),
#ifdef LOVR_ENABLE_THREAD
[EVENT_THREAD_ERROR] = "threaderror",
[EVENT_THREAD_ERROR] = ENTRY("threaderror"),
#endif
{ 0 }
};
static LOVR_THREAD_LOCAL int pollRef;
@ -91,7 +92,7 @@ static int nextEvent(lua_State* L) {
if (event.type == EVENT_CUSTOM) {
lua_pushstring(L, event.data.custom.name);
} else {
lua_pushstring(L, EventTypes[event.type]);
luax_pushenum(L, EventTypes, event.type);
}
switch (event.type) {

398
src/api/l_graphics.c
View File

@ -16,218 +16,219 @@
#include <stdbool.h>
#include <stdlib.h>
const char* ArcModes[] = {
[ARC_MODE_PIE] = "pie",
[ARC_MODE_OPEN] = "open",
[ARC_MODE_CLOSED] = "closed",
NULL
StringEntry ArcModes[] = {
[ARC_MODE_PIE] = ENTRY("pie"),
[ARC_MODE_OPEN] = ENTRY("open"),
[ARC_MODE_CLOSED] = ENTRY("closed"),
{ 0 }
};
const char* AttributeTypes[] = {
[I8] = "byte",
[U8] = "ubyte",
[I16] = "short",
[U16] = "ushort",
[I32] = "int",
[U32] = "uint",
[F32] = "float",
NULL
StringEntry AttributeTypes[] = {
[I8] = ENTRY("byte"),
[U8] = ENTRY("ubyte"),
[I16] = ENTRY("short"),
[U16] = ENTRY("ushort"),
[I32] = ENTRY("int"),
[U32] = ENTRY("uint"),
[F32] = ENTRY("float"),
{ 0 }
};
const char* BlendAlphaModes[] = {
[BLEND_ALPHA_MULTIPLY] = "alphamultiply",
[BLEND_PREMULTIPLIED] = "premultiplied",
NULL
StringEntry BlendAlphaModes[] = {
[BLEND_ALPHA_MULTIPLY] = ENTRY("alphamultiply"),
[BLEND_PREMULTIPLIED] = ENTRY("premultiplied"),
{ 0 }
};
const char* BlendModes[] = {
[BLEND_ALPHA] = "alpha",
[BLEND_ADD] = "add",
[BLEND_SUBTRACT] = "subtract",
[BLEND_MULTIPLY] = "multiply",
[BLEND_LIGHTEN] = "lighten",
[BLEND_DARKEN] = "darken",
[BLEND_SCREEN] = "screen",
NULL
StringEntry BlendModes[] = {
[BLEND_ALPHA] = ENTRY("alpha"),
[BLEND_ADD] = ENTRY("add"),
[BLEND_SUBTRACT] = ENTRY("subtract"),
[BLEND_MULTIPLY] = ENTRY("multiply"),
[BLEND_LIGHTEN] = ENTRY("lighten"),
[BLEND_DARKEN] = ENTRY("darken"),
[BLEND_SCREEN] = ENTRY("screen"),
{ 0 }
};
const char* BlockTypes[] = {
[BLOCK_UNIFORM] = "uniform",
[BLOCK_COMPUTE] = "compute",
NULL
StringEntry BlockTypes[] = {
[BLOCK_UNIFORM] = ENTRY("uniform"),
[BLOCK_COMPUTE] = ENTRY("compute"),
{ 0 }
};
const char* BufferUsages[] = {
[USAGE_STATIC] = "static",
[USAGE_DYNAMIC] = "dynamic",
[USAGE_STREAM] = "stream",
NULL
StringEntry BufferUsages[] = {
[USAGE_STATIC] = ENTRY("static"),
[USAGE_DYNAMIC] = ENTRY("dynamic"),
[USAGE_STREAM] = ENTRY("stream"),
{ 0 }
};
const char* CompareModes[] = {
[COMPARE_EQUAL] = "equal",
[COMPARE_NEQUAL] = "notequal",
[COMPARE_LESS] = "less",
[COMPARE_LEQUAL] = "lequal",
[COMPARE_GREATER] = "greater",
[COMPARE_GEQUAL] = "gequal",
NULL
StringEntry CompareModes[] = {
[COMPARE_EQUAL] = ENTRY("equal"),
[COMPARE_NEQUAL] = ENTRY("notequal"),
[COMPARE_LESS] = ENTRY("less"),
[COMPARE_LEQUAL] = ENTRY("lequal"),
[COMPARE_GREATER] = ENTRY("greater"),
[COMPARE_GEQUAL] = ENTRY("gequal"),
{ 0 }
};
const char* CoordinateSpaces[] = {
[SPACE_LOCAL] = "local",
[SPACE_GLOBAL] = "global",
NULL
StringEntry CoordinateSpaces[] = {
[SPACE_LOCAL] = ENTRY("local"),
[SPACE_GLOBAL] = ENTRY("global"),
{ 0 }
};
const char* DefaultShaders[] = {
[SHADER_UNLIT] = "unlit",
[SHADER_STANDARD] = "standard",
[SHADER_CUBE] = "cube",
[SHADER_PANO] = "pano",
[SHADER_FONT] = "font",
[SHADER_FILL] = "screenspace",
NULL
StringEntry DefaultShaders[] = {
[SHADER_UNLIT] = ENTRY("unlit"),
[SHADER_STANDARD] = ENTRY("standard"),
[SHADER_CUBE] = ENTRY("cube"),
[SHADER_PANO] = ENTRY("pano"),
[SHADER_FONT] = ENTRY("font"),
[SHADER_FILL] = ENTRY("screenspace"),
{ 0 }
};
const char* DrawModes[] = {
[DRAW_POINTS] = "points",
[DRAW_LINES] = "lines",
[DRAW_LINE_STRIP] = "linestrip",
[DRAW_LINE_LOOP] = "lineloop",
[DRAW_TRIANGLE_STRIP] = "strip",
[DRAW_TRIANGLES] = "triangles",
[DRAW_TRIANGLE_FAN] = "fan",
NULL
StringEntry DrawModes[] = {
[DRAW_POINTS] = ENTRY("points"),
[DRAW_LINES] = ENTRY("lines"),
[DRAW_LINE_STRIP] = ENTRY("linestrip"),
[DRAW_LINE_LOOP] = ENTRY("lineloop"),
[DRAW_TRIANGLE_STRIP] = ENTRY("strip"),
[DRAW_TRIANGLES] = ENTRY("triangles"),
[DRAW_TRIANGLE_FAN] = ENTRY("fan"),
{ 0 }
};
const char* DrawStyles[] = {
[STYLE_FILL] = "fill",
[STYLE_LINE] = "line",
NULL
StringEntry DrawStyles[] = {
[STYLE_FILL] = ENTRY("fill"),
[STYLE_LINE] = ENTRY("line"),
{ 0 }
};
const char* FilterModes[] = {
[FILTER_NEAREST] = "nearest",
[FILTER_BILINEAR] = "bilinear",
[FILTER_TRILINEAR] = "trilinear",
[FILTER_ANISOTROPIC] = "anisotropic",
NULL
StringEntry FilterModes[] = {
[FILTER_NEAREST] = ENTRY("nearest"),
[FILTER_BILINEAR] = ENTRY("bilinear"),
[FILTER_TRILINEAR] = ENTRY("trilinear"),
[FILTER_ANISOTROPIC] = ENTRY("anisotropic"),
{ 0 }
};
const char* HorizontalAligns[] = {
[ALIGN_LEFT] = "left",
[ALIGN_CENTER] = "center",
[ALIGN_RIGHT] = "right",
NULL
StringEntry HorizontalAligns[] = {
[ALIGN_LEFT] = ENTRY("left"),
[ALIGN_CENTER] = ENTRY("center"),
[ALIGN_RIGHT] = ENTRY("right"),
{ 0 }
};
const char* MaterialColors[] = {
[COLOR_DIFFUSE] = "diffuse",
[COLOR_EMISSIVE] = "emissive",
NULL
StringEntry MaterialColors[] = {
[COLOR_DIFFUSE] = ENTRY("diffuse"),
[COLOR_EMISSIVE] = ENTRY("emissive"),
{ 0 }
};
const char* MaterialScalars[] = {
[SCALAR_METALNESS] = "metalness",
[SCALAR_ROUGHNESS] = "roughness",
NULL
StringEntry MaterialScalars[] = {
[SCALAR_METALNESS] = ENTRY("metalness"),
[SCALAR_ROUGHNESS] = ENTRY("roughness"),
{ 0 }
};
const char* MaterialTextures[] = {
[TEXTURE_DIFFUSE] = "diffuse",
[TEXTURE_EMISSIVE] = "emissive",
[TEXTURE_METALNESS] = "metalness",
[TEXTURE_ROUGHNESS] = "roughness",
[TEXTURE_OCCLUSION] = "occlusion",
[TEXTURE_NORMAL] = "normal",
NULL
StringEntry MaterialTextures[] = {
[TEXTURE_DIFFUSE] = ENTRY("diffuse"),
[TEXTURE_EMISSIVE] = ENTRY("emissive"),
[TEXTURE_METALNESS] = ENTRY("metalness"),
[TEXTURE_ROUGHNESS] = ENTRY("roughness"),
[TEXTURE_OCCLUSION] = ENTRY("occlusion"),
[TEXTURE_NORMAL] = ENTRY("normal"),
{ 0 }
};
const char* ShaderTypes[] = {
[SHADER_GRAPHICS] = "graphics",
[SHADER_COMPUTE] = "compute",
NULL
StringEntry ShaderTypes[] = {
[SHADER_GRAPHICS] = ENTRY("graphics"),
[SHADER_COMPUTE] = ENTRY("compute"),
{ 0 }
};
const char* StencilActions[] = {
[STENCIL_REPLACE] = "replace",
[STENCIL_INCREMENT] = "increment",
[STENCIL_DECREMENT] = "decrement",
[STENCIL_INCREMENT_WRAP] = "incrementwrap",
[STENCIL_DECREMENT_WRAP] = "decrementwrap",
[STENCIL_INVERT] = "invert",
NULL
StringEntry StencilActions[] = {
[STENCIL_REPLACE] = ENTRY("replace"),
[STENCIL_INCREMENT] = ENTRY("increment"),
[STENCIL_DECREMENT] = ENTRY("decrement"),
[STENCIL_INCREMENT_WRAP] = ENTRY("incrementwrap"),
[STENCIL_DECREMENT_WRAP] = ENTRY("decrementwrap"),
[STENCIL_INVERT] = ENTRY("invert"),
{ 0 }
};
const char* TextureFormats[] = {
[FORMAT_RGB] = "rgb",
[FORMAT_RGBA] = "rgba",
[FORMAT_RGBA4] = "rgba4",
[FORMAT_RGBA16F] = "rgba16f",
[FORMAT_RGBA32F] = "rgba32f",
[FORMAT_R16F] = "r16f",
[FORMAT_R32F] = "r32f",
[FORMAT_RG16F] = "rg16f",
[FORMAT_RG32F] = "rg32f",
[FORMAT_RGB5A1] = "rgb5a1",
[FORMAT_RGB10A2] = "rgb10a2",
[FORMAT_RG11B10F] = "rg11b10f",
[FORMAT_D16] = "d16",
[FORMAT_D32F] = "d32f",
[FORMAT_D24S8] = "d24s8",
[FORMAT_DXT1] = "dxt1",
[FORMAT_DXT3] = "dxt3",
[FORMAT_DXT5] = "dxt5",
[FORMAT_ASTC_4x4] = "astc4x4",
[FORMAT_ASTC_5x4] = "astc5x4",
[FORMAT_ASTC_5x5] = "astc5x5",
[FORMAT_ASTC_6x5] = "astc6x5",
[FORMAT_ASTC_6x6] = "astc6x6",
[FORMAT_ASTC_8x5] = "astc8x5",
[FORMAT_ASTC_8x6] = "astc8x6",
[FORMAT_ASTC_8x8] = "astc8x8",
[FORMAT_ASTC_10x5] = "astc10x5",
[FORMAT_ASTC_10x6] = "astc10x6",
[FORMAT_ASTC_10x8] = "astc10x8",
[FORMAT_ASTC_10x10] = "astc10x10",
[FORMAT_ASTC_12x10] = "astc12x10",
[FORMAT_ASTC_12x12] = "astc12x12",
NULL
StringEntry TextureFormats[] = {
[FORMAT_RGB] = ENTRY("rgb"),
[FORMAT_RGBA] = ENTRY("rgba"),
[FORMAT_RGBA4] = ENTRY("rgba4"),
[FORMAT_RGBA16F] = ENTRY("rgba16f"),
[FORMAT_RGBA32F] = ENTRY("rgba32f"),
[FORMAT_R16F] = ENTRY("r16f"),
[FORMAT_R32F] = ENTRY("r32f"),
[FORMAT_RG16F] = ENTRY("rg16f"),
[FORMAT_RG32F] = ENTRY("rg32f"),
[FORMAT_RGB5A1] = ENTRY("rgb5a1"),
[FORMAT_RGB10A2] = ENTRY("rgb10a2"),
[FORMAT_RG11B10F] = ENTRY("rg11b10f"),
[FORMAT_D16] = ENTRY("d16"),
[FORMAT_D32F] = ENTRY("d32f"),
[FORMAT_D24S8] = ENTRY("d24s8"),
[FORMAT_DXT1] = ENTRY("dxt1"),
[FORMAT_DXT3] = ENTRY("dxt3"),
[FORMAT_DXT5] = ENTRY("dxt5"),
[FORMAT_ASTC_4x4] = ENTRY("astc4x4"),
[FORMAT_ASTC_5x4] = ENTRY("astc5x4"),
[FORMAT_ASTC_5x5] = ENTRY("astc5x5"),
[FORMAT_ASTC_6x5] = ENTRY("astc6x5"),
[FORMAT_ASTC_6x6] = ENTRY("astc6x6"),
[FORMAT_ASTC_8x5] = ENTRY("astc8x5"),
[FORMAT_ASTC_8x6] = ENTRY("astc8x6"),
[FORMAT_ASTC_8x8] = ENTRY("astc8x8"),
[FORMAT_ASTC_10x5] = ENTRY("astc10x5"),
[FORMAT_ASTC_10x6] = ENTRY("astc10x6"),
[FORMAT_ASTC_10x8] = ENTRY("astc10x8"),
[FORMAT_ASTC_10x10] = ENTRY("astc10x10"),
[FORMAT_ASTC_12x10] = ENTRY("astc12x10"),
[FORMAT_ASTC_12x12] = ENTRY("astc12x12"),
{ 0 }
};
const char* TextureTypes[] = {
[TEXTURE_2D] = "2d",
[TEXTURE_ARRAY] = "array",
[TEXTURE_CUBE] = "cube",
[TEXTURE_VOLUME] = "volume",
NULL
StringEntry TextureTypes[] = {
[TEXTURE_2D] = ENTRY("2d"),
[TEXTURE_ARRAY] = ENTRY("array"),
[TEXTURE_CUBE] = ENTRY("cube"),
[TEXTURE_VOLUME] = ENTRY("volume"),
{ 0 }
};
const char* UniformAccesses[] = {
[ACCESS_READ] = "read",
[ACCESS_WRITE] = "write",
[ACCESS_READ_WRITE] = "readwrite"
StringEntry UniformAccesses[] = {
[ACCESS_READ] = ENTRY("read"),
[ACCESS_WRITE] = ENTRY("write"),
[ACCESS_READ_WRITE] = ENTRY("readwrite"),
{ 0 }
};
const char* VerticalAligns[] = {
[ALIGN_TOP] = "top",
[ALIGN_MIDDLE] = "middle",
[ALIGN_BOTTOM] = "bottom",
NULL
StringEntry VerticalAligns[] = {
[ALIGN_TOP] = ENTRY("top"),
[ALIGN_MIDDLE] = ENTRY("middle"),
[ALIGN_BOTTOM] = ENTRY("bottom"),
{ 0 }
};
const char* Windings[] = {
[WINDING_CLOCKWISE] = "clockwise",
[WINDING_COUNTERCLOCKWISE] = "counterclockwise",
NULL
StringEntry Windings[] = {
[WINDING_CLOCKWISE] = ENTRY("clockwise"),
[WINDING_COUNTERCLOCKWISE] = ENTRY("counterclockwise"),
{ 0 }
};
const char* WrapModes[] = {
[WRAP_CLAMP] = "clamp",
[WRAP_REPEAT] = "repeat",
[WRAP_MIRRORED_REPEAT] = "mirroredrepeat",
NULL
StringEntry WrapModes[] = {
[WRAP_CLAMP] = ENTRY("clamp"),
[WRAP_REPEAT] = ENTRY("repeat"),
[WRAP_MIRRORED_REPEAT] = ENTRY("mirroredrepeat"),
{ 0 }
};
static uint32_t luax_getvertexcount(lua_State* L, int index) {
@ -513,14 +514,14 @@ static int l_lovrGraphicsGetBlendMode(lua_State* L) {
BlendMode mode;
BlendAlphaMode alphaMode;
lovrGraphicsGetBlendMode(&mode, &alphaMode);
lua_pushstring(L, BlendModes[mode]);
lua_pushstring(L, BlendAlphaModes[alphaMode]);
luax_pushenum(L, BlendModes, mode);
luax_pushenum(L, BlendAlphaModes, alphaMode);
return 2;
}
static int l_lovrGraphicsSetBlendMode(lua_State* L) {
BlendMode mode = lua_isnoneornil(L, 1) ? BLEND_NONE : luaL_checkoption(L, 1, NULL, BlendModes);
BlendAlphaMode alphaMode = luaL_checkoption(L, 2, "alphamultiply", BlendAlphaModes);
BlendMode mode = lua_isnoneornil(L, 1) ? BLEND_NONE : luax_checkenum(L, 1, BlendModes, NULL, "BlendMode");
BlendAlphaMode alphaMode = luax_checkenum(L, 2, BlendAlphaModes, "alphamultiply", "BlendAlphaMode");
lovrGraphicsSetBlendMode(mode, alphaMode);
return 0;
}
@ -584,7 +585,7 @@ static int l_lovrGraphicsSetCullingEnabled(lua_State* L) {
static int l_lovrGraphicsGetDefaultFilter(lua_State* L) {
TextureFilter filter = lovrGraphicsGetDefaultFilter();
lua_pushstring(L, FilterModes[filter.mode]);
luax_pushenum(L, FilterModes, filter.mode);
if (filter.mode == FILTER_ANISOTROPIC) {
lua_pushnumber(L, filter.anisotropy);
return 2;
@ -593,7 +594,7 @@ static int l_lovrGraphicsGetDefaultFilter(lua_State* L) {
}
static int l_lovrGraphicsSetDefaultFilter(lua_State* L) {
FilterMode mode = luaL_checkoption(L, 1, NULL, FilterModes);
FilterMode mode = luax_checkenum(L, 1, FilterModes, NULL, "FilterMode");
float anisotropy = luax_optfloat(L, 2, 1.f);
lovrGraphicsSetDefaultFilter((TextureFilter) { .mode = mode, .anisotropy = anisotropy });
return 0;
@ -603,13 +604,13 @@ static int l_lovrGraphicsGetDepthTest(lua_State* L) {
CompareMode mode;
bool write;
lovrGraphicsGetDepthTest(&mode, &write);
lua_pushstring(L, CompareModes[mode]);
luax_pushenum(L, CompareModes, mode);
lua_pushboolean(L, write);
return 2;
}
static int l_lovrGraphicsSetDepthTest(lua_State* L) {
CompareMode mode = lua_isnoneornil(L, 1) ? COMPARE_NONE : luaL_checkoption(L, 1, NULL, CompareModes);
CompareMode mode = lua_isnoneornil(L, 1) ? COMPARE_NONE : luax_checkenum(L, 1, CompareModes, NULL, "CompareMode");
bool write = lua_isnoneornil(L, 2) ? true : lua_toboolean(L, 2);
lovrGraphicsSetDepthTest(mode, write);
return 0;
@ -665,7 +666,7 @@ static int l_lovrGraphicsGetStencilTest(lua_State* L) {
CompareMode mode;
int value;
lovrGraphicsGetStencilTest(&mode, &value);
lua_pushstring(L, CompareModes[mode]);
luax_pushenum(L, CompareModes, mode);
lua_pushinteger(L, value);
return 2;
}
@ -674,7 +675,7 @@ static int l_lovrGraphicsSetStencilTest(lua_State* L) {
if (lua_isnoneornil(L, 1)) {
lovrGraphicsSetStencilTest(COMPARE_NONE, 0);
} else {
CompareMode mode = luaL_checkoption(L, 1, NULL, CompareModes);
CompareMode mode = luax_checkenum(L, 1, CompareModes, NULL, "CompareMode");
int value = luaL_checkinteger(L, 2);
lovrGraphicsSetStencilTest(mode, value);
}
@ -682,12 +683,13 @@ static int l_lovrGraphicsSetStencilTest(lua_State* L) {
}
static int l_lovrGraphicsGetWinding(lua_State* L) {
lua_pushstring(L, Windings[lovrGraphicsGetWinding()]);
luax_pushenum(L, Windings, lovrGraphicsGetWinding());
return 1;
}
static int l_lovrGraphicsSetWinding(lua_State* L) {
lovrGraphicsSetWinding(luaL_checkoption(L, 1, NULL, Windings));
Winding winding = luax_checkenum(L, 1, Windings, NULL, "Winding");
lovrGraphicsSetWinding(winding);
return 0;
}
@ -839,7 +841,7 @@ static int l_lovrGraphicsTriangle(lua_State* L) {
if (lua_isuserdata(L, 1)) {
material = luax_checktype(L, 1, Material);
} else {
style = luaL_checkoption(L, 1, NULL, DrawStyles);
style = luax_checkenum(L, 1, DrawStyles, NULL, "DrawStyle");
}
float* vertices;
@ -856,7 +858,7 @@ static int l_lovrGraphicsPlane(lua_State* L) {
if (lua_isuserdata(L, 1)) {
material = luax_checktype(L, 1, Material);
} else {
style = luaL_checkoption(L, 1, NULL, DrawStyles);
style = luax_checkenum(L, 1, DrawStyles, NULL, "DrawStyle");
}
float transform[16];
int index = luax_readmat4(L, 2, transform, 2);
@ -874,7 +876,7 @@ static int luax_rectangularprism(lua_State* L, int scaleComponents) {
if (lua_isuserdata(L, 1)) {
material = luax_checktype(L, 1, Material);
} else {
style = luaL_checkoption(L, 1, NULL, DrawStyles);
style = luax_checkenum(L, 1, DrawStyles, NULL, "DrawStyle");
}
float transform[16];
luax_readmat4(L, 2, transform, scaleComponents);
@ -896,12 +898,12 @@ static int l_lovrGraphicsArc(lua_State* L) {
if (lua_isuserdata(L, 1)) {
material = luax_checktype(L, 1, Material);
} else {
style = luaL_checkoption(L, 1, NULL, DrawStyles);
style = luax_checkenum(L, 1, DrawStyles, NULL, "DrawStyle");
}
ArcMode mode = ARC_MODE_PIE;
int index = 2;
if (lua_type(L, index) == LUA_TSTRING) {
mode = luaL_checkoption(L, index++, NULL, ArcModes);
mode = luax_checkenum(L, index++, ArcModes, NULL, "ArcMode");
}
float transform[16];
index = luax_readmat4(L, index, transform, 1);
@ -918,7 +920,7 @@ static int l_lovrGraphicsCircle(lua_State* L) {
if (lua_isuserdata(L, 1)) {
material = luax_checktype(L, 1, Material);
} else {
style = luaL_checkoption(L, 1, NULL, DrawStyles);
style = luax_checkenum(L, 1, DrawStyles, NULL, "DrawStyle");
}
float transform[16];
int index = luax_readmat4(L, 2, transform, 1);
@ -962,15 +964,15 @@ static int l_lovrGraphicsPrint(lua_State* L) {
float transform[16];
int index = luax_readmat4(L, 2, transform, 1);
float wrap = luax_optfloat(L, index++, 0.f);
HorizontalAlign halign = luaL_checkoption(L, index++, "center", HorizontalAligns);
VerticalAlign valign = luaL_checkoption(L, index++, "middle", VerticalAligns);
HorizontalAlign halign = luax_checkenum(L, index++, HorizontalAligns, "center", "HorizontalAlign");
VerticalAlign valign = luax_checkenum(L, index++, VerticalAligns, "middle", "VerticalAlign");
lovrGraphicsPrint(str, length, transform, wrap, halign, valign);
return 0;
}
static int l_lovrGraphicsStencil(lua_State* L) {
luaL_checktype(L, 1, LUA_TFUNCTION);
StencilAction action = luaL_checkoption(L, 2, "replace", StencilActions);
StencilAction action = luax_checkenum(L, 2, StencilActions, "replace", "StencilAction");
int replaceValue = luaL_optinteger(L, 3, 1);
bool keepValues = lua_toboolean(L, 4);
if (!keepValues) {
@ -1073,14 +1075,14 @@ static int l_lovrGraphicsNewCanvas(lua_State* L) {
switch (lua_type(L, -1)) {
case LUA_TNIL: break;
case LUA_TBOOLEAN: flags.depth.enabled = lua_toboolean(L, -1); break;
case LUA_TSTRING: flags.depth.format = luaL_checkoption(L, -1, NULL, TextureFormats); break;
case LUA_TSTRING: flags.depth.format = luax_checkenum(L, -1, TextureFormats, NULL, "TextureFormat"); break;
case LUA_TTABLE:
lua_getfield(L, -1, "readable");
flags.depth.readable = lua_toboolean(L, -1);
lua_pop(L, 1);
lua_getfield(L, -1, "format");
flags.depth.format = luaL_checkoption(L, -1, NULL, TextureFormats);
flags.depth.format = luax_checkenum(L, -1, TextureFormats, NULL, "TextureFormat");
lua_pop(L, 1);
break;
default: lovrThrow("Expected boolean, string, or table for Canvas depth flag");
@ -1101,7 +1103,7 @@ static int l_lovrGraphicsNewCanvas(lua_State* L) {
if (attachmentCount == 0) {
lua_getfield(L, index, "format");
format = luaL_checkoption(L, -1, "rgba", TextureFormats);
format = luax_checkenum(L, -1, TextureFormats, "rgba", "TextureFormat");
anonymous = lua_isnil(L, -1) || lua_toboolean(L, -1);
lua_pop(L, 1);
}
@ -1251,7 +1253,7 @@ static int l_lovrGraphicsNewMesh(lua_State* L) {
attributeNames[i] = lua_tostring(L, -1);
attributes[i].offset = (uint32_t) stride;
attributes[i].type = luaL_checkoption(L, -2, "float", AttributeTypes);
attributes[i].type = luax_checkenum(L, -2, AttributeTypes, "float", "AttributeType");
attributes[i].components = luaL_optinteger(L, -3, 1);
switch (attributes[i].type) {
@ -1268,8 +1270,8 @@ static int l_lovrGraphicsNewMesh(lua_State* L) {
count = (uint32_t) (blob->size / stride);
}
DrawMode mode = luaL_checkoption(L, drawModeIndex, "fan", DrawModes);
BufferUsage usage = luaL_checkoption(L, drawModeIndex + 1, "dynamic", BufferUsages);
DrawMode mode = luax_checkenum(L, drawModeIndex, DrawModes, "fan", "DrawMode");
BufferUsage usage = luax_checkenum(L, drawModeIndex + 1, BufferUsages, "dynamic", "BufferUsage");
bool readable = lua_toboolean(L, drawModeIndex + 2);
Buffer* vertexBuffer = lovrBufferCreate(count * stride, NULL, BUFFER_VERTEX, usage, readable);
Mesh* mesh = lovrMeshCreate(mode, vertexBuffer, count);
@ -1423,7 +1425,7 @@ static int l_lovrGraphicsNewShader(lua_State* L) {
Shader* shader;
if (lua_isstring(L, 1) && (lua_istable(L, 2) || lua_gettop(L) == 1)) {
DefaultShader shaderType = luaL_checkoption(L, 1, NULL, DefaultShaders);
DefaultShader shaderType = luax_checkenum(L, 1, DefaultShaders, NULL, "DefaultShader");
if (lua_istable(L, 2)) {
lua_getfield(L, 2, "flags");
@ -1491,7 +1493,7 @@ static int l_lovrGraphicsNewShaderBlock(lua_State* L) {
arr_uniform_t uniforms;
arr_init(&uniforms);
BlockType type = luaL_checkoption(L, 1, NULL, BlockTypes);
BlockType type = luax_checkenum(L, 1, BlockTypes, NULL, "Blocktype");
luaL_checktype(L, 2, LUA_TTABLE);
lua_pushnil(L);
@ -1528,7 +1530,7 @@ static int l_lovrGraphicsNewShaderBlock(lua_State* L) {
if (lua_istable(L, 3)) {
lua_getfield(L, 3, "usage");
usage = luaL_checkoption(L, -1, "dynamic", BufferUsages);
usage = luax_checkenum(L, -1, BufferUsages, "dynamic", "BufferUsage");
lua_pop(L, 1);
lua_getfield(L, 3, "readable");
@ -1587,11 +1589,11 @@ static int l_lovrGraphicsNewTexture(lua_State* L) {
lua_pop(L, 1);
lua_getfield(L, index, "type");
type = lua_isnil(L, -1) ? type : (TextureType) luaL_checkoption(L, -1, NULL, TextureTypes);
type = lua_isnil(L, -1) ? type : (TextureType) luax_checkenum(L, -1, TextureTypes, NULL, "TextureType");
lua_pop(L, 1);
lua_getfield(L, index, "format");
format = lua_isnil(L, -1) ? format : (TextureFormat) luaL_checkoption(L, -1, NULL, TextureFormats);
format = lua_isnil(L, -1) ? format : (TextureFormat) luax_checkenum(L, -1, TextureFormats, NULL, "TextureFormat");
lua_pop(L, 1);
lua_getfield(L, index, "msaa");

12
src/api/l_graphics_material.c
View File

@ -4,7 +4,7 @@
static int l_lovrMaterialGetColor(lua_State* L) {
Material* material = luax_checktype(L, 1, Material);
MaterialColor colorType = luaL_checkoption(L, 2, "diffuse", MaterialColors);
MaterialColor colorType = luax_checkenum(L, 2, MaterialColors, "diffuse", "MaterialColor");
Color color = lovrMaterialGetColor(material, colorType);
lua_pushnumber(L, color.r);
lua_pushnumber(L, color.g);
@ -18,7 +18,7 @@ static int l_lovrMaterialSetColor(lua_State* L) {
MaterialColor colorType = COLOR_DIFFUSE;
int index = 2;
if (lua_type(L, index) == LUA_TSTRING) {
colorType = luaL_checkoption(L, index, NULL, MaterialColors);
colorType = luax_checkenum(L, index, MaterialColors, NULL, "MaterialColor");
index++;
}
Color color;
@ -29,7 +29,7 @@ static int l_lovrMaterialSetColor(lua_State* L) {
static int l_lovrMaterialGetScalar(lua_State* L) {
Material* material = luax_checktype(L, 1, Material);
MaterialScalar scalarType = luaL_checkoption(L, 2, NULL, MaterialScalars);
MaterialScalar scalarType = luax_checkenum(L, 2, MaterialScalars, NULL, "MaterialScalar");
float value = lovrMaterialGetScalar(material, scalarType);
lua_pushnumber(L, value);
return 1;
@ -37,7 +37,7 @@ static int l_lovrMaterialGetScalar(lua_State* L) {
static int l_lovrMaterialSetScalar(lua_State* L) {
Material* material = luax_checktype(L, 1, Material);
MaterialScalar scalarType = luaL_checkoption(L, 2, NULL, MaterialScalars);
MaterialScalar scalarType = luax_checkenum(L, 2, MaterialScalars, NULL, "MaterialScalar");
float value = luax_checkfloat(L, 3);
lovrMaterialSetScalar(material, scalarType, value);
return 0;
@ -45,7 +45,7 @@ static int l_lovrMaterialSetScalar(lua_State* L) {
static int l_lovrMaterialGetTexture(lua_State* L) {
Material* material = luax_checktype(L, 1, Material);
MaterialTexture textureType = luaL_checkoption(L, 2, "diffuse", MaterialTextures);
MaterialTexture textureType = luax_checkenum(L, 2, MaterialTextures, "diffuse", "MaterialTexture");
Texture* texture = lovrMaterialGetTexture(material, textureType);
luax_pushtype(L, Texture, texture);
return 1;
@ -56,7 +56,7 @@ static int l_lovrMaterialSetTexture(lua_State* L) {
MaterialTexture textureType = TEXTURE_DIFFUSE;
int index = 2;
if (lua_type(L, index) == LUA_TSTRING) {
textureType = luaL_checkoption(L, index, NULL, MaterialTextures);
textureType = luax_checkenum(L, index, MaterialTextures, NULL, "MaterialTexture");
index++;
}
Texture* texture = lua_isnoneornil(L, index) ? NULL : luax_checktype(L, index, Texture);

6
src/api/l_graphics_mesh.c
View File

@ -85,13 +85,13 @@ static int l_lovrMeshDraw(lua_State* L) {
static int l_lovrMeshGetDrawMode(lua_State* L) {
Mesh* mesh = luax_checktype(L, 1, Mesh);
lua_pushstring(L, DrawModes[lovrMeshGetDrawMode(mesh)]);
luax_pushenum(L, DrawModes, lovrMeshGetDrawMode(mesh));
return 1;
}
static int l_lovrMeshSetDrawMode(lua_State* L) {
Mesh* mesh = luax_checktype(L, 1, Mesh);
DrawMode mode = luaL_checkoption(L, 2, NULL, DrawModes);
DrawMode mode = luax_checkenum(L, 2, DrawModes, NULL, "DrawMode");
lovrMeshSetDrawMode(mesh, mode);
return 0;
}
@ -107,7 +107,7 @@ static int l_lovrMeshGetVertexFormat(lua_State* L) {
lua_createtable(L, 3, 0);
lua_pushstring(L, mesh->attributeNames[i]);
lua_rawseti(L, -2, 1);
lua_pushstring(L, AttributeTypes[attribute->type]);
luax_pushenum(L, AttributeTypes, attribute->type);
lua_rawseti(L, -2, 2);
lua_pushinteger(L, attribute->components);
lua_rawseti(L, -2, 3);

2
src/api/l_graphics_model.c
View File

@ -127,7 +127,7 @@ static int l_lovrModelGetNodePose(lua_State* L) {
}
float position[4], rotation[4], angle, ax, ay, az;
CoordinateSpace space = luaL_checkoption(L, 3, "global", CoordinateSpaces);
CoordinateSpace space = luax_checkenum(L, 3, CoordinateSpaces, "global", "CoordinateSpace");
lovrModelGetNodePose(model, node, position, rotation, space);
lua_pushnumber(L, position[0]);
lua_pushnumber(L, position[1]);

6
src/api/l_graphics_shader.c
View File

@ -186,7 +186,7 @@ int luax_checkuniform(lua_State* L, int index, const Uniform* uniform, void* des
static int l_lovrShaderGetType(lua_State* L) {
Shader* shader = luax_checktype(L, 1, Shader);
lua_pushstring(L, ShaderTypes[lovrShaderGetType(shader)]);
luax_pushenum(L, ShaderTypes, lovrShaderGetType(shader));
return 1;
}
@ -231,7 +231,7 @@ static int l_lovrShaderSendBlock(lua_State* L) {
const char* name = luaL_checkstring(L, 2);
lovrAssert(lovrShaderHasBlock(shader, name), "Unknown shader block '%s'", name);
ShaderBlock* block = luax_checktype(L, 3, ShaderBlock);
UniformAccess access = luaL_checkoption(L, 4, "readwrite", UniformAccesses);
UniformAccess access = luax_checkenum(L, 4, UniformAccesses, "readwrite", "UniformAccess");
Buffer* buffer = lovrShaderBlockGetBuffer(block);
lovrShaderSetBlock(shader, name, buffer, 0, lovrBufferGetSize(buffer), access);
return 0;
@ -250,7 +250,7 @@ static int l_lovrShaderSendImage(lua_State* L) {
Texture* texture = luax_checktype(L, index++, Texture);
int slice = luaL_optinteger(L, index++, 0) - 1; // Default is -1
int mipmap = luax_optmipmap(L, index++, texture);
UniformAccess access = luaL_checkoption(L, index++, "readwrite", UniformAccesses);
UniformAccess access = luax_checkenum(L, index++, UniformAccesses, "readwrite", "UniformAccess");
Image image = { .texture = texture, .slice = slice, .mipmap = mipmap, .access = access };
lovrShaderSetImages(shader, name, &image, start, 1);
return 0;

2
src/api/l_graphics_shaderBlock.c
View File

@ -6,7 +6,7 @@
static int l_lovrShaderBlockGetType(lua_State* L) {
ShaderBlock* block = luax_checktype(L, 1, ShaderBlock);
lua_pushstring(L, BlockTypes[lovrShaderBlockGetType(block)]);
luax_pushenum(L, BlockTypes, lovrShaderBlockGetType(block));
return 1;
}

24
src/api/l_graphics_texture.c
View File

@ -9,7 +9,7 @@ int luax_optmipmap(lua_State* L, int index, Texture* texture) {
static int l_lovrTextureGetCompareMode(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
lua_pushstring(L, CompareModes[lovrTextureGetCompareMode(texture)]);
luax_pushenum(L, CompareModes, lovrTextureGetCompareMode(texture));
return 1;
}
@ -34,7 +34,7 @@ static int l_lovrTextureGetDimensions(lua_State* L) {
static int l_lovrTextureGetFilter(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
TextureFilter filter = lovrTextureGetFilter(texture);
lua_pushstring(L, FilterModes[filter.mode]);
luax_pushenum(L, FilterModes, filter.mode);
if (filter.mode == FILTER_ANISOTROPIC) {
lua_pushnumber(L, filter.anisotropy);
return 2;
@ -44,7 +44,7 @@ static int l_lovrTextureGetFilter(lua_State* L) {
static int l_lovrTextureGetFormat(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
lua_pushstring(L, TextureFormats[lovrTextureGetFormat(texture)]);
luax_pushenum(L, TextureFormats, lovrTextureGetFormat(texture));
return 1;
}
@ -62,7 +62,7 @@ static int l_lovrTextureGetMipmapCount(lua_State* L) {
static int l_lovrTextureGetType(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
lua_pushstring(L, TextureTypes[lovrTextureGetType(texture)]);
luax_pushenum(L, TextureTypes, lovrTextureGetType(texture));
return 1;
}
@ -75,10 +75,10 @@ static int l_lovrTextureGetWidth(lua_State* L) {
static int l_lovrTextureGetWrap(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
TextureWrap wrap = lovrTextureGetWrap(texture);
lua_pushstring(L, WrapModes[wrap.s]);
lua_pushstring(L, WrapModes[wrap.t]);
luax_pushenum(L, WrapModes, wrap.s);
luax_pushenum(L, WrapModes, wrap.t);
if (lovrTextureGetType(texture) == TEXTURE_CUBE) {
lua_pushstring(L, WrapModes[wrap.r]);
luax_pushenum(L, WrapModes, wrap.r);
return 3;
}
return 2;
@ -97,14 +97,14 @@ static int l_lovrTextureReplacePixels(lua_State* L) {
static int l_lovrTextureSetCompareMode(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
CompareMode mode = lua_isnoneornil(L, 2) ? COMPARE_NONE : luaL_checkoption(L, 2, NULL, CompareModes);
CompareMode mode = lua_isnoneornil(L, 2) ? COMPARE_NONE : luax_checkenum(L, 2, CompareModes, NULL, "CompareMode");
lovrTextureSetCompareMode(texture, mode);
return 0;
}
static int l_lovrTextureSetFilter(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
FilterMode mode = luaL_checkoption(L, 2, NULL, FilterModes);
FilterMode mode = luax_checkenum(L, 2, FilterModes, NULL, "FilterMode");
float anisotropy = luax_optfloat(L, 3, 1.f);
TextureFilter filter = { .mode = mode, .anisotropy = anisotropy };
lovrTextureSetFilter(texture, filter);
@ -114,9 +114,9 @@ static int l_lovrTextureSetFilter(lua_State* L) {
static int l_lovrTextureSetWrap(lua_State* L) {
Texture* texture = luax_checktype(L, 1, Texture);
TextureWrap wrap;
wrap.s = luaL_checkoption(L, 2, NULL, WrapModes);
wrap.t = luaL_checkoption(L, 3, luaL_checkstring(L, 2), WrapModes);
wrap.r = luaL_checkoption(L, 4, luaL_checkstring(L, 2), WrapModes);
wrap.s = luax_checkenum(L, 2, WrapModes, NULL, "WrapMode");
wrap.t = luax_checkenum(L, 3, WrapModes, lua_tostring(L, 2), "WrapMode");
wrap.r = luax_checkenum(L, 4, WrapModes, lua_tostring(L, 2), "WrapMode");
lovrTextureSetWrap(texture, wrap);
return 0;
}

128
src/api/l_headset.c
View File

@ -12,67 +12,67 @@
#define LOVR_HEADSET_HELPER_USES_REGISTRY
#endif
const char* HeadsetDrivers[] = {
[DRIVER_DESKTOP] = "desktop",
[DRIVER_LEAP_MOTION] = "leap",
[DRIVER_OCULUS] = "oculus",
[DRIVER_OCULUS_MOBILE] = "oculusmobile",
[DRIVER_OPENVR] = "openvr",
[DRIVER_OPENXR] = "openxr",
[DRIVER_WEBVR] = "webvr",
NULL
StringEntry HeadsetDrivers[] = {
[DRIVER_DESKTOP] = ENTRY("desktop"),
[DRIVER_LEAP_MOTION] = ENTRY("leap"),
[DRIVER_OCULUS] = ENTRY("oculus"),
[DRIVER_OCULUS_MOBILE] = ENTRY("oculusmobile"),
[DRIVER_OPENVR] = ENTRY("openvr"),
[DRIVER_OPENXR] = ENTRY("openxr"),
[DRIVER_WEBVR] = ENTRY("webvr"),
{ 0 }
};
const char* HeadsetOrigins[] = {
[ORIGIN_HEAD] = "head",
[ORIGIN_FLOOR] = "floor",
NULL
StringEntry HeadsetOrigins[] = {
[ORIGIN_HEAD] = ENTRY("head"),
[ORIGIN_FLOOR] = ENTRY("floor"),
{ 0 }
};
const char* Devices[] = {
[DEVICE_HEAD] = "head",
[DEVICE_HAND_LEFT] = "hand/left",
[DEVICE_HAND_RIGHT] = "hand/right",
[DEVICE_HAND_LEFT_POINT] = "hand/left/point",
[DEVICE_HAND_RIGHT_POINT] = "hand/right/point",
[DEVICE_EYE_LEFT] = "eye/left",
[DEVICE_EYE_RIGHT] = "eye/right",
[DEVICE_HAND_LEFT_FINGER_THUMB] = "hand/left/finger/thumb",
[DEVICE_HAND_LEFT_FINGER_INDEX] = "hand/left/finger/index",
[DEVICE_HAND_LEFT_FINGER_MIDDLE] = "hand/left/finger/middle",
[DEVICE_HAND_LEFT_FINGER_RING] = "hand/left/finger/ring",
[DEVICE_HAND_LEFT_FINGER_PINKY] = "hand/left/finger/pinky",
[DEVICE_HAND_RIGHT_FINGER_THUMB] = "hand/right/finger/thumb",
[DEVICE_HAND_RIGHT_FINGER_INDEX] = "hand/right/finger/index",
[DEVICE_HAND_RIGHT_FINGER_MIDDLE] = "hand/right/finger/middle",
[DEVICE_HAND_RIGHT_FINGER_RING] = "hand/right/finger/ring",
[DEVICE_HAND_RIGHT_FINGER_PINKY] = "hand/right/finger/pinky",
NULL
StringEntry Devices[] = {
[DEVICE_HEAD] = ENTRY("head"),
[DEVICE_HAND_LEFT] = ENTRY("hand/left"),
[DEVICE_HAND_RIGHT] = ENTRY("hand/right"),
[DEVICE_HAND_LEFT_POINT] = ENTRY("hand/left/point"),
[DEVICE_HAND_RIGHT_POINT] = ENTRY("hand/right/point"),
[DEVICE_EYE_LEFT] = ENTRY("eye/left"),
[DEVICE_EYE_RIGHT] = ENTRY("eye/right"),
[DEVICE_HAND_LEFT_FINGER_THUMB] = ENTRY("hand/left/finger/thumb"),
[DEVICE_HAND_LEFT_FINGER_INDEX] = ENTRY("hand/left/finger/index"),
[DEVICE_HAND_LEFT_FINGER_MIDDLE] = ENTRY("hand/left/finger/middle"),
[DEVICE_HAND_LEFT_FINGER_RING] = ENTRY("hand/left/finger/ring"),
[DEVICE_HAND_LEFT_FINGER_PINKY] = ENTRY("hand/left/finger/pinky"),
[DEVICE_HAND_RIGHT_FINGER_THUMB] = ENTRY("hand/right/finger/thumb"),
[DEVICE_HAND_RIGHT_FINGER_INDEX] = ENTRY("hand/right/finger/index"),
[DEVICE_HAND_RIGHT_FINGER_MIDDLE] = ENTRY("hand/right/finger/middle"),
[DEVICE_HAND_RIGHT_FINGER_RING] = ENTRY("hand/right/finger/ring"),
[DEVICE_HAND_RIGHT_FINGER_PINKY] = ENTRY("hand/right/finger/pinky"),
{ 0 }
};
const char* DeviceButtons[] = {
[BUTTON_TRIGGER] = "trigger",
[BUTTON_THUMBSTICK] = "thumbstick",
[BUTTON_TOUCHPAD] = "touchpad",
[BUTTON_GRIP] = "grip",
[BUTTON_MENU] = "menu",
[BUTTON_A] = "a",
[BUTTON_B] = "b",
[BUTTON_X] = "x",
[BUTTON_Y] = "y",
[BUTTON_PROXIMITY] = "proximity",
NULL
StringEntry DeviceButtons[] = {
[BUTTON_TRIGGER] = ENTRY("trigger"),
[BUTTON_THUMBSTICK] = ENTRY("thumbstick"),
[BUTTON_TOUCHPAD] = ENTRY("touchpad"),
[BUTTON_GRIP] = ENTRY("grip"),
[BUTTON_MENU] = ENTRY("menu"),
[BUTTON_A] = ENTRY("a"),
[BUTTON_B] = ENTRY("b"),
[BUTTON_X] = ENTRY("x"),
[BUTTON_Y] = ENTRY("y"),
[BUTTON_PROXIMITY] = ENTRY("proximity"),
{ 0 }
};
const char* DeviceAxes[] = {
[AXIS_TRIGGER] = "trigger",
[AXIS_THUMBSTICK] = "thumbstick",
[AXIS_TOUCHPAD] = "touchpad",
[AXIS_GRIP] = "grip",
[AXIS_CURL] = "curl",
[AXIS_SPLAY] = "splay",
[AXIS_PINCH] = "pinch",
NULL
StringEntry DeviceAxes[] = {
[AXIS_TRIGGER] = ENTRY("trigger"),
[AXIS_THUMBSTICK] = ENTRY("thumbstick"),
[AXIS_TOUCHPAD] = ENTRY("touchpad"),
[AXIS_GRIP] = ENTRY("grip"),
[AXIS_CURL] = ENTRY("curl"),
[AXIS_SPLAY] = ENTRY("splay"),
[AXIS_PINCH] = ENTRY("pinch"),
{ 0 }
};
typedef struct {
@ -108,18 +108,18 @@ static Device luax_optdevice(lua_State* L, int index) {
} else if (!strcmp(str, "right")) {
return DEVICE_HAND_RIGHT;
}
return luaL_checkoption(L, 1, "head", Devices);
return luax_checkenum(L, 1, Devices, "head", "Device");
}
static int l_lovrHeadsetGetDriver(lua_State* L) {
if (lua_gettop(L) == 0) {
lua_pushstring(L, HeadsetDrivers[lovrHeadsetDriver->driverType]);
luax_pushenum(L, HeadsetDrivers, lovrHeadsetDriver->driverType);
return 1;
} else {
Device device = luax_optdevice(L, 1);
FOREACH_TRACKING_DRIVER(driver) {
if (driver->getPose(device, NULL, NULL)) {
lua_pushstring(L, HeadsetDrivers[driver->driverType]);
luax_pushenum(L, HeadsetDrivers, driver->driverType);
return 1;
}
}
@ -138,7 +138,7 @@ static int l_lovrHeadsetGetName(lua_State* L) {
}
static int l_lovrHeadsetGetOriginType(lua_State* L) {
lua_pushstring(L, HeadsetOrigins[lovrHeadsetDriver->getOriginType()]);
luax_pushenum(L, HeadsetOrigins, lovrHeadsetDriver->getOriginType());
return 1;
}
@ -411,7 +411,7 @@ static int l_lovrHeadsetGetAngularVelocity(lua_State* L) {
static int l_lovrHeadsetIsDown(lua_State* L) {
Device device = luax_optdevice(L, 1);
DeviceButton button = luaL_checkoption(L, 2, NULL, DeviceButtons);
DeviceButton button = luax_checkenum(L, 2, DeviceButtons, NULL, "DeviceButton");
bool down, changed;
FOREACH_TRACKING_DRIVER(driver) {
if (driver->isDown(device, button, &down, &changed)) {
@ -425,7 +425,7 @@ static int l_lovrHeadsetIsDown(lua_State* L) {
static int l_lovrHeadsetWasPressed(lua_State* L) {
Device device = luax_optdevice(L, 1);
DeviceButton button = luaL_checkoption(L, 2, NULL, DeviceButtons);
DeviceButton button = luax_checkenum(L, 2, DeviceButtons, NULL, "DeviceButton");
bool down, changed;
FOREACH_TRACKING_DRIVER(driver) {
if (driver->isDown(device, button, &down, &changed)) {
@ -439,7 +439,7 @@ static int l_lovrHeadsetWasPressed(lua_State* L) {
static int l_lovrHeadsetWasReleased(lua_State* L) {
Device device = luax_optdevice(L, 1);
DeviceButton button = luaL_checkoption(L, 2, NULL, DeviceButtons);
DeviceButton button = luax_checkenum(L, 2, DeviceButtons, NULL, "DeviceButton");
bool down, changed;
FOREACH_TRACKING_DRIVER(driver) {
if (driver->isDown(device, button, &down, &changed)) {
@ -453,7 +453,7 @@ static int l_lovrHeadsetWasReleased(lua_State* L) {
static int l_lovrHeadsetIsTouched(lua_State* L) {
Device device = luax_optdevice(L, 1);
DeviceButton button = luaL_checkoption(L, 2, NULL, DeviceButtons);
DeviceButton button = luax_checkenum(L, 2, DeviceButtons, NULL, "DeviceButton");
bool touched;
FOREACH_TRACKING_DRIVER(driver) {
if (driver->isTouched(device, button, &touched)) {
@ -477,7 +477,7 @@ static const int axisCounts[MAX_AXES] = {
static int l_lovrHeadsetGetAxis(lua_State* L) {
Device device = luax_optdevice(L, 1);
DeviceAxis axis = luaL_checkoption(L, 2, NULL, DeviceAxes);
DeviceAxis axis = luax_checkenum(L, 2, DeviceAxes, NULL, "DeviceAxis");
int count = axisCounts[axis];
float value[4];
FOREACH_TRACKING_DRIVER(driver) {
@ -636,7 +636,7 @@ static int l_lovrHeadsetGetHands(lua_State* L) {
for (size_t i = 0; i < sizeof(hands) / sizeof(hands[0]); i++) {
FOREACH_TRACKING_DRIVER(driver) {
if (driver->getPose(hands[i], position, orientation)) {
lua_pushstring(L, Devices[hands[i]]);
luax_pushenum(L, Devices, hands[i]);
lua_rawseti(L, -2, ++count);
}
}
@ -705,7 +705,7 @@ int luaopen_lovr_headset(lua_State* L) {
int n = luax_len(L, -1);
for (int i = 0; i < n; i++) {
lua_rawgeti(L, -1, i + 1);
drivers[driverCount++] = luaL_checkoption(L, -1, NULL, HeadsetDrivers);
drivers[driverCount++] = luax_checkenum(L, -1, HeadsetDrivers, NULL, "HeadsetDriver");
lovrAssert(driverCount < sizeof(drivers) / sizeof(drivers[0]), "Too many headset drivers specified in conf.lua");
lua_pop(L, 1);
}

24
src/api/l_physics.c
View File

@ -2,20 +2,20 @@
#include "physics/physics.h"
#include "core/ref.h"
const char* ShapeTypes[] = {
[SHAPE_SPHERE] = "sphere",
[SHAPE_BOX] = "box",
[SHAPE_CAPSULE] = "capsule",
[SHAPE_CYLINDER] = "cylinder",
NULL
StringEntry ShapeTypes[] = {
[SHAPE_SPHERE] = ENTRY("sphere"),
[SHAPE_BOX] = ENTRY("box"),
[SHAPE_CAPSULE] = ENTRY("capsule"),
[SHAPE_CYLINDER] = ENTRY("cylinder"),
{ 0 }
};
const char* JointTypes[] = {
[JOINT_BALL] = "ball",
[JOINT_DISTANCE] = "distance",
[JOINT_HINGE] = "hinge",
[JOINT_SLIDER] = "slider",
NULL
StringEntry JointTypes[] = {
[JOINT_BALL] = ENTRY("ball"),
[JOINT_DISTANCE] = ENTRY("distance"),
[JOINT_HINGE] = ENTRY("hinge"),
[JOINT_SLIDER] = ENTRY("slider"),
{ 0 }
};
static int l_lovrPhysicsNewWorld(lua_State* L) {

2
src/api/l_physics_joints.c
View File

@ -41,7 +41,7 @@ static int l_lovrJointDestroy(lua_State* L) {
static int l_lovrJointGetType(lua_State* L) {
Joint* joint = luax_checkjoint(L, 1);
lua_pushstring(L, JointTypes[lovrJointGetType(joint)]);
luax_pushenum(L, JointTypes, lovrJointGetType(joint));
return 1;
}

2
src/api/l_physics_shapes.c
View File

@ -41,7 +41,7 @@ static int l_lovrShapeDestroy(lua_State* L) {
static int l_lovrShapeGetType(lua_State* L) {
Shape* shape = luax_checkshape(L, 1);
lua_pushstring(L, ShapeTypes[lovrShapeGetType(shape)]);
luax_pushenum(L, ShapeTypes, lovrShapeGetType(shape));
return 1;
}