diff options
Diffstat (limited to 'src/lua_core.c')
| -rw-r--r-- | src/lua_core.c | 1033 |
1 files changed, 1033 insertions, 0 deletions
diff --git a/src/lua_core.c b/src/lua_core.c new file mode 100644 index 0000000..ab59c1d --- /dev/null +++ b/src/lua_core.c @@ -0,0 +1,1033 @@ +#include "main.h" +#include "state.h" +#include "lua_core.h" +#include "core.h" +#include "shapes.h" +#include "textures.h" +#include "models.h" +#include "text.h" +#include "audio.h" +#include "rmath.h" +#include "rgui.h" + +static void assignGlobalInt( int value, const char *name ) { + lua_State *L = state->luaState; + lua_pushinteger( L, value ); + lua_setglobal( L, name ); +} + +static void assignGlobalFloat( float value, const char *name ) { + lua_State *L = state->luaState; + lua_pushnumber( L, value ); + lua_setglobal( L, name ); +} + +static void assignGlobalColor( Color color, const char *name ) { + lua_State *L = state->luaState; + uluaPushColor( L, color ); + lua_setglobal( L, name ); +} + +void defineGlobals() { +/*DOC_START*/ + /* Keys */ + assignGlobalInt( KEY_ENTER, "KEY_ENTER" ); + assignGlobalInt( KEY_SPACE, "KEY_SPACE" ); + assignGlobalInt( KEY_ESCAPE, "KEY_ESCAPE" ); + assignGlobalInt( KEY_ENTER, "KEY_ENTER" ); + assignGlobalInt( KEY_TAB, "KEY_TAB" ); + assignGlobalInt( KEY_BACKSPACE, "KEY_BACKSPACE" ); + assignGlobalInt( KEY_INSERT, "KEY_INSERT" ); + assignGlobalInt( KEY_DELETE, "KEY_DELETE" ); + assignGlobalInt( KEY_RIGHT, "KEY_RIGHT" ); + assignGlobalInt( KEY_LEFT, "KEY_LEFT" ); + assignGlobalInt( KEY_DOWN, "KEY_DOWN" ); + assignGlobalInt( KEY_UP, "KEY_UP" ); + /* WindowFlags */ + assignGlobalInt( FLAG_VSYNC_HINT, "FLAG_VSYNC_HINT" ); + assignGlobalInt( FLAG_FULLSCREEN_MODE, "FLAG_FULLSCREEN_MODE" ); + assignGlobalInt( FLAG_WINDOW_RESIZABLE, "FLAG_WINDOW_RESIZABLE" ); + assignGlobalInt( FLAG_WINDOW_UNDECORATED, "FLAG_WINDOW_UNDECORATED" ); + assignGlobalInt( FLAG_WINDOW_HIDDEN, "FLAG_WINDOW_HIDDEN" ); + assignGlobalInt( FLAG_WINDOW_MINIMIZED, "FLAG_WINDOW_MINIMIZED" ); + assignGlobalInt( FLAG_WINDOW_MAXIMIZED, "FLAG_WINDOW_MAXIMIZED" ); + assignGlobalInt( FLAG_WINDOW_UNFOCUSED, "FLAG_WINDOW_UNFOCUSED" ); + assignGlobalInt( FLAG_WINDOW_TOPMOST, "FLAG_WINDOW_TOPMOST" ); + assignGlobalInt( FLAG_WINDOW_ALWAYS_RUN, "FLAG_WINDOW_ALWAYS_RUN" ); + assignGlobalInt( FLAG_WINDOW_TRANSPARENT, "FLAG_WINDOW_TRANSPARENT" ); + assignGlobalInt( FLAG_WINDOW_HIGHDPI, "FLAG_WINDOW_HIGHDPI" ); + assignGlobalInt( FLAG_MSAA_4X_HINT, "FLAG_MSAA_4X_HINT" ); + assignGlobalInt( FLAG_INTERLACED_HINT, "FLAG_INTERLACED_HINT" ); + /* BlendModes */ + assignGlobalInt( BLEND_ALPHA, "BLEND_ALPHA" ); + assignGlobalInt( BLEND_ADDITIVE, "BLEND_ADDITIVE" ); + assignGlobalInt( BLEND_MULTIPLIED, "BLEND_MULTIPLIED" ); + assignGlobalInt( BLEND_ADD_COLORS, "BLEND_ADD_COLORS" ); + assignGlobalInt( BLEND_SUBTRACT_COLORS, "BLEND_SUBTRACT_COLORS" ); + assignGlobalInt( BLEND_CUSTOM, "BLEND_CUSTOM" ); + /* TextureModes */ + assignGlobalInt( TEXTURE_SOURCE_TEXTURE, "TEXTURE_SOURCE_TEXTURE" ); + assignGlobalInt( TEXTURE_SOURCE_RENDER_TEXTURE, "TEXTURE_SOURCE_RENDER_TEXTURE" ); + /* CameraProjections */ + assignGlobalInt( CAMERA_PERSPECTIVE, "CAMERA_PERSPECTIVE" ); + assignGlobalInt( CAMERA_ORTHOGRAPHIC, "CAMERA_ORTHOGRAPHIC" ); + /* CameraMode */ + assignGlobalInt( CAMERA_CUSTOM, "CAMERA_CUSTOM" ); + assignGlobalInt( CAMERA_FREE, "CAMERA_FREE" ); + assignGlobalInt( CAMERA_ORBITAL, "CAMERA_ORBITAL" ); + assignGlobalInt( CAMERA_FIRST_PERSON, "CAMERA_FIRST_PERSON" ); + assignGlobalInt( CAMERA_THIRD_PERSON, "CAMERA_THIRD_PERSON" ); + /* MapTypes */ + assignGlobalInt( MATERIAL_MAP_ALBEDO, "MATERIAL_MAP_ALBEDO" ); + assignGlobalInt( MATERIAL_MAP_METALNESS, "MATERIAL_MAP_METALNESS" ); + assignGlobalInt( MATERIAL_MAP_NORMAL, "MATERIAL_MAP_NORMAL" ); + assignGlobalInt( MATERIAL_MAP_ROUGHNESS, "MATERIAL_MAP_ROUGHNESS" ); + assignGlobalInt( MATERIAL_MAP_OCCLUSION, "MATERIAL_MAP_OCCLUSION" ); + assignGlobalInt( MATERIAL_MAP_EMISSION, "MATERIAL_MAP_EMISSION" ); + assignGlobalInt( MATERIAL_MAP_HEIGHT, "MATERIAL_MAP_HEIGHT" ); + assignGlobalInt( MATERIAL_MAP_CUBEMAP, "MATERIAL_MAP_CUBEMAP" ); + assignGlobalInt( MATERIAL_MAP_IRRADIANCE, "MATERIAL_MAP_IRRADIANCE" ); + assignGlobalInt( MATERIAL_MAP_PREFILTER, "MATERIAL_MAP_PREFILTER" ); + assignGlobalInt( MATERIAL_MAP_BRDF, "MATERIAL_MAP_BRDF" ); + /* TextureFilters */ + assignGlobalInt( TEXTURE_FILTER_POINT, "TEXTURE_FILTER_POINT" ); + assignGlobalInt( TEXTURE_FILTER_BILINEAR, "TEXTURE_FILTER_BILINEAR" ); + assignGlobalInt( TEXTURE_FILTER_TRILINEAR, "TEXTURE_FILTER_TRILINEAR" ); + assignGlobalInt( TEXTURE_FILTER_ANISOTROPIC_4X, "TEXTURE_FILTER_ANISOTROPIC_4X" ); + assignGlobalInt( TEXTURE_FILTER_ANISOTROPIC_8X, "TEXTURE_FILTER_ANISOTROPIC_8X" ); + assignGlobalInt( TEXTURE_FILTER_ANISOTROPIC_16X, "TEXTURE_FILTER_ANISOTROPIC_16X" ); + /* TextureWrapModes */ + assignGlobalInt( TEXTURE_WRAP_REPEAT, "TEXTURE_WRAP_REPEAT" ); + assignGlobalInt( TEXTURE_WRAP_CLAMP, "TEXTURE_WRAP_CLAMP" ); + assignGlobalInt( TEXTURE_WRAP_MIRROR_REPEAT, "TEXTURE_WRAP_MIRROR_REPEAT" ); + assignGlobalInt( TEXTURE_WRAP_MIRROR_CLAMP, "TEXTURE_WRAP_MIRROR_CLAMP" ); + /* TraceLogLevel */ + assignGlobalInt( LOG_ALL, "LOG_ALL" ); + assignGlobalInt( LOG_TRACE, "LOG_TRACE" ); + assignGlobalInt( LOG_DEBUG, "LOG_DEBUG" ); + assignGlobalInt( LOG_INFO, "LOG_INFO" ); + assignGlobalInt( LOG_WARNING, "LOG_WARNING" ); + assignGlobalInt( LOG_ERROR, "LOG_ERROR" ); + assignGlobalInt( LOG_FATAL, "LOG_FATAL" ); + assignGlobalInt( LOG_NONE, "LOG_NONE" ); + /* N-patchLayout */ + assignGlobalInt( NPATCH_NINE_PATCH, "NPATCH_NINE_PATCH" ); + assignGlobalInt( NPATCH_THREE_PATCH_VERTICAL, "NPATCH_THREE_PATCH_VERTICAL" ); + assignGlobalInt( NPATCH_THREE_PATCH_HORIZONTAL, "NPATCH_THREE_PATCH_HORIZONTAL" ); + /* Shader location index */ + assignGlobalInt( SHADER_LOC_VERTEX_POSITION, "SHADER_LOC_VERTEX_POSITION" ); + assignGlobalInt( SHADER_LOC_VERTEX_TEXCOORD01, "SHADER_LOC_VERTEX_TEXCOORD01" ); + assignGlobalInt( SHADER_LOC_VERTEX_TEXCOORD02, "SHADER_LOC_VERTEX_TEXCOORD02" ); + assignGlobalInt( SHADER_LOC_VERTEX_NORMAL, "SHADER_LOC_VERTEX_NORMAL" ); + assignGlobalInt( SHADER_LOC_VERTEX_TANGENT, "SHADER_LOC_VERTEX_TANGENT" ); + assignGlobalInt( SHADER_LOC_VERTEX_COLOR, "SHADER_LOC_VERTEX_COLOR" ); + assignGlobalInt( SHADER_LOC_MATRIX_MVP, "SHADER_LOC_MATRIX_MVP" ); + assignGlobalInt( SHADER_LOC_MATRIX_VIEW, "SHADER_LOC_MATRIX_VIEW" ); + assignGlobalInt( SHADER_LOC_MATRIX_PROJECTION, "SHADER_LOC_MATRIX_PROJECTION" ); + assignGlobalInt( SHADER_LOC_MATRIX_MODEL, "SHADER_LOC_MATRIX_MODEL" ); + assignGlobalInt( SHADER_LOC_MATRIX_NORMAL, "SHADER_LOC_MATRIX_NORMAL" ); + assignGlobalInt( SHADER_LOC_VECTOR_VIEW, "SHADER_LOC_VECTOR_VIEW" ); + assignGlobalInt( SHADER_LOC_COLOR_DIFFUSE, "SHADER_LOC_COLOR_DIFFUSE" ); + assignGlobalInt( SHADER_LOC_COLOR_SPECULAR, "SHADER_LOC_COLOR_SPECULAR" ); + assignGlobalInt( SHADER_LOC_COLOR_AMBIENT, "SHADER_LOC_COLOR_AMBIENT" ); + assignGlobalInt( SHADER_LOC_MAP_ALBEDO, "SHADER_LOC_MAP_ALBEDO" ); + assignGlobalInt( SHADER_LOC_MAP_METALNESS, "SHADER_LOC_MAP_METALNESS" ); + assignGlobalInt( SHADER_LOC_MAP_NORMAL, "SHADER_LOC_MAP_NORMAL" ); + assignGlobalInt( SHADER_LOC_MAP_ROUGHNESS, "SHADER_LOC_MAP_ROUGHNESS" ); + assignGlobalInt( SHADER_LOC_MAP_OCCLUSION, "SHADER_LOC_MAP_OCCLUSION" ); + assignGlobalInt( SHADER_LOC_MAP_EMISSION, "SHADER_LOC_MAP_EMISSION" ); + assignGlobalInt( SHADER_LOC_MAP_HEIGHT, "SHADER_LOC_MAP_HEIGHT" ); + assignGlobalInt( SHADER_LOC_MAP_CUBEMAP, "SHADER_LOC_MAP_CUBEMAP" ); + assignGlobalInt( SHADER_LOC_MAP_IRRADIANCE, "SHADER_LOC_MAP_IRRADIANCE" ); + assignGlobalInt( SHADER_LOC_MAP_PREFILTER, "SHADER_LOC_MAP_PREFILTER" ); + assignGlobalInt( SHADER_LOC_MAP_BRDF, "SHADER_LOC_MAP_BRDF" ); + /* Shader uniform data type */ + assignGlobalInt( SHADER_UNIFORM_FLOAT, "SHADER_UNIFORM_FLOAT" ); + assignGlobalInt( SHADER_UNIFORM_VEC2, "SHADER_UNIFORM_VEC2" ); + assignGlobalInt( SHADER_UNIFORM_VEC3, "SHADER_UNIFORM_VEC3" ); + assignGlobalInt( SHADER_UNIFORM_VEC4, "SHADER_UNIFORM_VEC4" ); + assignGlobalInt( SHADER_UNIFORM_INT, "SHADER_UNIFORM_INT" ); + assignGlobalInt( SHADER_UNIFORM_IVEC2, "SHADER_UNIFORM_IVEC2" ); + assignGlobalInt( SHADER_UNIFORM_IVEC3, "SHADER_UNIFORM_IVEC3" ); + assignGlobalInt( SHADER_UNIFORM_IVEC4, "SHADER_UNIFORM_IVEC4" ); + assignGlobalInt( SHADER_UNIFORM_SAMPLER2D, "SHADER_UNIFORM_SAMPLER2D" ); + /* Shader attribute data types */ + assignGlobalInt( SHADER_ATTRIB_FLOAT, "SHADER_ATTRIB_FLOAT" ); + assignGlobalInt( SHADER_ATTRIB_VEC2, "SHADER_ATTRIB_VEC2" ); + assignGlobalInt( SHADER_ATTRIB_VEC3, "SHADER_ATTRIB_VEC3" ); + assignGlobalInt( SHADER_ATTRIB_VEC4, "SHADER_ATTRIB_VEC4" ); + /* Colors */ + assignGlobalColor( WHITE, "WHITE" ); + assignGlobalColor( BLACK, "BLACK" ); + assignGlobalColor( BLANK, "BLANK" ); + assignGlobalColor( MAGENTA, "MAGENTA" ); + assignGlobalColor( RAYWHITE, "RAYWHITE" ); + assignGlobalColor( RED, "RED" ); + assignGlobalColor( GREEN, "GREEN" ); + assignGlobalColor( BLUE, "BLUE" ); + /* Math */ + assignGlobalFloat( PI, "PI" ); +/*DOC_END*/ +} + +bool luaInit() { + state->luaState = luaL_newstate(); + + luaL_openlibs( state->luaState ); + + if ( state->luaState == NULL ) { + TraceLog( LOG_WARNING, "%s", "Failed to init Lua" ); + + return false; + } + luaRegister(); + defineGlobals(); + + return luaCallMain(); +} + +int luaTraceback( lua_State *L ) { + lua_getglobal( L, "debug" ); + + if ( !lua_istable( L, -1 ) ) { + lua_pop( L, 1 ); + return 1; + } + + lua_getfield( L, -1, "traceback" ); + + if ( !lua_isfunction( L, -1 ) ) { + lua_pop(L, 2); + return 1; + } + + lua_pushvalue( L, 1 ); // pass error message + lua_pushinteger( L, 2 ); // skip this function and traceback + lua_call( L, 2, 1 ); // call debug.traceback + + return 1; +} + +bool luaCallMain() { + lua_State *L = state->luaState; + + char path[ STRING_LEN ] = { '\0' }; + + sprintf( path, "%smain.lua", state->exePath ); + + luaL_dofile( L, path ); + + /* Check errors in main.lua */ + if ( lua_tostring( state->luaState, -1 ) ) { + TraceLog( LOG_WARNING, "Lua error: %s\n", lua_tostring( state->luaState, -1 ) ); + } + + lua_pushcfunction( L, luaTraceback ); + int tracebackidx = lua_gettop( L ); + + lua_getglobal( L, "init" ); + + if ( lua_isfunction( L, -1 ) ) { + if ( lua_pcall( L, 0, 0, tracebackidx ) != 0 ) { + TraceLog( LOG_WARNING, "Lua error: %s", lua_tostring( L, -1 ) ); + return false; + } + } + else { + TraceLog( LOG_WARNING, "%s", "No Lua main found!" ); + return false; + } + + return true; +} + +void luaCallProcess() { + lua_State *L = state->luaState; + + lua_pushcfunction( L, luaTraceback ); + int tracebackidx = lua_gettop(L); + + lua_getglobal( L, "process" ); + + if ( lua_isfunction( L, -1 ) ) { + lua_pushnumber( L, GetFrameTime() ); + + if ( lua_pcall( L, 1, 0, tracebackidx ) != 0 ) { + TraceLog( LOG_WARNING, "Lua error: %s", lua_tostring( L, -1 ) ); + state->run = false; + return; + } + } + // else { + // TraceLog( LOG_WARNING, "%s", "No Lua process found!" ); + // state->run = false; + // return; + // } + lua_pop( L, -1 ); +} + +void luaCallDraw() { + lua_State *L = state->luaState; + lua_pushcfunction( L, luaTraceback ); + int tracebackidx = lua_gettop(L); + + lua_getglobal( L, "draw" ); + + if ( lua_isfunction( L, -1 ) ) { + BeginDrawing(); + + if ( lua_pcall( L, 0, 0, tracebackidx ) != 0 ) { + TraceLog( LOG_WARNING, "Lua error: %s", lua_tostring( L, -1 ) ); + // state->run = false; + return; + } + + EndDrawing(); + } + // else { + // TraceLog( LOG_WARNING, "%s", "No Lua render found!" ); + // state->run = false; + // return; + // } + lua_pop( L, -1 ); +} + +void luaRegister() { + lua_State *L = state->luaState; + + /* Core. */ + /* Window. */ + lua_register( L, "RL_SetWindowMonitor", lcoreSetWindowMonitor ); + lua_register( L, "RL_SetWindowPosition", lcoreSetWindowPosition ); + lua_register( L, "RL_SetWindowSize", lcoreSetWindowSize ); + lua_register( L, "RL_GetMonitorPosition", lcoreGetMonitorPosition ); + lua_register( L, "RL_GetMonitorSize", lcoreGetMonitorSize ); + lua_register( L, "RL_GetWindowPosition", lcoreGetWindowPosition ); + lua_register( L, "RL_GetWindowSize", lcoreGetWindowSize ); + lua_register( L, "RL_SetWindowState", lcoreSetWindowState ); + lua_register( L, "RL_IsWindowState", lcoreIsWindowState ); + lua_register( L, "RL_ClearWindowState", lcoreClearWindowState ); + lua_register( L, "RL_IsWindowResized", lcoreIsWindowResized ); + lua_register( L, "RL_SetWindowIcon", lcoreSetWindowIcon ); + lua_register( L, "RL_SetWindowTitle", lcoreSetWindowTitle ); + /* Timing. */ + lua_register( L, "RL_SetTargetFPS", lcoreSetTargetFPS ); + lua_register( L, "RL_GetFrameTime", lcoreGetFrameTime ); + lua_register( L, "RL_GetTime", lcoreGetTime ); + /* Misc. */ + lua_register( L, "RL_TraceLog", lcoreTraceLog ); + lua_register( L, "RL_OpenURL", lcoreOpenURL ); + /* Cursor. */ + lua_register( L, "RL_ShowCursor", lcoreShowCursor ); + lua_register( L, "RL_HideCursor", lcoreHideCursor ); + lua_register( L, "RL_IsCursorHidden", lcoreIsCursorHidden ); + lua_register( L, "RL_EnableCursor", lcoreEnableCursor ); + lua_register( L, "RL_DisableCursor", lcoreDisableCursor ); + lua_register( L, "RL_IsCursorOnScreen", lcoreIsCursorOnScreen ); + /* Drawing. */ + lua_register( L, "RL_ClearBackground", lcoreClearBackground ); + lua_register( L, "RL_BeginBlendMode", lcoreBeginBlendMode ); + lua_register( L, "RL_EndBlendMode", lcoreEndBlendMode ); + lua_register( L, "RL_BeginScissorMode", lcoreBeginScissorMode ); + lua_register( L, "RL_EndScissorMode", lcoreEndScissorMode ); + /* Shader. */ + lua_register( L, "RL_LoadShader", lcoreLoadShader ); + lua_register( L, "RL_LoadShaderFromMemory", lcoreLoadShaderFromMemory ); + lua_register( L, "RL_BeginShaderMode", lcoreBeginShaderMode ); + lua_register( L, "RL_EndShaderMode", lcoreEndShaderMode ); + lua_register( L, "RL_GetShaderLocation", lcoreGetShaderLocation ); + lua_register( L, "RL_GetShaderLocationAttrib", lcoreGetShaderLocationAttrib ); + lua_register( L, "RL_SetShaderValueMatrix", lcoreSetShaderValueMatrix ); + lua_register( L, "RL_SetShaderValueTexture", lcoreSetShaderValueTexture ); + lua_register( L, "RL_SetShaderValue", lcoreSetShaderValue ); + lua_register( L, "RL_SetShaderValueV", lcoreSetShaderValueV ); + lua_register( L, "RL_UnloadShader", lcoreUnloadShader ); + /* File. */ + lua_register( L, "RL_GetBasePath", lcoreGetBasePath ); + lua_register( L, "RL_FileExists", lcoreFileExists ); + lua_register( L, "RL_DirectoryExists", lcoreDirectoryExists ); + lua_register( L, "RL_IsFileExtension", lcoreIsFileExtension ); + lua_register( L, "RL_GetFileExtension", lcoreGetFileExtension ); + lua_register( L, "RL_GetFileName", lcoreGetFileName ); + lua_register( L, "RL_GetFileNameWithoutExt", lcoreGetFileNameWithoutExt ); + lua_register( L, "RL_GetDirectoryPath", lcoreGetDirectoryPath ); + lua_register( L, "RL_GetPrevDirectoryPath", lcoreGetPrevDirectoryPath ); + lua_register( L, "RL_GetWorkingDirectory", lcoreGetWorkingDirectory ); + lua_register( L, "RL_GetDirectoryFiles", lcoreGetDirectoryFiles ); + lua_register( L, "RL_GetFileModTime", lcoreGetFileModTime ); + /* Camera. */ + lua_register( L, "RL_CreateCamera3D", lcoreCreateCamera3D ); + lua_register( L, "RL_UnloadCamera3D", lcoreUnloadCamera3D ); + lua_register( L, "RL_BeginMode3D", lcoreBeginMode3D ); + lua_register( L, "RL_EndMode3D", lcoreEndMode3D ); + lua_register( L, "RL_SetCamera3DPosition", lcoreSetCamera3DPosition ); + lua_register( L, "RL_SetCamera3DTarget", lcoreSetCamera3DTarget ); + lua_register( L, "RL_SetCamera3DUp", lcoreSetCamera3DUp ); + lua_register( L, "RL_SetCamera3DFovy", lcoreSetCamera3DFovy ); + lua_register( L, "RL_SetCamera3DProjection", lcoreSetCamera3DProjection ); + lua_register( L, "RL_GetCamera3DPosition", lcoreGetCamera3DPosition ); + lua_register( L, "RL_GetCamera3DTarget", lcoreGetCamera3DTarget ); + lua_register( L, "RL_GetCamera3DUp", lcoreGetCamera3DUp ); + lua_register( L, "RL_GetCamera3DFovy", lcoreGetCamera3DFovy ); + lua_register( L, "RL_GetCamera3DProjection", lcoreGetCamera3DProjection ); + lua_register( L, "RL_UpdateCamera3D", lcoreUpdateCamera3D ); + lua_register( L, "RL_SetCamera3DMode", lcoreSetCamera3DMode ); + /* Input. */ + lua_register( L, "RL_IsKeyPressed", lcoreIsKeyPressed ); + lua_register( L, "RL_IsKeyDown", lcoreIsKeyDown ); + lua_register( L, "RL_IsKeyReleased", lcoreIsKeyReleased ); + lua_register( L, "RL_GetKeyPressed", lcoreGetKeyPressed ); + lua_register( L, "RL_GetCharPressed", lcoreGetCharPressed ); + lua_register( L, "RL_SetExitKey", lcoreSetExitKey ); + lua_register( L, "RL_IsGamepadAvailable", lcoreIsGamepadAvailable ); + lua_register( L, "RL_IsGamepadButtonPressed", lcoreIsGamepadButtonPressed ); + lua_register( L, "RL_IsGamepadButtonDown", lcoreIsGamepadButtonDown ); + lua_register( L, "RL_IsGamepadButtonReleased", lcoreIsGamepadButtonReleased ); + lua_register( L, "RL_GetGamepadAxisCount", lcoreGetGamepadAxisCount ); + lua_register( L, "RL_GetGamepadAxisMovement", lcoreGetGamepadAxisMovement ); + lua_register( L, "RL_GetGamepadName", lcoreGetGamepadName ); + lua_register( L, "RL_IsMouseButtonPressed", lcoreIsMouseButtonPressed ); + lua_register( L, "RL_IsMouseButtonDown", lcoreIsMouseButtonDown ); + lua_register( L, "RL_IsMouseButtonReleased", lcoreIsMouseButtonReleased ); + lua_register( L, "RL_GetMousePosition", lcoreGetMousePosition ); + lua_register( L, "RL_GetMouseDelta", lcoreGetMouseDelta ); + lua_register( L, "RL_GetMouseWheelMove", lcoreGetMouseWheelMove ); + lua_register( L, "RL_SetMousePosition", lcoreSetMousePosition ); + + /* Shapes. */ + /* Drawing. */ + lua_register( L, "RL_DrawPixel", lshapesDrawPixel ); + lua_register( L, "RL_DrawLine", lshapesDrawLine ); + lua_register( L, "RL_DrawCircle", lshapesDrawCircle ); + lua_register( L, "RL_DrawCircleLines", lshapesDrawCircleLines ); + lua_register( L, "RL_DrawRectangle", lshapesDrawRectangle ); + lua_register( L, "RL_DrawRectanglePro", lshapesDrawRectanglePro ); + lua_register( L, "RL_DrawTriangle", lshapesDrawTriangle ); + lua_register( L, "RL_DrawTriangleLines", lshapesDrawTriangleLines ); + /* Collision. */ + lua_register( L, "RL_CheckCollisionRecs", lshapesCheckCollisionRecs ); + lua_register( L, "RL_CheckCollisionCircles", lshapesCheckCollisionCircles ); + lua_register( L, "RL_CheckCollisionCircleRec", lshapesCheckCollisionCircleRec ); + lua_register( L, "RL_CheckCollisionPointRec", lshapesCheckCollisionPointRec ); + lua_register( L, "RL_CheckCollisionPointCircle", lshapesCheckCollisionPointCircle ); + lua_register( L, "RL_CheckCollisionPointTriangle", lshapesCheckCollisionPointTriangle ); + lua_register( L, "RL_CheckCollisionLines", lshapesCheckCollisionLines ); + lua_register( L, "RL_CheckCollisionPointLine", lshapesCheckCollisionPointLine ); + lua_register( L, "RL_GetCollisionRec", lshapesGetCollisionRec ); + + /* Textures. */ + /* File. */ + lua_register( L, "RL_LoadImage", ltexturesLoadImage ); + lua_register( L, "RL_GenImageColor", ltexturesGenImageColor ); + lua_register( L, "RL_UnloadImage", ltexturesUnloadImage ); + lua_register( L, "RL_LoadTexture", ltexturesLoadTexture ); + lua_register( L, "RL_LoadTextureFromImage", ltexturesLoadTextureFromImage ); + lua_register( L, "RL_UnloadTexture", ltexturesUnloadTexture ); + lua_register( L, "RL_LoadRenderTexture", ltexturesLoadRenderTexture ); + lua_register( L, "RL_UnloadRenderTexture", ltexturesUnloadRenderTexture ); + /* Image Drawing. */ + lua_register( L, "RL_ImageClearBackground", ltexturesImageClearBackground ); + lua_register( L, "RL_ImageDrawPixel", ltexturesImageDrawPixel ); + lua_register( L, "RL_ImageDrawLine", ltexturesImageDrawLine ); + lua_register( L, "RL_ImageDrawCircle", ltexturesImageDrawCircle ); + lua_register( L, "RL_ImageDrawRectangle", ltexturesImageDrawRectangle ); + lua_register( L, "RL_ImageDrawRectangleLines", ltexturesImageDrawRectangleLines ); + lua_register( L, "RL_ImageDraw", ltexturesImageDraw ); + lua_register( L, "RL_ImageDrawTextEx", ltexturesImageDrawTextEx ); + /* Texture Drawing. */ + lua_register( L, "RL_DrawTexture", ltexturesDrawTexture ); + lua_register( L, "RL_DrawTextureRec", ltexturesDrawTextureRec ); + lua_register( L, "RL_DrawTextureTiled", ltexturesDrawTextureTiled ); + lua_register( L, "RL_DrawTexturePro", ltexturesDrawTexturePro ); + lua_register( L, "RL_DrawTextureNPatch", ltexturesDrawTextureNPatch ); + lua_register( L, "RL_DrawTexturePoly", ltexturesDrawTexturePoly ); + lua_register( L, "RL_BeginTextureMode", ltexturesBeginTextureMode ); + lua_register( L, "RL_EndTextureMode", ltexturesEndTextureMode ); + lua_register( L, "RL_SetTextureSource", ltexturesSetTextureSource ); + lua_register( L, "RL_GetTextureSource", ltexturesGetTextureSource ); + /* Conf. */ + lua_register( L, "RL_GenTextureMipmaps", ltexturesGenTextureMipmaps ); + lua_register( L, "RL_SetTextureFilter", ltexturesSetTextureFilter ); + lua_register( L, "RL_SetTextureWrap", ltexturesSetTextureWrap ); + lua_register( L, "RL_GetTextureSize", ltexturesGetTextureSize ); + + /* Models. */ + /* Basic. */ + lua_register( L, "RL_DrawLine3D", lmodelsDrawLine3D ); + lua_register( L, "RL_DrawPoint3D", lmodelsDrawPoint3D ); + lua_register( L, "RL_DrawCircle3D", lmodelsDrawCircle3D ); + lua_register( L, "RL_DrawTriangle3D", lmodelsDrawTriangle3D ); + lua_register( L, "RL_DrawCube", lmodelsDrawCube ); + lua_register( L, "RL_DrawCubeWires", lmodelsDrawCubeWires ); + lua_register( L, "RL_DrawCubeTexture", lmodelsDrawCubeTexture ); + lua_register( L, "RL_DrawSphere", lmodelsDrawSphere ); + lua_register( L, "RL_DrawSphereEx", lmodelsDrawSphereEx ); + lua_register( L, "RL_DrawSphereWires", lmodelsDrawSphereWires ); + lua_register( L, "RL_DrawCylinder", lmodelsDrawCylinder ); + lua_register( L, "RL_DrawCylinderEx", lmodelsDrawCylinderEx ); + lua_register( L, "RL_DrawCylinderWires", lmodelsDrawCylinderWires ); + lua_register( L, "RL_DrawCylinderWiresEx", lmodelsDrawCylinderWiresEx ); + lua_register( L, "RL_DrawPlane", lmodelsDrawPlane ); + lua_register( L, "RL_DrawQuad3DTexture", lmodelDrawQuad3DTexture ); + lua_register( L, "RL_DrawRay", lmodelsDrawRay ); + lua_register( L, "RL_DrawGrid", lmodelsDrawGrid ); + /* Mesh. */ + lua_register( L, "RL_GenMeshPoly", lmodelsGenMeshPoly ); + lua_register( L, "RL_GenMeshPlane", lmodelsGenMeshPlane ); + lua_register( L, "RL_GenMeshCube", lmodelsGenMeshCube ); + lua_register( L, "RL_GenMeshSphere", lmodelsGenMeshSphere ); + lua_register( L, "RL_GenMeshCylinder", lmodelsGenMeshCylinder ); + lua_register( L, "RL_GenMeshCone", lmodelsGenMeshCone ); + lua_register( L, "RL_GenMeshTorus", lmodelsGenMeshTorus ); + lua_register( L, "RL_GenMeshKnot", lmodelsGenMeshKnot ); + lua_register( L, "RL_GenMeshHeightmap", lmodelsGenMeshHeightmap ); + lua_register( L, "RL_GenMeshCustom", lmodelsGenMeshCustom ); + lua_register( L, "RL_UnloadMesh", lmodelsUnloadMesh ); + lua_register( L, "RL_DrawMesh", lmodelsDrawMesh ); + lua_register( L, "RL_DrawMeshInstanced", lmodelsDrawMeshInstanced ); + lua_register( L, "RL_SetMeshColor", lmodelsSetMeshColor ); + /* Material. */ + lua_register( L, "RL_LoadMaterialDefault", lmodelsLoadMaterialDefault ); + lua_register( L, "RL_CreateMaterial", lmodelsCreateMaterial ); + lua_register( L, "RL_UnloadMaterial", lmodelsUnloadMaterial ); + lua_register( L, "RL_SetMaterialTexture", lmodelsSetMaterialTexture ); + lua_register( L, "RL_SetMaterialColor", lmodelsSetMaterialColor ); + lua_register( L, "RL_SetMaterialValue", lmodelsSetMaterialValue ); + /* Model. */ + lua_register( L, "RL_LoadModel", lmodelsLoadModel ); + lua_register( L, "RL_LoadModelFromMesh", lmodelsLoadModelFromMesh ); + lua_register( L, "RL_UnloadModel", lmodelsUnloadModel ); + lua_register( L, "RL_DrawModel", lmodelsDrawModel ); + lua_register( L, "RL_DrawModelEx", lmodelsDrawModelEx ); + lua_register( L, "RL_SetModelMaterial", lmodelsSetModelMaterial ); + lua_register( L, "RL_SetModelMeshMaterial", lmodelsSetModelMeshMaterial ); + lua_register( L, "RL_DrawBillboard", lmodelsDrawBillboard ); + lua_register( L, "RL_DrawBillboardRec", lmodelsDrawBillboardRec ); + /* Animations. */ + lua_register( L, "RL_LoadModelAnimations", lmodelsLoadModelAnimations ); + lua_register( L, "RL_UpdateModelAnimation", lmodelsUpdateModelAnimation ); + lua_register( L, "RL_GetModelAnimationBoneCount", lmodelsGetModelAnimationBoneCount ); + lua_register( L, "RL_GetModelAnimationFrameCount", lmodelsGetModelAnimationFrameCount ); + /* Collision. */ + lua_register( L, "RL_CheckCollisionSpheres", lmodelsCheckCollisionSpheres ); + lua_register( L, "RL_CheckCollisionBoxes", lmodelsCheckCollisionBoxes ); + lua_register( L, "RL_CheckCollisionBoxSphere", lmodelsCheckCollisionBoxSphere ); + lua_register( L, "RL_GetRayCollisionSphere", lmodelsGetRayCollisionSphere ); + lua_register( L, "RL_GetRayCollisionBox", lmodelsGetRayCollisionBox ); + lua_register( L, "RL_GetRayCollisionModel", lmodelsGetRayCollisionModel ); + lua_register( L, "RL_GetRayCollisionMesh", lmodelsGetRayCollisionMesh ); + lua_register( L, "RL_GetRayCollisionTriangle", lmodelsGetRayCollisionTriangle ); + lua_register( L, "RL_GetRayCollisionQuad", lmodelsGetRayCollisionQuad ); + + /* Text. */ + /* Loading. */ + lua_register( L, "RL_LoadFont", lmodelsLoadFont ); + /* Drawing. */ + lua_register( L, "RL_DrawText", ltextDrawText ); + + /* Audio. */ + /* Sound. */ + lua_register( L, "RL_LoadSound", laudioLoadSound ); + lua_register( L, "RL_PlaySoundMulti", laudioPlaySoundMulti ); + lua_register( L, "RL_SetSoundVolume", laudioSetSoundVolume ); + lua_register( L, "RL_SetSoundPitch", laudioSetSoundPitch ); + lua_register( L, "RL_UnloadSound", laudioUnloadSound ); + /* Music. */ + lua_register( L, "RL_LoadMusicStream", laudioLoadMusicStream ); + lua_register( L, "RL_PlayMusicStream", laudioPlayMusicStream ); + lua_register( L, "RL_StopMusicStream", laudioStopMusicStream ); + lua_register( L, "RL_PauseMusicStream", laudioPauseMusicStream ); + lua_register( L, "RL_ResumeMusicStream", laudioResumeMusicStream ); + lua_register( L, "RL_IsMusicStreamPlaying", laudioIsMusicStreamPlaying ); + lua_register( L, "RL_SetMusicVolume", laudioSetMusicVolume ); + + /* Math. */ + /* Vector2. */ + lua_register( L, "RL_Vector2Add", lmathVector2Add ); + lua_register( L, "RL_Vector2Subtract", lmathVector2Subtract ); + lua_register( L, "RL_Vector2Multiply", lmathVector2Multiply ); + lua_register( L, "RL_Vector2Length", lmathVector2Length ); + lua_register( L, "RL_Vector2DotProduct", lmathVector2DotProduct ); + lua_register( L, "RL_Vector2Distance", lmathVector2Distance ); + lua_register( L, "RL_Vector2Angle", lmathVector2Angle ); + lua_register( L, "RL_Vector2Normalize", lmathVector2Normalize ); + lua_register( L, "RL_Vector2Lerp", lmathVector2Lerp ); + lua_register( L, "RL_Vector2Reflect", lmathVector2Reflect ); + lua_register( L, "RL_Vector2Rotate", lmathVector2Rotate ); + lua_register( L, "RL_Vector2MoveTowards", lmathVector2MoveTowards ); + /* Vector3. */ + lua_register( L, "RL_Vector3Add", lmathVector3Add ); + lua_register( L, "RL_Vector3Subtract", lmathVector3Subtract ); + lua_register( L, "RL_Vector3Multiply", lmathVector3Multiply ); + lua_register( L, "RL_Vector3CrossProduct", lmathVector3CrossProduct ); + lua_register( L, "RL_Vector3Perpendicular", lmathVector3Perpendicular ); + lua_register( L, "RL_Vector3Length", lmathVector3Length ); + lua_register( L, "RL_Vector3LengthSqr", lmathVector3LengthSqr ); + lua_register( L, "RL_Vector3DotProduct", lmathVector3DotProduct ); + lua_register( L, "RL_Vector3Distance", lmathVector3Distance ); + lua_register( L, "RL_Vector3Normalize", lmathVector3Normalize ); + lua_register( L, "RL_Vector3OrthoNormalize", lmathVector3OrthoNormalize ); + lua_register( L, "RL_Vector3Transform", lmathVector3Transform ); + lua_register( L, "RL_Vector3RotateByQuaternion", lmathVector3RotateByQuaternion ); + lua_register( L, "RL_Vector3Lerp", lmathVector3Lerp ); + lua_register( L, "RL_Vector3Reflect", lmathVector3Reflect ); + /* Matrix. */ + lua_register( L, "RL_MatrixDeterminant", lmathMatrixDeterminant ); + lua_register( L, "RL_MatrixTranspose", lmathMatrixTranspose ); + lua_register( L, "RL_MatrixInvert", lmathMatrixInvert ); + lua_register( L, "RL_MatrixNormalize", lmathMatrixNormalize ); + lua_register( L, "RL_MatrixIdentity", lmathMatrixIdentity ); + lua_register( L, "RL_MatrixAdd", lmathMatrixAdd ); + lua_register( L, "RL_MatrixSubtract", lmathMatrixSubtract ); + lua_register( L, "RL_MatrixMultiply", lmathMatrixMultiply ); + lua_register( L, "RL_MatrixTranslate", lmathMatrixTranslate ); + lua_register( L, "RL_MatrixRotate", lmathMatrixRotate ); + lua_register( L, "RL_MatrixScale", lmathMatrixScale ); + lua_register( L, "RL_MatrixFrustum", lmathMatrixFrustum ); + lua_register( L, "RL_MatrixPerspective", lmathMatrixPerspective ); + lua_register( L, "RL_MatrixOrtho", lmathMatrixOrtho ); + lua_register( L, "RL_MatrixLookAt", lmathMatrixLookAt ); + + /* Gui. */ + /* Global. */ + lua_register( L, "RL_GuiEnable", lguiGuiEnable ); + lua_register( L, "RL_GuiDisable", lguiGuiDisable ); + lua_register( L, "RL_GuiLock", lguiGuiLock ); + lua_register( L, "RL_GuiUnlock", lguiGuiUnlock ); + /* Font. */ + lua_register( L, "RL_GuiSetFont", lguiGuiSetFont ); + /* Container. */ + lua_register( L, "RL_GuiWindowBox", lguiGuiWindowBox ); + lua_register( L, "RL_GuiPanel", lguiGuiPanel ); + lua_register( L, "RL_GuiScrollPanel", lguiGuiScrollPanel ); + /* Basic. */ + lua_register( L, "RL_GuiLabel", lguiGuiLabel ); + lua_register( L, "RL_GuiButton", lguiGuiButton ); + lua_register( L, "RL_GuiToggle", lguiGuiToggle ); + lua_register( L, "RL_GuiCheckBox", lguiGuiCheckBox ); + lua_register( L, "RL_GuiTextBox", lguiGuiTextBox ); + lua_register( L, "RL_GuiTextBoxMulti", lguiGuiTextBoxMulti ); + lua_register( L, "RL_GuiSpinner", lguiGuiSpinner ); + lua_register( L, "RL_GuiValueBox", lguiGuiValueBox ); + lua_register( L, "RL_GuiSlider", lguiGuiSlider ); + lua_register( L, "RL_GuiSliderBar", lguiGuiSliderBar ); + lua_register( L, "RL_GuiProgressBar", lguiGuiProgressBar ); + lua_register( L, "RL_GuiScrollBar", lguiGuiScrollBar ); + lua_register( L, "RL_GuiDropdownBox", lguiGuiDropdownBox ); +} + +/* Lua util functions. */ + +Color uluaGetColor( lua_State *L ) { + Color color = { 0, 0, 0, 255 }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong color value. Returning { 0, 0, 0, 255 }" ); + return color; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + switch ( i ) { + case 0: + color.r = (uint8_t)lua_tointeger( L, -1 ); + break; + case 1: + color.g = (uint8_t)lua_tointeger( L, -1 ); + break; + case 2: + color.b = (uint8_t)lua_tointeger( L, -1 ); + break; + case 3: + color.a = (uint8_t)lua_tointeger( L, -1 ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + return color; +} + +Vector2 uluaGetVector2( lua_State *L ) { + Vector2 vector = { 0.0f, 0.0f }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong vector value. Returning { 0, 0 }" ); + return vector; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + switch ( i ) { + case 0: + vector.x = lua_tonumber( L, -1 ); + break; + case 1: + vector.y = lua_tonumber( L, -1 ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + return vector; +} + +Vector3 uluaGetVector3( lua_State *L ) { + Vector3 vector = { 0.0f, 0.0f, 0.0f }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong vector value. Returning { 0, 0, 0 }" ); + return vector; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + switch ( i ) { + case 0: + vector.x = lua_tonumber( L, -1 ); + break; + case 1: + vector.y = lua_tonumber( L, -1 ); + break; + case 2: + vector.z = lua_tonumber( L, -1 ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + return vector; +} + +Rectangle uluaGetRectangle( lua_State *L ) { + Rectangle rect = { 0.0f, 0.0f, 0.0f, 0.0f }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong rectangle value. Returning { 0, 0, 0, 0 }" ); + return rect; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + switch ( i ) { + case 0: + rect.x = lua_tonumber( L, -1 ); + break; + case 1: + rect.y = lua_tonumber( L, -1 ); + break; + case 2: + rect.width = lua_tonumber( L, -1 ); + break; + case 3: + rect.height = lua_tonumber( L, -1 ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + return rect; +} + +Quaternion uluaGetQuaternion( lua_State *L ) { + Quaternion quaternion = { 0.0f, 0.0f, 0.0f, 0.0f }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong quaternion value. Returning { 0, 0, 0, 0 }" ); + return quaternion; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + switch ( i ) { + case 0: + quaternion.x = lua_tonumber( L, -1 ); + break; + case 1: + quaternion.y = lua_tonumber( L, -1 ); + break; + case 2: + quaternion.z = lua_tonumber( L, -1 ); + break; + case 3: + quaternion.w = lua_tonumber( L, -1 ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + return quaternion; +} + +Matrix uluaGetMatrix( lua_State *L ) { + Matrix matrix = { 0.0f }; + float m[4][4]; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong matrix value. Returning MatrixIdentity." ); + return MatrixIdentity(); + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_istable( L, -1 ) ) { + int t2 = lua_gettop( L ), j = 0; + lua_pushnil( L ); + + while ( lua_next( L, t2 ) != 0 ) { + if ( lua_isnumber( L, -1 ) ) { + m[i][j] = lua_tonumber( L, -1 ); + } + j++; + lua_pop( L, 1 ); + } + } + i++; + lua_pop( L, 1 ); + } + matrix.m0 = m[0][0]; matrix.m1 = m[0][1]; matrix.m2 = m[0][2]; matrix.m3 = m[0][3]; + matrix.m4 = m[1][0]; matrix.m5 = m[1][1]; matrix.m6 = m[1][2]; matrix.m7 = m[1][3]; + matrix.m8 = m[2][0]; matrix.m9 = m[2][1]; matrix.m10 = m[2][2]; matrix.m11 = m[2][3]; + matrix.m12 = m[3][0]; matrix.m13 = m[3][1]; matrix.m14 = m[3][2]; matrix.m15 = m[3][3]; + + return matrix; +} + +BoundingBox uluaGetBoundingBox( lua_State *L ) { + BoundingBox box = { .min = { 0.0, 0.0, 0.0 }, .max = { 0.0, 0.0, 0.0 } }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong boundingbox value. Returning { min{ 0, 0, 0 }, max{ 0, 0, 0 } }." ); + return box; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_istable( L, -1 ) ) { + switch ( i ) { + case 0: + box.min = uluaGetVector3( L ); + break; + case 1: + box.max = uluaGetVector3( L ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + + return box; +} + +Ray uluaGetRay( lua_State *L ) { + Ray ray = { .position = { 0.0, 0.0, 0.0 }, .direction = { 0.0, 0.0, 0.0 } }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong ray value. Returning { position{ 0, 0, 0 }, direction{ 0, 0, 0 } }." ); + return ray; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + if ( lua_istable( L, -1 ) ) { + switch ( i ) { + case 0: + ray.position = uluaGetVector3( L ); + break; + case 1: + ray.direction = uluaGetVector3( L ); + break; + default: + break; + } + } + i++; + lua_pop( L, 1 ); + } + + return ray; +} + +NPatchInfo uluaGetNPatchInfo( lua_State *L ) { + NPatchInfo npatch = { .source = { 0.0, 0.0, 0.0, 0.0 }, .left = 0, .top = 0, .right = 0, .bottom = 0, .layout = NPATCH_NINE_PATCH }; + + if ( !lua_istable( L, -1 ) ) { + TraceLog( LOG_WARNING, "%s", "Error. Wrong ray value. Returning { source = { 0.0, 0.0, 0.0, 0.0 }, left = 0, top = 0, right = 0, bottom = 0, layout = NPATCH_NINE_PATCH }." ); + return npatch; + } + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + switch ( i ) { + case 0: + npatch.source = uluaGetRectangle( L ); + break; + case 1: + npatch.left = lua_tointeger( L, -1 ); + break; + case 2: + npatch.top = lua_tointeger( L, -1 ); + break; + case 3: + npatch.right = lua_tointeger( L, -1 ); + break; + case 4: + npatch.bottom = lua_tointeger( L, -1 ); + break; + case 5: + npatch.layout = lua_tointeger( L, -1 ); + break; + default: + break; + } + i++; + lua_pop( L, 1 ); + } + + return npatch; +} + +void uluaPushColor( lua_State *L, Color color ) { + lua_createtable( L, 3, 0 ); + lua_pushnumber( L, color.r ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, color.g ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, color.b ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, color.a ); + lua_rawseti( L, -2, 4 ); +} + +void uluaPushVector2( lua_State *L, Vector2 vector ) { + lua_createtable( L, 2, 0 ); + lua_pushnumber( L, vector.x ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, vector.y ); + lua_rawseti( L, -2, 2 ); +} + +void uluaPushVector3( lua_State *L, Vector3 vector ) { + lua_createtable( L, 3, 0 ); + lua_pushnumber( L, vector.x ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, vector.y ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, vector.z ); + lua_rawseti( L, -2, 3 ); +} + +void uluaPushRectangle( lua_State *L, Rectangle rect ) { + lua_createtable( L, 4, 0 ); + lua_pushnumber( L, rect.x ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, rect.y ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, rect.width ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, rect.height ); + lua_rawseti( L, -2, 4 ); +} + +void uluaPushMatrix( lua_State *L, Matrix matrix ) { + lua_createtable( L, 4, 0 ); + + lua_createtable( L, 4, 0 ); + lua_pushnumber( L, matrix.m0 ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, matrix.m1 ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, matrix.m2 ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, matrix.m3 ); + lua_rawseti( L, -2, 4 ); + lua_rawseti( L, -2, 1 ); + + lua_createtable( L, 4, 0 ); + lua_pushnumber( L, matrix.m4 ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, matrix.m5 ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, matrix.m6 ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, matrix.m7 ); + lua_rawseti( L, -2, 4 ); + lua_rawseti( L, -2, 2 ); + + lua_createtable( L, 4, 0 ); + lua_pushnumber( L, matrix.m8 ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, matrix.m9 ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, matrix.m10 ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, matrix.m11 ); + lua_rawseti( L, -2, 4 ); + lua_rawseti( L, -2, 3 ); + + lua_createtable( L, 4, 0 ); + lua_pushnumber( L, matrix.m12 ); + lua_rawseti( L, -2, 1 ); + lua_pushnumber( L, matrix.m13 ); + lua_rawseti( L, -2, 2 ); + lua_pushnumber( L, matrix.m14 ); + lua_rawseti( L, -2, 3 ); + lua_pushnumber( L, matrix.m15 ); + lua_rawseti( L, -2, 4 ); + lua_rawseti( L, -2, 4 ); +} + +void uluaPushRayCollision( lua_State *L, RayCollision rayCol ) { + lua_createtable( L, 4, 0 ); + lua_pushboolean( L, rayCol.hit ); + lua_setfield( L, -2, "hit" ); + lua_pushnumber( L, rayCol.distance ); + lua_setfield( L, -2, "distance" ); + uluaPushVector3( L, rayCol.point ); + lua_setfield( L, -2, "point" ); + uluaPushVector3( L, rayCol.normal ); + lua_setfield( L, -2, "normal" ); +} + +int uluaGetTableLen( lua_State *L ) { + int t = lua_gettop( L ), i = 0; + lua_pushnil( L ); + + while ( lua_next( L, t ) != 0 ) { + i++; + lua_pop( L, 1 ); + } + return i; +} |