├── .editorconfig ├── .gitignore ├── CMakeLists.txt ├── LICENSE ├── README.md ├── bin ├── CMakeLists.txt └── raylib-duktape.cpp ├── examples ├── CMakeLists.txt ├── core │ ├── core_basic_window.js │ └── core_input_mouse.js ├── shapes │ ├── logo.png │ └── shapes_logo_raylib.js └── textures │ ├── resources │ ├── raylib_logo.png │ └── wabbit_alpha.png │ ├── textures_bunnymark.js │ └── textures_image_loading.js ├── generator └── index.js ├── lib ├── CMakeLists.txt ├── raylib-duktape-gen.h ├── raylib-duktape.cpp └── raylib-duktape.h ├── package-lock.json ├── package.json └── tests ├── CMakeLists.txt ├── raylib-assert.h └── raylib-duktape-test.cpp /.editorconfig: -------------------------------------------------------------------------------- 1 | root = true 2 | 3 | [*] 4 | indent_style = tabs 5 | charset = utf-8 6 | end_of_line = lf 7 | indent_size = 4 8 | insert_final_newline = true 9 | trim_trailing_whitespace = true 10 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | build 2 | CMakeFiles 3 | Makefile 4 | config.h 5 | cmake_install.cmake 6 | *.a 7 | _deps 8 | CPack* 9 | CMakeCache.txt 10 | bin/raylib-duktape 11 | node_modules 12 | -------------------------------------------------------------------------------- /CMakeLists.txt: -------------------------------------------------------------------------------- 1 | cmake_minimum_required(VERSION 3.11) 2 | project(raylib-duktape 3 | DESCRIPTION "raylib-duktape: raylib for Duktape JavaScript" 4 | HOMEPAGE_URL "https://github.com/robloach/raylib-duktape" 5 | VERSION 0.0.1 6 | ) 7 | 8 | add_definitions( 9 | -Wfatal-errors 10 | ) 11 | 12 | # Options 13 | if ("${CMAKE_SOURCE_DIR}" STREQUAL "${CMAKE_CURRENT_SOURCE_DIR}") 14 | set(RAYLIB_DUKTAPE_IS_MAIN TRUE) 15 | else() 16 | set(RAYLIB_DUKTAPE_IS_MAIN FALSE) 17 | endif() 18 | option(RAYLIB_DUKTAPE_BUILD_EXAMPLES "Examples" ${RAYLIB_DUKTAPE_IS_MAIN}) 19 | option(RAYLIB_DUKTAPE_BUILD_BINARY "Binary" ${RAYLIB_DUKTAPE_IS_MAIN}) 20 | option(RAYLIB_DUKTAPE_BUILD_TESTS "Tests" ${RAYLIB_DUKTAPE_IS_MAIN}) 21 | 22 | add_subdirectory(lib) 23 | 24 | if (RAYLIB_DUKTAPE_BUILD_BINARY) 25 | add_subdirectory(bin) 26 | endif() 27 | if (RAYLIB_DUKTAPE_BUILD_EXAMPLES) 28 | add_subdirectory(examples) 29 | endif() 30 | 31 | if (RAYLIB_DUKTAPE_BUILD_TESTS) 32 | include(CTest) 33 | enable_testing() 34 | if (BUILD_TESTING) 35 | add_subdirectory(tests) 36 | endif() 37 | endif() 38 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Copyright (c) 2022 Rob Loach (@RobLoach) 2 | 3 | This software is provided "as-is", without any express or implied warranty. In no event 4 | will the authors be held liable for any damages arising from the use of this software. 5 | 6 | Permission is granted to anyone to use this software for any purpose, including commercial 7 | applications, and to alter it and redistribute it freely, subject to the following restrictions: 8 | 9 | 1. The origin of this software must not be misrepresented; you must not claim that you 10 | wrote the original software. If you use this software in a product, an acknowledgment 11 | in the product documentation would be appreciated but is not required. 12 | 13 | 2. Altered source versions must be plainly marked as such, and must not be misrepresented 14 | as being the original software. 15 | 16 | 3. This notice may not be removed or altered from any source distribution. 17 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ![logo.png](examples/shapes/logo.png) 2 | 3 | # raylib-duktape 4 | 5 | Embedded JavaScript bindings for [raylib](https://www.raylib.com/), a simple and easy-to-use library to learn videogames programming. 6 | 7 | `raylib-duktape` uses [Duktape](https://duktape.org/) and [Dukglue](https://github.com/Aloshi/dukglue). 8 | 9 | ## Example 10 | 11 | ``` js 12 | const screenWidth = 800 13 | const screenHeight = 450 14 | 15 | InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window") 16 | SetTargetFPS(60) 17 | 18 | while (!WindowShouldClose()) { 19 | BeginDrawing() 20 | ClearBackground(RAYWHITE) 21 | DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY) 22 | EndDrawing() 23 | } 24 | 25 | CloseWindow() 26 | ``` 27 | 28 | ## CLI 29 | 30 | A [raylib-duktape](bin/raylib-duktape.cpp) CLI launcher is provided to allow running raylib JavaScript files. 31 | 32 | ``` bash 33 | raylib-duktape core_basic_window.js 34 | ``` 35 | 36 | ## API 37 | 38 | Initialize raylib-duktape through your Duktape context. 39 | 40 | ``` c 41 | #include "raylib-duktape.h" 42 | 43 | // After initializing the Duktape heap... 44 | duk_raylib_init(ctx, 0); 45 | ``` 46 | 47 | ## Build 48 | 49 | ``` bash 50 | git clone https://github.com/RobLoach/raylib-duktape.git 51 | cd raylib-duktape 52 | mkdir build 53 | cd build 54 | cmake .. 55 | make 56 | make test 57 | ``` 58 | 59 | ## License 60 | 61 | [zlib](LICENSE) 62 | -------------------------------------------------------------------------------- /bin/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(raylib-duktape-bin 2 | raylib-duktape.cpp 3 | #${duktape_SOURCE_DIR}/extras/console/duk_console.c 4 | ) 5 | set_target_properties(raylib-duktape-bin PROPERTIES OUTPUT_NAME "raylib-duktape") 6 | target_link_libraries(raylib-duktape-bin raylib-duktape) 7 | -------------------------------------------------------------------------------- /bin/raylib-duktape.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | 4 | #include "raylib.h" 5 | #include 6 | //#include 7 | #include "../lib/raylib-duktape.h" 8 | #include 9 | 10 | int main(int argc, char *argv[]) { 11 | std::string executableName; 12 | std::string fileToLoad; 13 | 14 | SetTraceLogLevel(LOG_FATAL); 15 | 16 | switch (argc) { 17 | case 0: 18 | executableName = "raylib-duktape"; 19 | fileToLoad = "main.js"; 20 | break; 21 | case 1: 22 | executableName = argv[0]; 23 | fileToLoad = "main.js"; 24 | break; 25 | default: 26 | executableName = argv[0]; 27 | fileToLoad = argv[1]; 28 | break; 29 | } 30 | 31 | if (!FileExists(fileToLoad.c_str())) { 32 | std::cout << "Usage:" << std::endl << " " << GetFileName(executableName.c_str()) << " myfile.js" << std::endl << std::endl; 33 | std::cout << "Attempted file " << fileToLoad << " was not found." << std::endl; 34 | return 1; 35 | } 36 | 37 | if (!IsFileExtension(fileToLoad.c_str(), ".js")) { 38 | std::cout << "Expected file to be a .js file." << std::endl; 39 | return 1; 40 | } 41 | 42 | char* fileText = LoadFileText(fileToLoad.c_str()); 43 | std::string contents(fileText); 44 | UnloadFileText(fileText); 45 | if (contents.empty()) { 46 | std::cout << "File was empty." << std::endl; 47 | return 1; 48 | } 49 | 50 | // Make sure it runs in the correct folder. 51 | if (!ChangeDirectory(GetDirectoryPath(fileToLoad.c_str()))) { 52 | TraceLog(LOG_WARNING, "Failed to change directory"); 53 | } 54 | 55 | // Construct the Duktape environment. 56 | duk_context* ctx = duk_create_heap_default(); 57 | 58 | // Initialize the console module. 59 | //duk_console_init(ctx, 0); 60 | 61 | // Initialize the raylib module. 62 | duk_raylib_init(ctx, 0); 63 | 64 | // Eval the loaded code. 65 | dukglue_peval(ctx, contents.c_str()); 66 | 67 | // Destroy the environment. 68 | duk_destroy_heap(ctx); 69 | 70 | return 0; 71 | } 72 | -------------------------------------------------------------------------------- /examples/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | # Get the sources together 2 | set(example_dirs audio core text textures shapes) 3 | set(example_sources) 4 | set(example_resources) 5 | 6 | # Examples directories 7 | foreach(example_dir ${example_dirs}) 8 | file(GLOB sources ${example_dir}/*.js) 9 | list(APPEND example_sources ${sources}) 10 | 11 | # Any all resources. 12 | file(GLOB resources ${example_dir}/resources/*) 13 | list(APPEND example_resources ${resources}) 14 | endforeach() 15 | 16 | # Add all examples. 17 | foreach(example_source ${example_sources}) 18 | # Create the basename for the example 19 | get_filename_component(example_name ${example_source} NAME) 20 | 21 | configure_file(${example_source} ${example_name} COPYONLY) 22 | 23 | string(REGEX MATCH ".*/.*/" resources_dir ${example_source}) 24 | string(APPEND resources_dir "resources") 25 | endforeach() 26 | 27 | # Resources 28 | file(COPY ${example_resources} DESTINATION "resources/") 29 | -------------------------------------------------------------------------------- /examples/core/core_basic_window.js: -------------------------------------------------------------------------------- 1 | /******************************************************************************************* 2 | * 3 | * raylib [core] example - Basic window 4 | * 5 | * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) 6 | * 7 | * Copyright (c) 2018 Rob Loach (@RobLoach) 8 | * 9 | ********************************************************************************************/ 10 | 11 | // Initialization 12 | //-------------------------------------------------------------------------------------- 13 | const screenWidth = 800 14 | const screenHeight = 450 15 | InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window") 16 | 17 | SetTargetFPS(60) 18 | //-------------------------------------------------------------------------------------- 19 | 20 | // Main game loop 21 | while (!WindowShouldClose()) // Detect window close button or ESC key 22 | { 23 | // Update 24 | //---------------------------------------------------------------------------------- 25 | // TODO: Update your variables here 26 | //---------------------------------------------------------------------------------- 27 | 28 | // Draw 29 | //---------------------------------------------------------------------------------- 30 | BeginDrawing() 31 | 32 | ClearBackground(RAYWHITE) 33 | 34 | DrawText("Congrats! You created your first window!", 190, 200, 20, LIGHTGRAY) 35 | 36 | EndDrawing() 37 | //---------------------------------------------------------------------------------- 38 | } 39 | 40 | // De-Initialization 41 | //-------------------------------------------------------------------------------------- 42 | CloseWindow() // Close window and OpenGL context 43 | //-------------------------------------------------------------------------------------- 44 | -------------------------------------------------------------------------------- /examples/core/core_input_mouse.js: -------------------------------------------------------------------------------- 1 | /******************************************************************************************* 2 | * 3 | * raylib [core] example - Mouse input 4 | * 5 | * This example has been created using raylib 1.0 (www.raylib.com) 6 | * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) 7 | * 8 | * Copyright (c) 2014 Ramon Santamaria (@raysan5) 9 | * 10 | ********************************************************************************************/ 11 | 12 | // Initialization 13 | //-------------------------------------------------------------------------------------- 14 | const screenWidth = 800 15 | const screenHeight = 450 16 | 17 | InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input") 18 | 19 | var ballPosition = {x:-100, y:-100} 20 | var ballColor = DARKBLUE; 21 | 22 | SetTargetFPS(60); // Set our game to run at 60 frames-per-second 23 | //--------------------------------------------------------------------------------------- 24 | 25 | // Main game loop 26 | while (!WindowShouldClose()) // Detect window close button or ESC key 27 | { 28 | // Update 29 | //---------------------------------------------------------------------------------- 30 | 31 | ballPosition = GetMousePosition() 32 | 33 | if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) { 34 | ballColor = MAROON 35 | } 36 | else if (IsMouseButtonPressed(MOUSE_MIDDLE_BUTTON)) { 37 | ballColor = LIME 38 | } 39 | else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON)) { 40 | ballColor = DARKBLUE 41 | } 42 | 43 | //---------------------------------------------------------------------------------- 44 | 45 | // Draw 46 | //---------------------------------------------------------------------------------- 47 | BeginDrawing() 48 | 49 | ClearBackground(RAYWHITE) 50 | 51 | DrawCircleV(ballPosition, 40, ballColor) 52 | 53 | DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, DARKGRAY) 54 | 55 | EndDrawing() 56 | //---------------------------------------------------------------------------------- 57 | } 58 | 59 | // De-Initialization 60 | //-------------------------------------------------------------------------------------- 61 | CloseWindow() // Close window and OpenGL context 62 | //-------------------------------------------------------------------------------------- 63 | -------------------------------------------------------------------------------- /examples/shapes/logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobLoach/raylib-duktape/a2e1a67a4ad79d995d68ea0955e3ff15ec6d3587/examples/shapes/logo.png -------------------------------------------------------------------------------- /examples/shapes/shapes_logo_raylib.js: -------------------------------------------------------------------------------- 1 | // Initialization 2 | //-------------------------------------------------------------------------------------- 3 | const screenWidth = 800 4 | const screenHeight = 450 5 | const fontSize = 50 6 | const color = Color(247, 223, 30, 255) 7 | 8 | InitWindow(screenWidth, screenHeight, "raylib [shapes] example - raylib logo using shapes") 9 | 10 | SetTargetFPS(60) // Set our game to run at 60 frames-per-second 11 | const raylibWidth = MeasureText("raylib", fontSize) 12 | const duktapeWidth = MeasureText("duktape", fontSize) 13 | //-------------------------------------------------------------------------------------- 14 | 15 | // Main game loop 16 | while (!WindowShouldClose()) // Detect window close button or ESC key 17 | { 18 | // Update 19 | //---------------------------------------------------------------------------------- 20 | // TODO: Update your variables here 21 | //---------------------------------------------------------------------------------- 22 | 23 | // Draw 24 | //---------------------------------------------------------------------------------- 25 | BeginDrawing(); 26 | 27 | ClearBackground(RAYWHITE); 28 | 29 | DrawRectangle(screenWidth/2 - 128, screenHeight/2 - 128, 256, 256, BLACK); 30 | DrawRectangle(screenWidth/2 - 112, screenHeight/2 - 112, 224, 224, YELLOW); 31 | 32 | DrawText("raylib", screenWidth/2 + 112 - raylibWidth - 12, screenHeight/2 + 48 - 40, fontSize, BLACK); 33 | DrawText("duktape", screenWidth/2 + 112 - duktapeWidth - 12, screenHeight/2 + 48, fontSize, BLACK); 34 | 35 | DrawText("this is NOT a texture!", 350, 370, 10, GRAY); 36 | 37 | EndDrawing(); 38 | //---------------------------------------------------------------------------------- 39 | } 40 | 41 | // De-Initialization 42 | //-------------------------------------------------------------------------------------- 43 | CloseWindow(); // Close window and OpenGL context 44 | //-------------------------------------------------------------------------------------- 45 | -------------------------------------------------------------------------------- /examples/textures/resources/raylib_logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobLoach/raylib-duktape/a2e1a67a4ad79d995d68ea0955e3ff15ec6d3587/examples/textures/resources/raylib_logo.png -------------------------------------------------------------------------------- /examples/textures/resources/wabbit_alpha.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/RobLoach/raylib-duktape/a2e1a67a4ad79d995d68ea0955e3ff15ec6d3587/examples/textures/resources/wabbit_alpha.png -------------------------------------------------------------------------------- /examples/textures/textures_bunnymark.js: -------------------------------------------------------------------------------- 1 | 2 | const screenWidth = 800 3 | const screenHeight = 450 4 | InitWindow(screenWidth, screenHeight, 'raylib [textures] example - bunnymark') 5 | SetTargetFPS(60) 6 | 7 | const MAX_BUNNIES = 1000000 8 | const MAX_BATCH_ELEMENTS = 8192 9 | 10 | function Bunny () { 11 | const col = Color(GetRandomValue(50, 240), GetRandomValue(80, 240), GetRandomValue(100, 240), 255) 12 | return { 13 | position: GetMousePosition(), 14 | speed: Vector2(GetRandomValue(-250, 250) / 60, GetRandomValue(-250, 250) / 60), 15 | color: col 16 | } 17 | } 18 | 19 | var bunnies = [] 20 | bunnies.push(Bunny()) 21 | 22 | const texBunny = LoadTexture('resources/wabbit_alpha.png') 23 | 24 | while (!WindowShouldClose()) { 25 | if (IsMouseButtonDown(MOUSE_BUTTON_LEFT)) { 26 | for (var i = 0; i < 2; i++) { 27 | if (bunnies.length < MAX_BUNNIES) { 28 | bunnies.push(Bunny()) 29 | } 30 | } 31 | } 32 | 33 | for (var i = 0; i < bunnies.length; i++) { 34 | bunnies[i].position.x += bunnies[i].speed.x 35 | bunnies[i].position.y += bunnies[i].speed.y 36 | 37 | if (((bunnies[i].position.x + texBunny.width / 2) > GetScreenWidth()) || 38 | ((bunnies[i].position.x + texBunny.width / 2) < 0)) bunnies[i].speed.x *= -1 39 | if (((bunnies[i].position.y + texBunny.height / 2) > GetScreenHeight()) || 40 | ((bunnies[i].position.y + texBunny.height / 2 - 40) < 0)) bunnies[i].speed.y *= -1 41 | } 42 | 43 | BeginDrawing() 44 | ClearBackground(RAYWHITE) 45 | 46 | for (var i = 0; i < bunnies.length; i++) { 47 | DrawTextureV(texBunny, bunnies[i].position, bunnies[i].color) 48 | } 49 | 50 | DrawRectangle(0, 0, screenWidth, 40, BLACK); 51 | DrawText("bunnies: " + bunnies.length, 120, 10, 20, GREEN); 52 | DrawText("batched draw calls: " + (1 + bunnies.length / MAX_BATCH_ELEMENTS), 320, 10, 20, MAROON); 53 | 54 | DrawFPS(10, 10) 55 | 56 | EndDrawing() 57 | } 58 | 59 | UnloadTexture(texBunny) 60 | CloseWindow() 61 | -------------------------------------------------------------------------------- /examples/textures/textures_image_loading.js: -------------------------------------------------------------------------------- 1 | /******************************************************************************************* 2 | * 3 | * raylib [textures] example - Image loading and texture creation 4 | * 5 | * NOTE: Images are loaded in CPU memory (RAM); textures are loaded in GPU memory (VRAM) 6 | * 7 | * This example has been created using raylib 1.3 (www.raylib.com) 8 | * raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) 9 | * 10 | * Copyright (c) 2015 Ramon Santamaria (@raysan5) 11 | * 12 | ********************************************************************************************/ 13 | 14 | // Initialization 15 | //-------------------------------------------------------------------------------------- 16 | const screenWidth = 800; 17 | const screenHeight = 450; 18 | 19 | InitWindow(screenWidth, screenHeight, "raylib [textures] example - image loading"); 20 | 21 | // NOTE: Textures MUST be loaded after Window initialization (OpenGL context is required) 22 | 23 | const image = LoadImage("resources/raylib_logo.png"); // Loaded in CPU memory (RAM) 24 | const texture = LoadTextureFromImage(image); // Image converted to texture, GPU memory (VRAM) 25 | 26 | UnloadImage(image); // Once image has been converted to texture and uploaded to VRAM, it can be unloaded from RAM 27 | //--------------------------------------------------------------------------------------- 28 | 29 | // Main game loop 30 | while (!WindowShouldClose()) // Detect window close button or ESC key 31 | { 32 | // Update 33 | //---------------------------------------------------------------------------------- 34 | // TODO: Update your variables here 35 | //---------------------------------------------------------------------------------- 36 | 37 | // Draw 38 | //---------------------------------------------------------------------------------- 39 | BeginDrawing(); 40 | 41 | ClearBackground(RAYWHITE); 42 | 43 | DrawTexture(texture, screenWidth/2 - texture.width/2, screenHeight/2 - texture.height/2, WHITE); 44 | 45 | DrawText("this IS a texture loaded from an image!", 300, 370, 10, GRAY); 46 | 47 | EndDrawing(); 48 | //---------------------------------------------------------------------------------- 49 | } 50 | 51 | // De-Initialization 52 | //-------------------------------------------------------------------------------------- 53 | UnloadTexture(texture); // Texture unloading 54 | 55 | CloseWindow(); // Close window and OpenGL context 56 | //-------------------------------------------------------------------------------------- 57 | -------------------------------------------------------------------------------- /generator/index.js: -------------------------------------------------------------------------------- 1 | const r = require('@raylib/api').raylib 2 | const fs = require('fs') 3 | const path = require('path') 4 | 5 | const header = ` 6 | /** 7 | * This file is automatically generated by npm it. 8 | */ 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include "raylib-duktape.h" 14 | ` 15 | 16 | const functionHeader = ` 17 | void raylib_duktape_gen(duk_context* ctx) { 18 | ` 19 | 20 | const footer = ` 21 | } 22 | ` 23 | 24 | const definesBlacklist = [ 25 | 'RAYLIB_H', 26 | '__declspec(x)', 27 | 'RLAPI', 28 | 'DEG2RAD', 29 | 'RAD2DEG', 30 | 'RL_BOOL_TYPE', 31 | 'RL_MALLOC(sz)', 32 | 'RL_CALLOC(n,sz)', 33 | 'RL_REALLOC(ptr,sz)', 34 | 'RL_FREE(ptr)', 35 | 'CLITERAL(type)', 36 | 'RL_COLOR_TYPE', 37 | 'RL_RECTANGLE_TYPE', 38 | 'RL_VECTOR2_TYPE', 39 | 'RL_VECTOR3_TYPE', 40 | 'RL_VECTOR4_TYPE', 41 | 'RL_QUATERNION_TYPE', 42 | 'RL_MATRIX_TYPE', 43 | 'RAYLIB_VERSION', 44 | 'MOUSE_LEFT_BUTTON', 45 | 'MOUSE_RIGHT_BUTTON', 46 | 'MOUSE_MIDDLE_BUTTON', 47 | 'MATERIAL_MAP_DIFFUSE', 48 | 'MATERIAL_MAP_SPECULAR', 49 | 'SHADER_LOC_MAP_DIFFUSE', 50 | 'SHADER_LOC_MAP_SPECULAR', 51 | ] 52 | 53 | r.enums.push({ 54 | name: 'Custom', 55 | description: 'Additional defines', 56 | values: [ 57 | { name: 'MOUSE_LEFT_BUTTON' }, 58 | { name: 'MOUSE_RIGHT_BUTTON' }, 59 | { name: 'MOUSE_MIDDLE_BUTTON' }, 60 | ] 61 | }) 62 | 63 | const defines = r.defines.map((define) => { 64 | if (definesBlacklist.includes(define.name)) { 65 | return ` // Skipped: ${define.name}` 66 | } 67 | return ` dukglue_register_global(ctx, ${define.name}, "${define.name}");`; 68 | }).join('\n') + '\n' 69 | 70 | const enums = r.enums.map((enumeration) => { 71 | const header = ` // ${enumeration.name}` 72 | const out = enumeration.values.map((val) => { 73 | return ` dukglue_register_global(ctx, (int)${val.name}, "${val.name}");` 74 | }).join('\n') 75 | 76 | return `${header}\n${out}\n` 77 | }).join('\n') + '\n' 78 | 79 | 80 | const functionBlacklist = [ 81 | 'TraceLog', 82 | 'TextFormat', 83 | 'SetShaderValue', 84 | 'GetShaderLocationAttrib', 85 | 'SetShaderValueV', 86 | 'SetShaderValueMatrix', 87 | 'SetShaderValueTexture', 88 | 'UnloadShader', 89 | 'MemAlloc', 90 | 'MemRealloc', 91 | 'MemFree', 92 | 'LoadFileData', 93 | 'UnloadFileData', 94 | 'SaveFileData', 95 | 'LoadFileText', 96 | 'UnloadFileText', 97 | 'SaveFileText', 98 | 'CompressData', 99 | 'DecompressData', 100 | 'EncodeDataBase64', 101 | 'DecodeDataBase64', 102 | 'UpdateCamera', 103 | 'DrawLineStrip', 104 | 'DrawPolyLines', 105 | 'DrawPolyLinesEx', 106 | 'DrawTriangleFan', 107 | 'DrawPolyLines', 108 | 'DrawPolyLinesEx', 109 | 'DrawTriangleStrip', 110 | 'DrawPoly', 111 | 'CheckCollisionLines', 112 | 'LoadImageAnim', 113 | 'LoadImageFromMemory', 114 | 'ImageFormat', 115 | 'ImageToPOT', 116 | 'ImageCrop', 117 | 'ImageAlphaCrop', 118 | 'ImageAlphaClear', 119 | 'ImageAlphaMask', 120 | 'ImageAlphaPremultiply', 121 | 'ImageResize', 122 | 'ImageResizeNN', 123 | 'ImageResizeCanvas', 124 | 'ImageMipmaps', 125 | 'ImageDither', 126 | 'ImageFlipVertical', 127 | 'ImageFlipHorizontal', 128 | 'ImageRotateCW', 129 | 'ImageRotateCCW', 130 | 'ImageColorTint', 131 | 'ImageColorInvert', 132 | 'ImageColorGrayscale', 133 | 'ImageColorContrast', 134 | 'ImageColorBrightness', 135 | 'ImageColorReplace', 136 | 'LoadImageColors', 137 | 'LoadImagePalette', 138 | 'UnloadImageColors', 139 | 'UnloadImagePalette', 140 | 'GetImageAlphaBorder', 141 | 'GetImageColor', 142 | 'ImageClearBackground', 143 | 'ImageDrawPixel', 144 | 'ImageDrawPixelV', 145 | 'ImageDrawLine', 146 | 'ImageDrawLineV', 147 | 'ImageDrawCircle', 148 | 'ImageDrawCircleV', 149 | 'ImageDrawRectangle', 150 | 'ImageDrawRectangleV', 151 | 'ImageDrawRectangleRec', 152 | 'ImageDrawRectangleLines', 153 | 'ImageDraw', 154 | 'ImageDrawText', 155 | 'ImageDrawTextEx', 156 | 'UpdateTexture', 157 | 'UpdateTextureRec', 158 | 'GenTextureMipmaps', 159 | 'GetPixelColor', 160 | 'SetPixelColor', 161 | 'GetPixelDataSize', 162 | 'LoadFontEx', 163 | 'LoadFontFromMemory', 164 | 'LoadFontData', 165 | 'GenImageFontAtlas', 166 | 'UnloadFontData', 167 | 'ExportFontAsCode', 168 | 'DrawTexturePoly', 169 | 'DrawTextCodepoints', 170 | 'LoadCodepoints', 171 | 'UnloadCodepoints', 172 | 'GetCodepoint', 173 | 'CodepointToUTF8', 174 | 'TextCodepointsToUTF8', 175 | 'TextCopy', 176 | 'TextReplace', 177 | 'TextJoin', 178 | 'TextSplit', 179 | 'TextAppend', 180 | 'DrawTriangleStrip3D', 181 | 'UploadMesh', 182 | 'UpdateMeshBuffer', 183 | 'DrawMeshInstanced', 184 | 'GenMeshTangents', 185 | 'LoadMaterials', 186 | 'SetMaterialTexture', 187 | 'SetModelMeshMaterial', 188 | 'LoadModelAnimations', 189 | 'UnloadModelAnimations', 190 | 'LoadWaveFromMemory', 191 | 'UpdateSound', 192 | 'WaveCrop', 193 | 'WaveFormat', 194 | 'LoadWaveSamples', 195 | 'UnloadWaveSamples', 196 | 'LoadMusicStreamFromMemory', 197 | 'UpdateAudioStream', 198 | 'GetWindowHandle', 199 | 'TextInsert', 200 | 'SetTraceLogCallback', 201 | 'SetLoadFileDataCallback', 202 | 'SetSaveFileDataCallback', 203 | 'SetLoadFileTextCallback', 204 | 'SetSaveFileTextCallback', 205 | 'SetAudioStreamCallback', 206 | 'DetachAudioStreamProcessor', 207 | 'AttachAudioStreamProcessor' 208 | ] 209 | const functions = r.functions.map((func) => { 210 | let prefix = ' ' 211 | if (functionBlacklist.includes(func.name)) { 212 | prefix = ' // ' 213 | } 214 | return `${prefix}dukglue_register_function(ctx, &${func.name}, "${func.name}");` 215 | }).join('\n') 216 | 217 | function readPropertyTypeToFunction(type) { 218 | switch (type) { 219 | case 'unsigned int': 220 | case 'unsigned char': 221 | return ['duk_get_uint', 'duk_push_uint'] 222 | case 'int': 223 | return ['duk_get_int', 'duk_push_int'] 224 | case 'float': 225 | case 'double': 226 | return ['duk_get_number', 'duk_push_number'] 227 | case 'const char*': 228 | case 'char[32]': 229 | return ['duk_get_string', 'duk_push_string'] 230 | case 'char **': 231 | return ['(char**)duk_get_pointer', 'duk_push_pointer'] 232 | case 'Transform **': 233 | return ['(Transform**)duk_get_pointer', 'duk_push_pointer'] 234 | case 'float[2]': 235 | case 'float[4]': 236 | case 'Matrix[2]': 237 | return ['skip', 'skip'] 238 | case 'bool': 239 | return ['duk_get_boolean', 'duk_push_boolean'] 240 | } 241 | 242 | if (type.includes(' *')) { 243 | return [`(${type})duk_get_pointer`, 'duk_push_pointer'] 244 | } 245 | return ['raylib_duktape_get<' + type + '>', 'raylib_duktape_push<' + type + '>'] 246 | } 247 | 248 | 249 | const structHeader = ` 250 | namespace dukglue { 251 | namespace types { 252 | ` 253 | 254 | const structFooter = '}}' 255 | const structs = structHeader + r.structs.map((structure) => { 256 | 257 | let readProperties = '' 258 | let pushProperties = '' 259 | for (let field of structure.fields) { 260 | const func = readPropertyTypeToFunction(field.type) 261 | if (func[0] != 'skip') { 262 | readProperties += ` 263 | duk_get_prop_string(ctx, arg_idx, "${field.name}"); 264 | out.${field.name} = ${func[0]}(ctx, -1);` 265 | } 266 | else { 267 | readProperties += `\n // Skipped: ${field.name}` 268 | } 269 | if (func[1] != 'skip') { 270 | pushProperties += ` 271 | ${func[1]}(ctx, value.${field.name}); 272 | duk_put_prop_string(ctx, obj_idx, "${field.name}");` 273 | } 274 | else { 275 | pushProperties += `\n // Skipped: ${field.name}` 276 | } 277 | } 278 | return `template<> 279 | struct DukType<::${structure.name}> { 280 | typedef std::true_type IsValueType; 281 | template 282 | static ::${structure.name} read(duk_context* ctx, duk_idx_t arg_idx) { 283 | if (!duk_is_object(ctx, arg_idx)) { 284 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 285 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 286 | } 287 | ::${structure.name} out;${readProperties} 288 | return out; 289 | } 290 | template 291 | static void push(duk_context* ctx, ::${structure.name} value) { 292 | duk_idx_t obj_idx = duk_push_object(ctx); 293 | ${pushProperties} 294 | } 295 | };\n` 296 | }).join('\n') + structFooter 297 | 298 | fs.writeFileSync(path.join(__dirname, '..', 'lib', 'raylib-duktape-gen.h'), 299 | header + 300 | structs + 301 | functionHeader + 302 | enums + 303 | defines + 304 | functions + 305 | footer); 306 | -------------------------------------------------------------------------------- /lib/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_library(raylib-duktape STATIC raylib-duktape.cpp) 2 | install(FILES 3 | raylib-duktape.h DESTINATION include 4 | ) 5 | target_include_directories(raylib-duktape INTERFACE ${CMAKE_CURRENT_SOURCE_DIR}) 6 | 7 | # dukglue 8 | find_package(dukglue 2.5 QUIET) 9 | if (NOT dukglue_FOUND) 10 | include(FetchContent) 11 | FetchContent_Declare( 12 | dukglue 13 | GIT_REPOSITORY https://github.com/Aloshi/dukglue.git 14 | GIT_TAG c2dc87602c824378cd255cb8fd7dd6b33a301bba 15 | ) 16 | FetchContent_GetProperties(dukglue) 17 | if (NOT dukglue_POPULATED) # Have we downloaded raylib yet? 18 | set(FETCHCONTENT_QUIET NO) 19 | FetchContent_Populate(dukglue) 20 | set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) # don't build the supplied examples 21 | set(BUILD_GAMES OFF CACHE BOOL "" FORCE) # or games 22 | add_subdirectory(${dukglue_SOURCE_DIR} ${dukglue_BINARY_DIR}) 23 | endif() 24 | endif() 25 | 26 | # Duktape 27 | include(FetchContent) 28 | FetchContent_Declare( 29 | duktapecmake 30 | GIT_REPOSITORY https://github.com/robloach/duktape-cmake.git 31 | GIT_TAG v2.7.0 32 | ) 33 | FetchContent_GetProperties(duktapecmake) 34 | if (NOT duktapecmake_POPULATED) 35 | set(FETCHCONTENT_QUIET NO) 36 | FetchContent_Populate(duktapecmake) 37 | add_subdirectory(${duktapecmake_SOURCE_DIR} ${duktapecmake_BINARY_DIR}) 38 | endif() 39 | 40 | # raylib 41 | set(RAYLIB_VERSION 4.2.0) 42 | find_package(raylib ${RAYLIB_VERSION} QUIET) 43 | if (NOT raylib_FOUND) 44 | include(FetchContent) 45 | FetchContent_Declare( 46 | raylib 47 | GIT_REPOSITORY https://github.com/raysan5/raylib.git 48 | GIT_TAG ${RAYLIB_VERSION} 49 | ) 50 | FetchContent_GetProperties(raylib) 51 | if (NOT raylib_POPULATED) # Have we downloaded raylib yet? 52 | set(FETCHCONTENT_QUIET NO) 53 | FetchContent_Populate(raylib) 54 | set(BUILD_EXAMPLES OFF CACHE BOOL "" FORCE) # don't build the supplied examples 55 | set(BUILD_GAMES OFF CACHE BOOL "" FORCE) # or games 56 | add_subdirectory(${raylib_SOURCE_DIR} ${raylib_BINARY_DIR}) 57 | endif() 58 | endif() 59 | 60 | target_link_libraries(raylib-duktape raylib duktape dukglue) 61 | -------------------------------------------------------------------------------- /lib/raylib-duktape-gen.h: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * This file is automatically generated by npm it. 4 | */ 5 | #include 6 | #include 7 | #include 8 | #include 9 | #include "raylib-duktape.h" 10 | 11 | namespace dukglue { 12 | namespace types { 13 | template<> 14 | struct DukType<::Vector2> { 15 | typedef std::true_type IsValueType; 16 | template 17 | static ::Vector2 read(duk_context* ctx, duk_idx_t arg_idx) { 18 | if (!duk_is_object(ctx, arg_idx)) { 19 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 20 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 21 | } 22 | ::Vector2 out; 23 | duk_get_prop_string(ctx, arg_idx, "x"); 24 | out.x = duk_get_number(ctx, -1); 25 | duk_get_prop_string(ctx, arg_idx, "y"); 26 | out.y = duk_get_number(ctx, -1); 27 | return out; 28 | } 29 | template 30 | static void push(duk_context* ctx, ::Vector2 value) { 31 | duk_idx_t obj_idx = duk_push_object(ctx); 32 | 33 | duk_push_number(ctx, value.x); 34 | duk_put_prop_string(ctx, obj_idx, "x"); 35 | duk_push_number(ctx, value.y); 36 | duk_put_prop_string(ctx, obj_idx, "y"); 37 | } 38 | }; 39 | 40 | template<> 41 | struct DukType<::Vector3> { 42 | typedef std::true_type IsValueType; 43 | template 44 | static ::Vector3 read(duk_context* ctx, duk_idx_t arg_idx) { 45 | if (!duk_is_object(ctx, arg_idx)) { 46 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 47 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 48 | } 49 | ::Vector3 out; 50 | duk_get_prop_string(ctx, arg_idx, "x"); 51 | out.x = duk_get_number(ctx, -1); 52 | duk_get_prop_string(ctx, arg_idx, "y"); 53 | out.y = duk_get_number(ctx, -1); 54 | duk_get_prop_string(ctx, arg_idx, "z"); 55 | out.z = duk_get_number(ctx, -1); 56 | return out; 57 | } 58 | template 59 | static void push(duk_context* ctx, ::Vector3 value) { 60 | duk_idx_t obj_idx = duk_push_object(ctx); 61 | 62 | duk_push_number(ctx, value.x); 63 | duk_put_prop_string(ctx, obj_idx, "x"); 64 | duk_push_number(ctx, value.y); 65 | duk_put_prop_string(ctx, obj_idx, "y"); 66 | duk_push_number(ctx, value.z); 67 | duk_put_prop_string(ctx, obj_idx, "z"); 68 | } 69 | }; 70 | 71 | template<> 72 | struct DukType<::Vector4> { 73 | typedef std::true_type IsValueType; 74 | template 75 | static ::Vector4 read(duk_context* ctx, duk_idx_t arg_idx) { 76 | if (!duk_is_object(ctx, arg_idx)) { 77 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 78 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 79 | } 80 | ::Vector4 out; 81 | duk_get_prop_string(ctx, arg_idx, "x"); 82 | out.x = duk_get_number(ctx, -1); 83 | duk_get_prop_string(ctx, arg_idx, "y"); 84 | out.y = duk_get_number(ctx, -1); 85 | duk_get_prop_string(ctx, arg_idx, "z"); 86 | out.z = duk_get_number(ctx, -1); 87 | duk_get_prop_string(ctx, arg_idx, "w"); 88 | out.w = duk_get_number(ctx, -1); 89 | return out; 90 | } 91 | template 92 | static void push(duk_context* ctx, ::Vector4 value) { 93 | duk_idx_t obj_idx = duk_push_object(ctx); 94 | 95 | duk_push_number(ctx, value.x); 96 | duk_put_prop_string(ctx, obj_idx, "x"); 97 | duk_push_number(ctx, value.y); 98 | duk_put_prop_string(ctx, obj_idx, "y"); 99 | duk_push_number(ctx, value.z); 100 | duk_put_prop_string(ctx, obj_idx, "z"); 101 | duk_push_number(ctx, value.w); 102 | duk_put_prop_string(ctx, obj_idx, "w"); 103 | } 104 | }; 105 | 106 | template<> 107 | struct DukType<::Matrix> { 108 | typedef std::true_type IsValueType; 109 | template 110 | static ::Matrix read(duk_context* ctx, duk_idx_t arg_idx) { 111 | if (!duk_is_object(ctx, arg_idx)) { 112 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 113 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 114 | } 115 | ::Matrix out; 116 | duk_get_prop_string(ctx, arg_idx, "m0"); 117 | out.m0 = duk_get_number(ctx, -1); 118 | duk_get_prop_string(ctx, arg_idx, "m4"); 119 | out.m4 = duk_get_number(ctx, -1); 120 | duk_get_prop_string(ctx, arg_idx, "m8"); 121 | out.m8 = duk_get_number(ctx, -1); 122 | duk_get_prop_string(ctx, arg_idx, "m12"); 123 | out.m12 = duk_get_number(ctx, -1); 124 | duk_get_prop_string(ctx, arg_idx, "m1"); 125 | out.m1 = duk_get_number(ctx, -1); 126 | duk_get_prop_string(ctx, arg_idx, "m5"); 127 | out.m5 = duk_get_number(ctx, -1); 128 | duk_get_prop_string(ctx, arg_idx, "m9"); 129 | out.m9 = duk_get_number(ctx, -1); 130 | duk_get_prop_string(ctx, arg_idx, "m13"); 131 | out.m13 = duk_get_number(ctx, -1); 132 | duk_get_prop_string(ctx, arg_idx, "m2"); 133 | out.m2 = duk_get_number(ctx, -1); 134 | duk_get_prop_string(ctx, arg_idx, "m6"); 135 | out.m6 = duk_get_number(ctx, -1); 136 | duk_get_prop_string(ctx, arg_idx, "m10"); 137 | out.m10 = duk_get_number(ctx, -1); 138 | duk_get_prop_string(ctx, arg_idx, "m14"); 139 | out.m14 = duk_get_number(ctx, -1); 140 | duk_get_prop_string(ctx, arg_idx, "m3"); 141 | out.m3 = duk_get_number(ctx, -1); 142 | duk_get_prop_string(ctx, arg_idx, "m7"); 143 | out.m7 = duk_get_number(ctx, -1); 144 | duk_get_prop_string(ctx, arg_idx, "m11"); 145 | out.m11 = duk_get_number(ctx, -1); 146 | duk_get_prop_string(ctx, arg_idx, "m15"); 147 | out.m15 = duk_get_number(ctx, -1); 148 | return out; 149 | } 150 | template 151 | static void push(duk_context* ctx, ::Matrix value) { 152 | duk_idx_t obj_idx = duk_push_object(ctx); 153 | 154 | duk_push_number(ctx, value.m0); 155 | duk_put_prop_string(ctx, obj_idx, "m0"); 156 | duk_push_number(ctx, value.m4); 157 | duk_put_prop_string(ctx, obj_idx, "m4"); 158 | duk_push_number(ctx, value.m8); 159 | duk_put_prop_string(ctx, obj_idx, "m8"); 160 | duk_push_number(ctx, value.m12); 161 | duk_put_prop_string(ctx, obj_idx, "m12"); 162 | duk_push_number(ctx, value.m1); 163 | duk_put_prop_string(ctx, obj_idx, "m1"); 164 | duk_push_number(ctx, value.m5); 165 | duk_put_prop_string(ctx, obj_idx, "m5"); 166 | duk_push_number(ctx, value.m9); 167 | duk_put_prop_string(ctx, obj_idx, "m9"); 168 | duk_push_number(ctx, value.m13); 169 | duk_put_prop_string(ctx, obj_idx, "m13"); 170 | duk_push_number(ctx, value.m2); 171 | duk_put_prop_string(ctx, obj_idx, "m2"); 172 | duk_push_number(ctx, value.m6); 173 | duk_put_prop_string(ctx, obj_idx, "m6"); 174 | duk_push_number(ctx, value.m10); 175 | duk_put_prop_string(ctx, obj_idx, "m10"); 176 | duk_push_number(ctx, value.m14); 177 | duk_put_prop_string(ctx, obj_idx, "m14"); 178 | duk_push_number(ctx, value.m3); 179 | duk_put_prop_string(ctx, obj_idx, "m3"); 180 | duk_push_number(ctx, value.m7); 181 | duk_put_prop_string(ctx, obj_idx, "m7"); 182 | duk_push_number(ctx, value.m11); 183 | duk_put_prop_string(ctx, obj_idx, "m11"); 184 | duk_push_number(ctx, value.m15); 185 | duk_put_prop_string(ctx, obj_idx, "m15"); 186 | } 187 | }; 188 | 189 | template<> 190 | struct DukType<::Color> { 191 | typedef std::true_type IsValueType; 192 | template 193 | static ::Color read(duk_context* ctx, duk_idx_t arg_idx) { 194 | if (!duk_is_object(ctx, arg_idx)) { 195 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 196 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 197 | } 198 | ::Color out; 199 | duk_get_prop_string(ctx, arg_idx, "r"); 200 | out.r = duk_get_uint(ctx, -1); 201 | duk_get_prop_string(ctx, arg_idx, "g"); 202 | out.g = duk_get_uint(ctx, -1); 203 | duk_get_prop_string(ctx, arg_idx, "b"); 204 | out.b = duk_get_uint(ctx, -1); 205 | duk_get_prop_string(ctx, arg_idx, "a"); 206 | out.a = duk_get_uint(ctx, -1); 207 | return out; 208 | } 209 | template 210 | static void push(duk_context* ctx, ::Color value) { 211 | duk_idx_t obj_idx = duk_push_object(ctx); 212 | 213 | duk_push_uint(ctx, value.r); 214 | duk_put_prop_string(ctx, obj_idx, "r"); 215 | duk_push_uint(ctx, value.g); 216 | duk_put_prop_string(ctx, obj_idx, "g"); 217 | duk_push_uint(ctx, value.b); 218 | duk_put_prop_string(ctx, obj_idx, "b"); 219 | duk_push_uint(ctx, value.a); 220 | duk_put_prop_string(ctx, obj_idx, "a"); 221 | } 222 | }; 223 | 224 | template<> 225 | struct DukType<::Rectangle> { 226 | typedef std::true_type IsValueType; 227 | template 228 | static ::Rectangle read(duk_context* ctx, duk_idx_t arg_idx) { 229 | if (!duk_is_object(ctx, arg_idx)) { 230 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 231 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 232 | } 233 | ::Rectangle out; 234 | duk_get_prop_string(ctx, arg_idx, "x"); 235 | out.x = duk_get_number(ctx, -1); 236 | duk_get_prop_string(ctx, arg_idx, "y"); 237 | out.y = duk_get_number(ctx, -1); 238 | duk_get_prop_string(ctx, arg_idx, "width"); 239 | out.width = duk_get_number(ctx, -1); 240 | duk_get_prop_string(ctx, arg_idx, "height"); 241 | out.height = duk_get_number(ctx, -1); 242 | return out; 243 | } 244 | template 245 | static void push(duk_context* ctx, ::Rectangle value) { 246 | duk_idx_t obj_idx = duk_push_object(ctx); 247 | 248 | duk_push_number(ctx, value.x); 249 | duk_put_prop_string(ctx, obj_idx, "x"); 250 | duk_push_number(ctx, value.y); 251 | duk_put_prop_string(ctx, obj_idx, "y"); 252 | duk_push_number(ctx, value.width); 253 | duk_put_prop_string(ctx, obj_idx, "width"); 254 | duk_push_number(ctx, value.height); 255 | duk_put_prop_string(ctx, obj_idx, "height"); 256 | } 257 | }; 258 | 259 | template<> 260 | struct DukType<::Image> { 261 | typedef std::true_type IsValueType; 262 | template 263 | static ::Image read(duk_context* ctx, duk_idx_t arg_idx) { 264 | if (!duk_is_object(ctx, arg_idx)) { 265 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 266 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 267 | } 268 | ::Image out; 269 | duk_get_prop_string(ctx, arg_idx, "data"); 270 | out.data = (void *)duk_get_pointer(ctx, -1); 271 | duk_get_prop_string(ctx, arg_idx, "width"); 272 | out.width = duk_get_int(ctx, -1); 273 | duk_get_prop_string(ctx, arg_idx, "height"); 274 | out.height = duk_get_int(ctx, -1); 275 | duk_get_prop_string(ctx, arg_idx, "mipmaps"); 276 | out.mipmaps = duk_get_int(ctx, -1); 277 | duk_get_prop_string(ctx, arg_idx, "format"); 278 | out.format = duk_get_int(ctx, -1); 279 | return out; 280 | } 281 | template 282 | static void push(duk_context* ctx, ::Image value) { 283 | duk_idx_t obj_idx = duk_push_object(ctx); 284 | 285 | duk_push_pointer(ctx, value.data); 286 | duk_put_prop_string(ctx, obj_idx, "data"); 287 | duk_push_int(ctx, value.width); 288 | duk_put_prop_string(ctx, obj_idx, "width"); 289 | duk_push_int(ctx, value.height); 290 | duk_put_prop_string(ctx, obj_idx, "height"); 291 | duk_push_int(ctx, value.mipmaps); 292 | duk_put_prop_string(ctx, obj_idx, "mipmaps"); 293 | duk_push_int(ctx, value.format); 294 | duk_put_prop_string(ctx, obj_idx, "format"); 295 | } 296 | }; 297 | 298 | template<> 299 | struct DukType<::Texture> { 300 | typedef std::true_type IsValueType; 301 | template 302 | static ::Texture read(duk_context* ctx, duk_idx_t arg_idx) { 303 | if (!duk_is_object(ctx, arg_idx)) { 304 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 305 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 306 | } 307 | ::Texture out; 308 | duk_get_prop_string(ctx, arg_idx, "id"); 309 | out.id = duk_get_uint(ctx, -1); 310 | duk_get_prop_string(ctx, arg_idx, "width"); 311 | out.width = duk_get_int(ctx, -1); 312 | duk_get_prop_string(ctx, arg_idx, "height"); 313 | out.height = duk_get_int(ctx, -1); 314 | duk_get_prop_string(ctx, arg_idx, "mipmaps"); 315 | out.mipmaps = duk_get_int(ctx, -1); 316 | duk_get_prop_string(ctx, arg_idx, "format"); 317 | out.format = duk_get_int(ctx, -1); 318 | return out; 319 | } 320 | template 321 | static void push(duk_context* ctx, ::Texture value) { 322 | duk_idx_t obj_idx = duk_push_object(ctx); 323 | 324 | duk_push_uint(ctx, value.id); 325 | duk_put_prop_string(ctx, obj_idx, "id"); 326 | duk_push_int(ctx, value.width); 327 | duk_put_prop_string(ctx, obj_idx, "width"); 328 | duk_push_int(ctx, value.height); 329 | duk_put_prop_string(ctx, obj_idx, "height"); 330 | duk_push_int(ctx, value.mipmaps); 331 | duk_put_prop_string(ctx, obj_idx, "mipmaps"); 332 | duk_push_int(ctx, value.format); 333 | duk_put_prop_string(ctx, obj_idx, "format"); 334 | } 335 | }; 336 | 337 | template<> 338 | struct DukType<::RenderTexture> { 339 | typedef std::true_type IsValueType; 340 | template 341 | static ::RenderTexture read(duk_context* ctx, duk_idx_t arg_idx) { 342 | if (!duk_is_object(ctx, arg_idx)) { 343 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 344 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 345 | } 346 | ::RenderTexture out; 347 | duk_get_prop_string(ctx, arg_idx, "id"); 348 | out.id = duk_get_uint(ctx, -1); 349 | duk_get_prop_string(ctx, arg_idx, "texture"); 350 | out.texture = raylib_duktape_get(ctx, -1); 351 | duk_get_prop_string(ctx, arg_idx, "depth"); 352 | out.depth = raylib_duktape_get(ctx, -1); 353 | return out; 354 | } 355 | template 356 | static void push(duk_context* ctx, ::RenderTexture value) { 357 | duk_idx_t obj_idx = duk_push_object(ctx); 358 | 359 | duk_push_uint(ctx, value.id); 360 | duk_put_prop_string(ctx, obj_idx, "id"); 361 | raylib_duktape_push(ctx, value.texture); 362 | duk_put_prop_string(ctx, obj_idx, "texture"); 363 | raylib_duktape_push(ctx, value.depth); 364 | duk_put_prop_string(ctx, obj_idx, "depth"); 365 | } 366 | }; 367 | 368 | template<> 369 | struct DukType<::NPatchInfo> { 370 | typedef std::true_type IsValueType; 371 | template 372 | static ::NPatchInfo read(duk_context* ctx, duk_idx_t arg_idx) { 373 | if (!duk_is_object(ctx, arg_idx)) { 374 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 375 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 376 | } 377 | ::NPatchInfo out; 378 | duk_get_prop_string(ctx, arg_idx, "source"); 379 | out.source = raylib_duktape_get(ctx, -1); 380 | duk_get_prop_string(ctx, arg_idx, "left"); 381 | out.left = duk_get_int(ctx, -1); 382 | duk_get_prop_string(ctx, arg_idx, "top"); 383 | out.top = duk_get_int(ctx, -1); 384 | duk_get_prop_string(ctx, arg_idx, "right"); 385 | out.right = duk_get_int(ctx, -1); 386 | duk_get_prop_string(ctx, arg_idx, "bottom"); 387 | out.bottom = duk_get_int(ctx, -1); 388 | duk_get_prop_string(ctx, arg_idx, "layout"); 389 | out.layout = duk_get_int(ctx, -1); 390 | return out; 391 | } 392 | template 393 | static void push(duk_context* ctx, ::NPatchInfo value) { 394 | duk_idx_t obj_idx = duk_push_object(ctx); 395 | 396 | raylib_duktape_push(ctx, value.source); 397 | duk_put_prop_string(ctx, obj_idx, "source"); 398 | duk_push_int(ctx, value.left); 399 | duk_put_prop_string(ctx, obj_idx, "left"); 400 | duk_push_int(ctx, value.top); 401 | duk_put_prop_string(ctx, obj_idx, "top"); 402 | duk_push_int(ctx, value.right); 403 | duk_put_prop_string(ctx, obj_idx, "right"); 404 | duk_push_int(ctx, value.bottom); 405 | duk_put_prop_string(ctx, obj_idx, "bottom"); 406 | duk_push_int(ctx, value.layout); 407 | duk_put_prop_string(ctx, obj_idx, "layout"); 408 | } 409 | }; 410 | 411 | template<> 412 | struct DukType<::GlyphInfo> { 413 | typedef std::true_type IsValueType; 414 | template 415 | static ::GlyphInfo read(duk_context* ctx, duk_idx_t arg_idx) { 416 | if (!duk_is_object(ctx, arg_idx)) { 417 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 418 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 419 | } 420 | ::GlyphInfo out; 421 | duk_get_prop_string(ctx, arg_idx, "value"); 422 | out.value = duk_get_int(ctx, -1); 423 | duk_get_prop_string(ctx, arg_idx, "offsetX"); 424 | out.offsetX = duk_get_int(ctx, -1); 425 | duk_get_prop_string(ctx, arg_idx, "offsetY"); 426 | out.offsetY = duk_get_int(ctx, -1); 427 | duk_get_prop_string(ctx, arg_idx, "advanceX"); 428 | out.advanceX = duk_get_int(ctx, -1); 429 | duk_get_prop_string(ctx, arg_idx, "image"); 430 | out.image = raylib_duktape_get(ctx, -1); 431 | return out; 432 | } 433 | template 434 | static void push(duk_context* ctx, ::GlyphInfo value) { 435 | duk_idx_t obj_idx = duk_push_object(ctx); 436 | 437 | duk_push_int(ctx, value.value); 438 | duk_put_prop_string(ctx, obj_idx, "value"); 439 | duk_push_int(ctx, value.offsetX); 440 | duk_put_prop_string(ctx, obj_idx, "offsetX"); 441 | duk_push_int(ctx, value.offsetY); 442 | duk_put_prop_string(ctx, obj_idx, "offsetY"); 443 | duk_push_int(ctx, value.advanceX); 444 | duk_put_prop_string(ctx, obj_idx, "advanceX"); 445 | raylib_duktape_push(ctx, value.image); 446 | duk_put_prop_string(ctx, obj_idx, "image"); 447 | } 448 | }; 449 | 450 | template<> 451 | struct DukType<::Font> { 452 | typedef std::true_type IsValueType; 453 | template 454 | static ::Font read(duk_context* ctx, duk_idx_t arg_idx) { 455 | if (!duk_is_object(ctx, arg_idx)) { 456 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 457 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 458 | } 459 | ::Font out; 460 | duk_get_prop_string(ctx, arg_idx, "baseSize"); 461 | out.baseSize = duk_get_int(ctx, -1); 462 | duk_get_prop_string(ctx, arg_idx, "glyphCount"); 463 | out.glyphCount = duk_get_int(ctx, -1); 464 | duk_get_prop_string(ctx, arg_idx, "glyphPadding"); 465 | out.glyphPadding = duk_get_int(ctx, -1); 466 | duk_get_prop_string(ctx, arg_idx, "texture"); 467 | out.texture = raylib_duktape_get(ctx, -1); 468 | duk_get_prop_string(ctx, arg_idx, "recs"); 469 | out.recs = (Rectangle *)duk_get_pointer(ctx, -1); 470 | duk_get_prop_string(ctx, arg_idx, "glyphs"); 471 | out.glyphs = (GlyphInfo *)duk_get_pointer(ctx, -1); 472 | return out; 473 | } 474 | template 475 | static void push(duk_context* ctx, ::Font value) { 476 | duk_idx_t obj_idx = duk_push_object(ctx); 477 | 478 | duk_push_int(ctx, value.baseSize); 479 | duk_put_prop_string(ctx, obj_idx, "baseSize"); 480 | duk_push_int(ctx, value.glyphCount); 481 | duk_put_prop_string(ctx, obj_idx, "glyphCount"); 482 | duk_push_int(ctx, value.glyphPadding); 483 | duk_put_prop_string(ctx, obj_idx, "glyphPadding"); 484 | raylib_duktape_push(ctx, value.texture); 485 | duk_put_prop_string(ctx, obj_idx, "texture"); 486 | duk_push_pointer(ctx, value.recs); 487 | duk_put_prop_string(ctx, obj_idx, "recs"); 488 | duk_push_pointer(ctx, value.glyphs); 489 | duk_put_prop_string(ctx, obj_idx, "glyphs"); 490 | } 491 | }; 492 | 493 | template<> 494 | struct DukType<::Camera3D> { 495 | typedef std::true_type IsValueType; 496 | template 497 | static ::Camera3D read(duk_context* ctx, duk_idx_t arg_idx) { 498 | if (!duk_is_object(ctx, arg_idx)) { 499 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 500 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 501 | } 502 | ::Camera3D out; 503 | duk_get_prop_string(ctx, arg_idx, "position"); 504 | out.position = raylib_duktape_get(ctx, -1); 505 | duk_get_prop_string(ctx, arg_idx, "target"); 506 | out.target = raylib_duktape_get(ctx, -1); 507 | duk_get_prop_string(ctx, arg_idx, "up"); 508 | out.up = raylib_duktape_get(ctx, -1); 509 | duk_get_prop_string(ctx, arg_idx, "fovy"); 510 | out.fovy = duk_get_number(ctx, -1); 511 | duk_get_prop_string(ctx, arg_idx, "projection"); 512 | out.projection = duk_get_int(ctx, -1); 513 | return out; 514 | } 515 | template 516 | static void push(duk_context* ctx, ::Camera3D value) { 517 | duk_idx_t obj_idx = duk_push_object(ctx); 518 | 519 | raylib_duktape_push(ctx, value.position); 520 | duk_put_prop_string(ctx, obj_idx, "position"); 521 | raylib_duktape_push(ctx, value.target); 522 | duk_put_prop_string(ctx, obj_idx, "target"); 523 | raylib_duktape_push(ctx, value.up); 524 | duk_put_prop_string(ctx, obj_idx, "up"); 525 | duk_push_number(ctx, value.fovy); 526 | duk_put_prop_string(ctx, obj_idx, "fovy"); 527 | duk_push_int(ctx, value.projection); 528 | duk_put_prop_string(ctx, obj_idx, "projection"); 529 | } 530 | }; 531 | 532 | template<> 533 | struct DukType<::Camera2D> { 534 | typedef std::true_type IsValueType; 535 | template 536 | static ::Camera2D read(duk_context* ctx, duk_idx_t arg_idx) { 537 | if (!duk_is_object(ctx, arg_idx)) { 538 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 539 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 540 | } 541 | ::Camera2D out; 542 | duk_get_prop_string(ctx, arg_idx, "offset"); 543 | out.offset = raylib_duktape_get(ctx, -1); 544 | duk_get_prop_string(ctx, arg_idx, "target"); 545 | out.target = raylib_duktape_get(ctx, -1); 546 | duk_get_prop_string(ctx, arg_idx, "rotation"); 547 | out.rotation = duk_get_number(ctx, -1); 548 | duk_get_prop_string(ctx, arg_idx, "zoom"); 549 | out.zoom = duk_get_number(ctx, -1); 550 | return out; 551 | } 552 | template 553 | static void push(duk_context* ctx, ::Camera2D value) { 554 | duk_idx_t obj_idx = duk_push_object(ctx); 555 | 556 | raylib_duktape_push(ctx, value.offset); 557 | duk_put_prop_string(ctx, obj_idx, "offset"); 558 | raylib_duktape_push(ctx, value.target); 559 | duk_put_prop_string(ctx, obj_idx, "target"); 560 | duk_push_number(ctx, value.rotation); 561 | duk_put_prop_string(ctx, obj_idx, "rotation"); 562 | duk_push_number(ctx, value.zoom); 563 | duk_put_prop_string(ctx, obj_idx, "zoom"); 564 | } 565 | }; 566 | 567 | template<> 568 | struct DukType<::Mesh> { 569 | typedef std::true_type IsValueType; 570 | template 571 | static ::Mesh read(duk_context* ctx, duk_idx_t arg_idx) { 572 | if (!duk_is_object(ctx, arg_idx)) { 573 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 574 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 575 | } 576 | ::Mesh out; 577 | duk_get_prop_string(ctx, arg_idx, "vertexCount"); 578 | out.vertexCount = duk_get_int(ctx, -1); 579 | duk_get_prop_string(ctx, arg_idx, "triangleCount"); 580 | out.triangleCount = duk_get_int(ctx, -1); 581 | duk_get_prop_string(ctx, arg_idx, "vertices"); 582 | out.vertices = (float *)duk_get_pointer(ctx, -1); 583 | duk_get_prop_string(ctx, arg_idx, "texcoords"); 584 | out.texcoords = (float *)duk_get_pointer(ctx, -1); 585 | duk_get_prop_string(ctx, arg_idx, "texcoords2"); 586 | out.texcoords2 = (float *)duk_get_pointer(ctx, -1); 587 | duk_get_prop_string(ctx, arg_idx, "normals"); 588 | out.normals = (float *)duk_get_pointer(ctx, -1); 589 | duk_get_prop_string(ctx, arg_idx, "tangents"); 590 | out.tangents = (float *)duk_get_pointer(ctx, -1); 591 | duk_get_prop_string(ctx, arg_idx, "colors"); 592 | out.colors = (unsigned char *)duk_get_pointer(ctx, -1); 593 | duk_get_prop_string(ctx, arg_idx, "indices"); 594 | out.indices = (unsigned short *)duk_get_pointer(ctx, -1); 595 | duk_get_prop_string(ctx, arg_idx, "animVertices"); 596 | out.animVertices = (float *)duk_get_pointer(ctx, -1); 597 | duk_get_prop_string(ctx, arg_idx, "animNormals"); 598 | out.animNormals = (float *)duk_get_pointer(ctx, -1); 599 | duk_get_prop_string(ctx, arg_idx, "boneIds"); 600 | out.boneIds = (unsigned char *)duk_get_pointer(ctx, -1); 601 | duk_get_prop_string(ctx, arg_idx, "boneWeights"); 602 | out.boneWeights = (float *)duk_get_pointer(ctx, -1); 603 | duk_get_prop_string(ctx, arg_idx, "vaoId"); 604 | out.vaoId = duk_get_uint(ctx, -1); 605 | duk_get_prop_string(ctx, arg_idx, "vboId"); 606 | out.vboId = (unsigned int *)duk_get_pointer(ctx, -1); 607 | return out; 608 | } 609 | template 610 | static void push(duk_context* ctx, ::Mesh value) { 611 | duk_idx_t obj_idx = duk_push_object(ctx); 612 | 613 | duk_push_int(ctx, value.vertexCount); 614 | duk_put_prop_string(ctx, obj_idx, "vertexCount"); 615 | duk_push_int(ctx, value.triangleCount); 616 | duk_put_prop_string(ctx, obj_idx, "triangleCount"); 617 | duk_push_pointer(ctx, value.vertices); 618 | duk_put_prop_string(ctx, obj_idx, "vertices"); 619 | duk_push_pointer(ctx, value.texcoords); 620 | duk_put_prop_string(ctx, obj_idx, "texcoords"); 621 | duk_push_pointer(ctx, value.texcoords2); 622 | duk_put_prop_string(ctx, obj_idx, "texcoords2"); 623 | duk_push_pointer(ctx, value.normals); 624 | duk_put_prop_string(ctx, obj_idx, "normals"); 625 | duk_push_pointer(ctx, value.tangents); 626 | duk_put_prop_string(ctx, obj_idx, "tangents"); 627 | duk_push_pointer(ctx, value.colors); 628 | duk_put_prop_string(ctx, obj_idx, "colors"); 629 | duk_push_pointer(ctx, value.indices); 630 | duk_put_prop_string(ctx, obj_idx, "indices"); 631 | duk_push_pointer(ctx, value.animVertices); 632 | duk_put_prop_string(ctx, obj_idx, "animVertices"); 633 | duk_push_pointer(ctx, value.animNormals); 634 | duk_put_prop_string(ctx, obj_idx, "animNormals"); 635 | duk_push_pointer(ctx, value.boneIds); 636 | duk_put_prop_string(ctx, obj_idx, "boneIds"); 637 | duk_push_pointer(ctx, value.boneWeights); 638 | duk_put_prop_string(ctx, obj_idx, "boneWeights"); 639 | duk_push_uint(ctx, value.vaoId); 640 | duk_put_prop_string(ctx, obj_idx, "vaoId"); 641 | duk_push_pointer(ctx, value.vboId); 642 | duk_put_prop_string(ctx, obj_idx, "vboId"); 643 | } 644 | }; 645 | 646 | template<> 647 | struct DukType<::Shader> { 648 | typedef std::true_type IsValueType; 649 | template 650 | static ::Shader read(duk_context* ctx, duk_idx_t arg_idx) { 651 | if (!duk_is_object(ctx, arg_idx)) { 652 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 653 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 654 | } 655 | ::Shader out; 656 | duk_get_prop_string(ctx, arg_idx, "id"); 657 | out.id = duk_get_uint(ctx, -1); 658 | duk_get_prop_string(ctx, arg_idx, "locs"); 659 | out.locs = (int *)duk_get_pointer(ctx, -1); 660 | return out; 661 | } 662 | template 663 | static void push(duk_context* ctx, ::Shader value) { 664 | duk_idx_t obj_idx = duk_push_object(ctx); 665 | 666 | duk_push_uint(ctx, value.id); 667 | duk_put_prop_string(ctx, obj_idx, "id"); 668 | duk_push_pointer(ctx, value.locs); 669 | duk_put_prop_string(ctx, obj_idx, "locs"); 670 | } 671 | }; 672 | 673 | template<> 674 | struct DukType<::MaterialMap> { 675 | typedef std::true_type IsValueType; 676 | template 677 | static ::MaterialMap read(duk_context* ctx, duk_idx_t arg_idx) { 678 | if (!duk_is_object(ctx, arg_idx)) { 679 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 680 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 681 | } 682 | ::MaterialMap out; 683 | duk_get_prop_string(ctx, arg_idx, "texture"); 684 | out.texture = raylib_duktape_get(ctx, -1); 685 | duk_get_prop_string(ctx, arg_idx, "color"); 686 | out.color = raylib_duktape_get(ctx, -1); 687 | duk_get_prop_string(ctx, arg_idx, "value"); 688 | out.value = duk_get_number(ctx, -1); 689 | return out; 690 | } 691 | template 692 | static void push(duk_context* ctx, ::MaterialMap value) { 693 | duk_idx_t obj_idx = duk_push_object(ctx); 694 | 695 | raylib_duktape_push(ctx, value.texture); 696 | duk_put_prop_string(ctx, obj_idx, "texture"); 697 | raylib_duktape_push(ctx, value.color); 698 | duk_put_prop_string(ctx, obj_idx, "color"); 699 | duk_push_number(ctx, value.value); 700 | duk_put_prop_string(ctx, obj_idx, "value"); 701 | } 702 | }; 703 | 704 | template<> 705 | struct DukType<::Material> { 706 | typedef std::true_type IsValueType; 707 | template 708 | static ::Material read(duk_context* ctx, duk_idx_t arg_idx) { 709 | if (!duk_is_object(ctx, arg_idx)) { 710 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 711 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 712 | } 713 | ::Material out; 714 | duk_get_prop_string(ctx, arg_idx, "shader"); 715 | out.shader = raylib_duktape_get(ctx, -1); 716 | duk_get_prop_string(ctx, arg_idx, "maps"); 717 | out.maps = (MaterialMap *)duk_get_pointer(ctx, -1); 718 | // Skipped: params 719 | return out; 720 | } 721 | template 722 | static void push(duk_context* ctx, ::Material value) { 723 | duk_idx_t obj_idx = duk_push_object(ctx); 724 | 725 | raylib_duktape_push(ctx, value.shader); 726 | duk_put_prop_string(ctx, obj_idx, "shader"); 727 | duk_push_pointer(ctx, value.maps); 728 | duk_put_prop_string(ctx, obj_idx, "maps"); 729 | // Skipped: params 730 | } 731 | }; 732 | 733 | template<> 734 | struct DukType<::Transform> { 735 | typedef std::true_type IsValueType; 736 | template 737 | static ::Transform read(duk_context* ctx, duk_idx_t arg_idx) { 738 | if (!duk_is_object(ctx, arg_idx)) { 739 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 740 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 741 | } 742 | ::Transform out; 743 | duk_get_prop_string(ctx, arg_idx, "translation"); 744 | out.translation = raylib_duktape_get(ctx, -1); 745 | duk_get_prop_string(ctx, arg_idx, "rotation"); 746 | out.rotation = raylib_duktape_get(ctx, -1); 747 | duk_get_prop_string(ctx, arg_idx, "scale"); 748 | out.scale = raylib_duktape_get(ctx, -1); 749 | return out; 750 | } 751 | template 752 | static void push(duk_context* ctx, ::Transform value) { 753 | duk_idx_t obj_idx = duk_push_object(ctx); 754 | 755 | raylib_duktape_push(ctx, value.translation); 756 | duk_put_prop_string(ctx, obj_idx, "translation"); 757 | raylib_duktape_push(ctx, value.rotation); 758 | duk_put_prop_string(ctx, obj_idx, "rotation"); 759 | raylib_duktape_push(ctx, value.scale); 760 | duk_put_prop_string(ctx, obj_idx, "scale"); 761 | } 762 | }; 763 | 764 | template<> 765 | struct DukType<::BoneInfo> { 766 | typedef std::true_type IsValueType; 767 | template 768 | static ::BoneInfo read(duk_context* ctx, duk_idx_t arg_idx) { 769 | if (!duk_is_object(ctx, arg_idx)) { 770 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 771 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 772 | } 773 | ::BoneInfo out; 774 | duk_get_prop_string(ctx, arg_idx, "name"); 775 | out.name = duk_get_string(ctx, -1); 776 | duk_get_prop_string(ctx, arg_idx, "parent"); 777 | out.parent = duk_get_int(ctx, -1); 778 | return out; 779 | } 780 | template 781 | static void push(duk_context* ctx, ::BoneInfo value) { 782 | duk_idx_t obj_idx = duk_push_object(ctx); 783 | 784 | duk_push_string(ctx, value.name); 785 | duk_put_prop_string(ctx, obj_idx, "name"); 786 | duk_push_int(ctx, value.parent); 787 | duk_put_prop_string(ctx, obj_idx, "parent"); 788 | } 789 | }; 790 | 791 | template<> 792 | struct DukType<::Model> { 793 | typedef std::true_type IsValueType; 794 | template 795 | static ::Model read(duk_context* ctx, duk_idx_t arg_idx) { 796 | if (!duk_is_object(ctx, arg_idx)) { 797 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 798 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 799 | } 800 | ::Model out; 801 | duk_get_prop_string(ctx, arg_idx, "transform"); 802 | out.transform = raylib_duktape_get(ctx, -1); 803 | duk_get_prop_string(ctx, arg_idx, "meshCount"); 804 | out.meshCount = duk_get_int(ctx, -1); 805 | duk_get_prop_string(ctx, arg_idx, "materialCount"); 806 | out.materialCount = duk_get_int(ctx, -1); 807 | duk_get_prop_string(ctx, arg_idx, "meshes"); 808 | out.meshes = (Mesh *)duk_get_pointer(ctx, -1); 809 | duk_get_prop_string(ctx, arg_idx, "materials"); 810 | out.materials = (Material *)duk_get_pointer(ctx, -1); 811 | duk_get_prop_string(ctx, arg_idx, "meshMaterial"); 812 | out.meshMaterial = (int *)duk_get_pointer(ctx, -1); 813 | duk_get_prop_string(ctx, arg_idx, "boneCount"); 814 | out.boneCount = duk_get_int(ctx, -1); 815 | duk_get_prop_string(ctx, arg_idx, "bones"); 816 | out.bones = (BoneInfo *)duk_get_pointer(ctx, -1); 817 | duk_get_prop_string(ctx, arg_idx, "bindPose"); 818 | out.bindPose = (Transform *)duk_get_pointer(ctx, -1); 819 | return out; 820 | } 821 | template 822 | static void push(duk_context* ctx, ::Model value) { 823 | duk_idx_t obj_idx = duk_push_object(ctx); 824 | 825 | raylib_duktape_push(ctx, value.transform); 826 | duk_put_prop_string(ctx, obj_idx, "transform"); 827 | duk_push_int(ctx, value.meshCount); 828 | duk_put_prop_string(ctx, obj_idx, "meshCount"); 829 | duk_push_int(ctx, value.materialCount); 830 | duk_put_prop_string(ctx, obj_idx, "materialCount"); 831 | duk_push_pointer(ctx, value.meshes); 832 | duk_put_prop_string(ctx, obj_idx, "meshes"); 833 | duk_push_pointer(ctx, value.materials); 834 | duk_put_prop_string(ctx, obj_idx, "materials"); 835 | duk_push_pointer(ctx, value.meshMaterial); 836 | duk_put_prop_string(ctx, obj_idx, "meshMaterial"); 837 | duk_push_int(ctx, value.boneCount); 838 | duk_put_prop_string(ctx, obj_idx, "boneCount"); 839 | duk_push_pointer(ctx, value.bones); 840 | duk_put_prop_string(ctx, obj_idx, "bones"); 841 | duk_push_pointer(ctx, value.bindPose); 842 | duk_put_prop_string(ctx, obj_idx, "bindPose"); 843 | } 844 | }; 845 | 846 | template<> 847 | struct DukType<::ModelAnimation> { 848 | typedef std::true_type IsValueType; 849 | template 850 | static ::ModelAnimation read(duk_context* ctx, duk_idx_t arg_idx) { 851 | if (!duk_is_object(ctx, arg_idx)) { 852 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 853 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 854 | } 855 | ::ModelAnimation out; 856 | duk_get_prop_string(ctx, arg_idx, "boneCount"); 857 | out.boneCount = duk_get_int(ctx, -1); 858 | duk_get_prop_string(ctx, arg_idx, "frameCount"); 859 | out.frameCount = duk_get_int(ctx, -1); 860 | duk_get_prop_string(ctx, arg_idx, "bones"); 861 | out.bones = (BoneInfo *)duk_get_pointer(ctx, -1); 862 | duk_get_prop_string(ctx, arg_idx, "framePoses"); 863 | out.framePoses = (Transform**)duk_get_pointer(ctx, -1); 864 | return out; 865 | } 866 | template 867 | static void push(duk_context* ctx, ::ModelAnimation value) { 868 | duk_idx_t obj_idx = duk_push_object(ctx); 869 | 870 | duk_push_int(ctx, value.boneCount); 871 | duk_put_prop_string(ctx, obj_idx, "boneCount"); 872 | duk_push_int(ctx, value.frameCount); 873 | duk_put_prop_string(ctx, obj_idx, "frameCount"); 874 | duk_push_pointer(ctx, value.bones); 875 | duk_put_prop_string(ctx, obj_idx, "bones"); 876 | duk_push_pointer(ctx, value.framePoses); 877 | duk_put_prop_string(ctx, obj_idx, "framePoses"); 878 | } 879 | }; 880 | 881 | template<> 882 | struct DukType<::Ray> { 883 | typedef std::true_type IsValueType; 884 | template 885 | static ::Ray read(duk_context* ctx, duk_idx_t arg_idx) { 886 | if (!duk_is_object(ctx, arg_idx)) { 887 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 888 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 889 | } 890 | ::Ray out; 891 | duk_get_prop_string(ctx, arg_idx, "position"); 892 | out.position = raylib_duktape_get(ctx, -1); 893 | duk_get_prop_string(ctx, arg_idx, "direction"); 894 | out.direction = raylib_duktape_get(ctx, -1); 895 | return out; 896 | } 897 | template 898 | static void push(duk_context* ctx, ::Ray value) { 899 | duk_idx_t obj_idx = duk_push_object(ctx); 900 | 901 | raylib_duktape_push(ctx, value.position); 902 | duk_put_prop_string(ctx, obj_idx, "position"); 903 | raylib_duktape_push(ctx, value.direction); 904 | duk_put_prop_string(ctx, obj_idx, "direction"); 905 | } 906 | }; 907 | 908 | template<> 909 | struct DukType<::RayCollision> { 910 | typedef std::true_type IsValueType; 911 | template 912 | static ::RayCollision read(duk_context* ctx, duk_idx_t arg_idx) { 913 | if (!duk_is_object(ctx, arg_idx)) { 914 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 915 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 916 | } 917 | ::RayCollision out; 918 | duk_get_prop_string(ctx, arg_idx, "hit"); 919 | out.hit = duk_get_boolean(ctx, -1); 920 | duk_get_prop_string(ctx, arg_idx, "distance"); 921 | out.distance = duk_get_number(ctx, -1); 922 | duk_get_prop_string(ctx, arg_idx, "point"); 923 | out.point = raylib_duktape_get(ctx, -1); 924 | duk_get_prop_string(ctx, arg_idx, "normal"); 925 | out.normal = raylib_duktape_get(ctx, -1); 926 | return out; 927 | } 928 | template 929 | static void push(duk_context* ctx, ::RayCollision value) { 930 | duk_idx_t obj_idx = duk_push_object(ctx); 931 | 932 | duk_push_boolean(ctx, value.hit); 933 | duk_put_prop_string(ctx, obj_idx, "hit"); 934 | duk_push_number(ctx, value.distance); 935 | duk_put_prop_string(ctx, obj_idx, "distance"); 936 | raylib_duktape_push(ctx, value.point); 937 | duk_put_prop_string(ctx, obj_idx, "point"); 938 | raylib_duktape_push(ctx, value.normal); 939 | duk_put_prop_string(ctx, obj_idx, "normal"); 940 | } 941 | }; 942 | 943 | template<> 944 | struct DukType<::BoundingBox> { 945 | typedef std::true_type IsValueType; 946 | template 947 | static ::BoundingBox read(duk_context* ctx, duk_idx_t arg_idx) { 948 | if (!duk_is_object(ctx, arg_idx)) { 949 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 950 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 951 | } 952 | ::BoundingBox out; 953 | duk_get_prop_string(ctx, arg_idx, "min"); 954 | out.min = raylib_duktape_get(ctx, -1); 955 | duk_get_prop_string(ctx, arg_idx, "max"); 956 | out.max = raylib_duktape_get(ctx, -1); 957 | return out; 958 | } 959 | template 960 | static void push(duk_context* ctx, ::BoundingBox value) { 961 | duk_idx_t obj_idx = duk_push_object(ctx); 962 | 963 | raylib_duktape_push(ctx, value.min); 964 | duk_put_prop_string(ctx, obj_idx, "min"); 965 | raylib_duktape_push(ctx, value.max); 966 | duk_put_prop_string(ctx, obj_idx, "max"); 967 | } 968 | }; 969 | 970 | template<> 971 | struct DukType<::Wave> { 972 | typedef std::true_type IsValueType; 973 | template 974 | static ::Wave read(duk_context* ctx, duk_idx_t arg_idx) { 975 | if (!duk_is_object(ctx, arg_idx)) { 976 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 977 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 978 | } 979 | ::Wave out; 980 | duk_get_prop_string(ctx, arg_idx, "frameCount"); 981 | out.frameCount = duk_get_uint(ctx, -1); 982 | duk_get_prop_string(ctx, arg_idx, "sampleRate"); 983 | out.sampleRate = duk_get_uint(ctx, -1); 984 | duk_get_prop_string(ctx, arg_idx, "sampleSize"); 985 | out.sampleSize = duk_get_uint(ctx, -1); 986 | duk_get_prop_string(ctx, arg_idx, "channels"); 987 | out.channels = duk_get_uint(ctx, -1); 988 | duk_get_prop_string(ctx, arg_idx, "data"); 989 | out.data = (void *)duk_get_pointer(ctx, -1); 990 | return out; 991 | } 992 | template 993 | static void push(duk_context* ctx, ::Wave value) { 994 | duk_idx_t obj_idx = duk_push_object(ctx); 995 | 996 | duk_push_uint(ctx, value.frameCount); 997 | duk_put_prop_string(ctx, obj_idx, "frameCount"); 998 | duk_push_uint(ctx, value.sampleRate); 999 | duk_put_prop_string(ctx, obj_idx, "sampleRate"); 1000 | duk_push_uint(ctx, value.sampleSize); 1001 | duk_put_prop_string(ctx, obj_idx, "sampleSize"); 1002 | duk_push_uint(ctx, value.channels); 1003 | duk_put_prop_string(ctx, obj_idx, "channels"); 1004 | duk_push_pointer(ctx, value.data); 1005 | duk_put_prop_string(ctx, obj_idx, "data"); 1006 | } 1007 | }; 1008 | 1009 | template<> 1010 | struct DukType<::AudioStream> { 1011 | typedef std::true_type IsValueType; 1012 | template 1013 | static ::AudioStream read(duk_context* ctx, duk_idx_t arg_idx) { 1014 | if (!duk_is_object(ctx, arg_idx)) { 1015 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1016 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1017 | } 1018 | ::AudioStream out; 1019 | duk_get_prop_string(ctx, arg_idx, "buffer"); 1020 | out.buffer = (rAudioBuffer *)duk_get_pointer(ctx, -1); 1021 | duk_get_prop_string(ctx, arg_idx, "processor"); 1022 | out.processor = (rAudioProcessor *)duk_get_pointer(ctx, -1); 1023 | duk_get_prop_string(ctx, arg_idx, "sampleRate"); 1024 | out.sampleRate = duk_get_uint(ctx, -1); 1025 | duk_get_prop_string(ctx, arg_idx, "sampleSize"); 1026 | out.sampleSize = duk_get_uint(ctx, -1); 1027 | duk_get_prop_string(ctx, arg_idx, "channels"); 1028 | out.channels = duk_get_uint(ctx, -1); 1029 | return out; 1030 | } 1031 | template 1032 | static void push(duk_context* ctx, ::AudioStream value) { 1033 | duk_idx_t obj_idx = duk_push_object(ctx); 1034 | 1035 | duk_push_pointer(ctx, value.buffer); 1036 | duk_put_prop_string(ctx, obj_idx, "buffer"); 1037 | duk_push_pointer(ctx, value.processor); 1038 | duk_put_prop_string(ctx, obj_idx, "processor"); 1039 | duk_push_uint(ctx, value.sampleRate); 1040 | duk_put_prop_string(ctx, obj_idx, "sampleRate"); 1041 | duk_push_uint(ctx, value.sampleSize); 1042 | duk_put_prop_string(ctx, obj_idx, "sampleSize"); 1043 | duk_push_uint(ctx, value.channels); 1044 | duk_put_prop_string(ctx, obj_idx, "channels"); 1045 | } 1046 | }; 1047 | 1048 | template<> 1049 | struct DukType<::Sound> { 1050 | typedef std::true_type IsValueType; 1051 | template 1052 | static ::Sound read(duk_context* ctx, duk_idx_t arg_idx) { 1053 | if (!duk_is_object(ctx, arg_idx)) { 1054 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1055 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1056 | } 1057 | ::Sound out; 1058 | duk_get_prop_string(ctx, arg_idx, "stream"); 1059 | out.stream = raylib_duktape_get(ctx, -1); 1060 | duk_get_prop_string(ctx, arg_idx, "frameCount"); 1061 | out.frameCount = duk_get_uint(ctx, -1); 1062 | return out; 1063 | } 1064 | template 1065 | static void push(duk_context* ctx, ::Sound value) { 1066 | duk_idx_t obj_idx = duk_push_object(ctx); 1067 | 1068 | raylib_duktape_push(ctx, value.stream); 1069 | duk_put_prop_string(ctx, obj_idx, "stream"); 1070 | duk_push_uint(ctx, value.frameCount); 1071 | duk_put_prop_string(ctx, obj_idx, "frameCount"); 1072 | } 1073 | }; 1074 | 1075 | template<> 1076 | struct DukType<::Music> { 1077 | typedef std::true_type IsValueType; 1078 | template 1079 | static ::Music read(duk_context* ctx, duk_idx_t arg_idx) { 1080 | if (!duk_is_object(ctx, arg_idx)) { 1081 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1082 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1083 | } 1084 | ::Music out; 1085 | duk_get_prop_string(ctx, arg_idx, "stream"); 1086 | out.stream = raylib_duktape_get(ctx, -1); 1087 | duk_get_prop_string(ctx, arg_idx, "frameCount"); 1088 | out.frameCount = duk_get_uint(ctx, -1); 1089 | duk_get_prop_string(ctx, arg_idx, "looping"); 1090 | out.looping = duk_get_boolean(ctx, -1); 1091 | duk_get_prop_string(ctx, arg_idx, "ctxType"); 1092 | out.ctxType = duk_get_int(ctx, -1); 1093 | duk_get_prop_string(ctx, arg_idx, "ctxData"); 1094 | out.ctxData = (void *)duk_get_pointer(ctx, -1); 1095 | return out; 1096 | } 1097 | template 1098 | static void push(duk_context* ctx, ::Music value) { 1099 | duk_idx_t obj_idx = duk_push_object(ctx); 1100 | 1101 | raylib_duktape_push(ctx, value.stream); 1102 | duk_put_prop_string(ctx, obj_idx, "stream"); 1103 | duk_push_uint(ctx, value.frameCount); 1104 | duk_put_prop_string(ctx, obj_idx, "frameCount"); 1105 | duk_push_boolean(ctx, value.looping); 1106 | duk_put_prop_string(ctx, obj_idx, "looping"); 1107 | duk_push_int(ctx, value.ctxType); 1108 | duk_put_prop_string(ctx, obj_idx, "ctxType"); 1109 | duk_push_pointer(ctx, value.ctxData); 1110 | duk_put_prop_string(ctx, obj_idx, "ctxData"); 1111 | } 1112 | }; 1113 | 1114 | template<> 1115 | struct DukType<::VrDeviceInfo> { 1116 | typedef std::true_type IsValueType; 1117 | template 1118 | static ::VrDeviceInfo read(duk_context* ctx, duk_idx_t arg_idx) { 1119 | if (!duk_is_object(ctx, arg_idx)) { 1120 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1121 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1122 | } 1123 | ::VrDeviceInfo out; 1124 | duk_get_prop_string(ctx, arg_idx, "hResolution"); 1125 | out.hResolution = duk_get_int(ctx, -1); 1126 | duk_get_prop_string(ctx, arg_idx, "vResolution"); 1127 | out.vResolution = duk_get_int(ctx, -1); 1128 | duk_get_prop_string(ctx, arg_idx, "hScreenSize"); 1129 | out.hScreenSize = duk_get_number(ctx, -1); 1130 | duk_get_prop_string(ctx, arg_idx, "vScreenSize"); 1131 | out.vScreenSize = duk_get_number(ctx, -1); 1132 | duk_get_prop_string(ctx, arg_idx, "vScreenCenter"); 1133 | out.vScreenCenter = duk_get_number(ctx, -1); 1134 | duk_get_prop_string(ctx, arg_idx, "eyeToScreenDistance"); 1135 | out.eyeToScreenDistance = duk_get_number(ctx, -1); 1136 | duk_get_prop_string(ctx, arg_idx, "lensSeparationDistance"); 1137 | out.lensSeparationDistance = duk_get_number(ctx, -1); 1138 | duk_get_prop_string(ctx, arg_idx, "interpupillaryDistance"); 1139 | out.interpupillaryDistance = duk_get_number(ctx, -1); 1140 | // Skipped: lensDistortionValues 1141 | // Skipped: chromaAbCorrection 1142 | return out; 1143 | } 1144 | template 1145 | static void push(duk_context* ctx, ::VrDeviceInfo value) { 1146 | duk_idx_t obj_idx = duk_push_object(ctx); 1147 | 1148 | duk_push_int(ctx, value.hResolution); 1149 | duk_put_prop_string(ctx, obj_idx, "hResolution"); 1150 | duk_push_int(ctx, value.vResolution); 1151 | duk_put_prop_string(ctx, obj_idx, "vResolution"); 1152 | duk_push_number(ctx, value.hScreenSize); 1153 | duk_put_prop_string(ctx, obj_idx, "hScreenSize"); 1154 | duk_push_number(ctx, value.vScreenSize); 1155 | duk_put_prop_string(ctx, obj_idx, "vScreenSize"); 1156 | duk_push_number(ctx, value.vScreenCenter); 1157 | duk_put_prop_string(ctx, obj_idx, "vScreenCenter"); 1158 | duk_push_number(ctx, value.eyeToScreenDistance); 1159 | duk_put_prop_string(ctx, obj_idx, "eyeToScreenDistance"); 1160 | duk_push_number(ctx, value.lensSeparationDistance); 1161 | duk_put_prop_string(ctx, obj_idx, "lensSeparationDistance"); 1162 | duk_push_number(ctx, value.interpupillaryDistance); 1163 | duk_put_prop_string(ctx, obj_idx, "interpupillaryDistance"); 1164 | // Skipped: lensDistortionValues 1165 | // Skipped: chromaAbCorrection 1166 | } 1167 | }; 1168 | 1169 | template<> 1170 | struct DukType<::VrStereoConfig> { 1171 | typedef std::true_type IsValueType; 1172 | template 1173 | static ::VrStereoConfig read(duk_context* ctx, duk_idx_t arg_idx) { 1174 | if (!duk_is_object(ctx, arg_idx)) { 1175 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1176 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1177 | } 1178 | ::VrStereoConfig out; 1179 | // Skipped: projection 1180 | // Skipped: viewOffset 1181 | // Skipped: leftLensCenter 1182 | // Skipped: rightLensCenter 1183 | // Skipped: leftScreenCenter 1184 | // Skipped: rightScreenCenter 1185 | // Skipped: scale 1186 | // Skipped: scaleIn 1187 | return out; 1188 | } 1189 | template 1190 | static void push(duk_context* ctx, ::VrStereoConfig value) { 1191 | duk_idx_t obj_idx = duk_push_object(ctx); 1192 | 1193 | // Skipped: projection 1194 | // Skipped: viewOffset 1195 | // Skipped: leftLensCenter 1196 | // Skipped: rightLensCenter 1197 | // Skipped: leftScreenCenter 1198 | // Skipped: rightScreenCenter 1199 | // Skipped: scale 1200 | // Skipped: scaleIn 1201 | } 1202 | }; 1203 | 1204 | template<> 1205 | struct DukType<::FilePathList> { 1206 | typedef std::true_type IsValueType; 1207 | template 1208 | static ::FilePathList read(duk_context* ctx, duk_idx_t arg_idx) { 1209 | if (!duk_is_object(ctx, arg_idx)) { 1210 | duk_int_t type_idx = duk_get_type(ctx, arg_idx); 1211 | duk_error(ctx, DUK_ERR_TYPE_ERROR, "Argument %d: expected object, got %s", arg_idx, detail::get_type_name(type_idx)); 1212 | } 1213 | ::FilePathList out; 1214 | duk_get_prop_string(ctx, arg_idx, "capacity"); 1215 | out.capacity = duk_get_uint(ctx, -1); 1216 | duk_get_prop_string(ctx, arg_idx, "count"); 1217 | out.count = duk_get_uint(ctx, -1); 1218 | duk_get_prop_string(ctx, arg_idx, "paths"); 1219 | out.paths = (char**)duk_get_pointer(ctx, -1); 1220 | return out; 1221 | } 1222 | template 1223 | static void push(duk_context* ctx, ::FilePathList value) { 1224 | duk_idx_t obj_idx = duk_push_object(ctx); 1225 | 1226 | duk_push_uint(ctx, value.capacity); 1227 | duk_put_prop_string(ctx, obj_idx, "capacity"); 1228 | duk_push_uint(ctx, value.count); 1229 | duk_put_prop_string(ctx, obj_idx, "count"); 1230 | duk_push_pointer(ctx, value.paths); 1231 | duk_put_prop_string(ctx, obj_idx, "paths"); 1232 | } 1233 | }; 1234 | }} 1235 | void raylib_duktape_gen(duk_context* ctx) { 1236 | // ConfigFlags 1237 | dukglue_register_global(ctx, (int)FLAG_VSYNC_HINT, "FLAG_VSYNC_HINT"); 1238 | dukglue_register_global(ctx, (int)FLAG_FULLSCREEN_MODE, "FLAG_FULLSCREEN_MODE"); 1239 | dukglue_register_global(ctx, (int)FLAG_WINDOW_RESIZABLE, "FLAG_WINDOW_RESIZABLE"); 1240 | dukglue_register_global(ctx, (int)FLAG_WINDOW_UNDECORATED, "FLAG_WINDOW_UNDECORATED"); 1241 | dukglue_register_global(ctx, (int)FLAG_WINDOW_HIDDEN, "FLAG_WINDOW_HIDDEN"); 1242 | dukglue_register_global(ctx, (int)FLAG_WINDOW_MINIMIZED, "FLAG_WINDOW_MINIMIZED"); 1243 | dukglue_register_global(ctx, (int)FLAG_WINDOW_MAXIMIZED, "FLAG_WINDOW_MAXIMIZED"); 1244 | dukglue_register_global(ctx, (int)FLAG_WINDOW_UNFOCUSED, "FLAG_WINDOW_UNFOCUSED"); 1245 | dukglue_register_global(ctx, (int)FLAG_WINDOW_TOPMOST, "FLAG_WINDOW_TOPMOST"); 1246 | dukglue_register_global(ctx, (int)FLAG_WINDOW_ALWAYS_RUN, "FLAG_WINDOW_ALWAYS_RUN"); 1247 | dukglue_register_global(ctx, (int)FLAG_WINDOW_TRANSPARENT, "FLAG_WINDOW_TRANSPARENT"); 1248 | dukglue_register_global(ctx, (int)FLAG_WINDOW_HIGHDPI, "FLAG_WINDOW_HIGHDPI"); 1249 | dukglue_register_global(ctx, (int)FLAG_WINDOW_MOUSE_PASSTHROUGH, "FLAG_WINDOW_MOUSE_PASSTHROUGH"); 1250 | dukglue_register_global(ctx, (int)FLAG_MSAA_4X_HINT, "FLAG_MSAA_4X_HINT"); 1251 | dukglue_register_global(ctx, (int)FLAG_INTERLACED_HINT, "FLAG_INTERLACED_HINT"); 1252 | 1253 | // TraceLogLevel 1254 | dukglue_register_global(ctx, (int)LOG_ALL, "LOG_ALL"); 1255 | dukglue_register_global(ctx, (int)LOG_TRACE, "LOG_TRACE"); 1256 | dukglue_register_global(ctx, (int)LOG_DEBUG, "LOG_DEBUG"); 1257 | dukglue_register_global(ctx, (int)LOG_INFO, "LOG_INFO"); 1258 | dukglue_register_global(ctx, (int)LOG_WARNING, "LOG_WARNING"); 1259 | dukglue_register_global(ctx, (int)LOG_ERROR, "LOG_ERROR"); 1260 | dukglue_register_global(ctx, (int)LOG_FATAL, "LOG_FATAL"); 1261 | dukglue_register_global(ctx, (int)LOG_NONE, "LOG_NONE"); 1262 | 1263 | // KeyboardKey 1264 | dukglue_register_global(ctx, (int)KEY_NULL, "KEY_NULL"); 1265 | dukglue_register_global(ctx, (int)KEY_APOSTROPHE, "KEY_APOSTROPHE"); 1266 | dukglue_register_global(ctx, (int)KEY_COMMA, "KEY_COMMA"); 1267 | dukglue_register_global(ctx, (int)KEY_MINUS, "KEY_MINUS"); 1268 | dukglue_register_global(ctx, (int)KEY_PERIOD, "KEY_PERIOD"); 1269 | dukglue_register_global(ctx, (int)KEY_SLASH, "KEY_SLASH"); 1270 | dukglue_register_global(ctx, (int)KEY_ZERO, "KEY_ZERO"); 1271 | dukglue_register_global(ctx, (int)KEY_ONE, "KEY_ONE"); 1272 | dukglue_register_global(ctx, (int)KEY_TWO, "KEY_TWO"); 1273 | dukglue_register_global(ctx, (int)KEY_THREE, "KEY_THREE"); 1274 | dukglue_register_global(ctx, (int)KEY_FOUR, "KEY_FOUR"); 1275 | dukglue_register_global(ctx, (int)KEY_FIVE, "KEY_FIVE"); 1276 | dukglue_register_global(ctx, (int)KEY_SIX, "KEY_SIX"); 1277 | dukglue_register_global(ctx, (int)KEY_SEVEN, "KEY_SEVEN"); 1278 | dukglue_register_global(ctx, (int)KEY_EIGHT, "KEY_EIGHT"); 1279 | dukglue_register_global(ctx, (int)KEY_NINE, "KEY_NINE"); 1280 | dukglue_register_global(ctx, (int)KEY_SEMICOLON, "KEY_SEMICOLON"); 1281 | dukglue_register_global(ctx, (int)KEY_EQUAL, "KEY_EQUAL"); 1282 | dukglue_register_global(ctx, (int)KEY_A, "KEY_A"); 1283 | dukglue_register_global(ctx, (int)KEY_B, "KEY_B"); 1284 | dukglue_register_global(ctx, (int)KEY_C, "KEY_C"); 1285 | dukglue_register_global(ctx, (int)KEY_D, "KEY_D"); 1286 | dukglue_register_global(ctx, (int)KEY_E, "KEY_E"); 1287 | dukglue_register_global(ctx, (int)KEY_F, "KEY_F"); 1288 | dukglue_register_global(ctx, (int)KEY_G, "KEY_G"); 1289 | dukglue_register_global(ctx, (int)KEY_H, "KEY_H"); 1290 | dukglue_register_global(ctx, (int)KEY_I, "KEY_I"); 1291 | dukglue_register_global(ctx, (int)KEY_J, "KEY_J"); 1292 | dukglue_register_global(ctx, (int)KEY_K, "KEY_K"); 1293 | dukglue_register_global(ctx, (int)KEY_L, "KEY_L"); 1294 | dukglue_register_global(ctx, (int)KEY_M, "KEY_M"); 1295 | dukglue_register_global(ctx, (int)KEY_N, "KEY_N"); 1296 | dukglue_register_global(ctx, (int)KEY_O, "KEY_O"); 1297 | dukglue_register_global(ctx, (int)KEY_P, "KEY_P"); 1298 | dukglue_register_global(ctx, (int)KEY_Q, "KEY_Q"); 1299 | dukglue_register_global(ctx, (int)KEY_R, "KEY_R"); 1300 | dukglue_register_global(ctx, (int)KEY_S, "KEY_S"); 1301 | dukglue_register_global(ctx, (int)KEY_T, "KEY_T"); 1302 | dukglue_register_global(ctx, (int)KEY_U, "KEY_U"); 1303 | dukglue_register_global(ctx, (int)KEY_V, "KEY_V"); 1304 | dukglue_register_global(ctx, (int)KEY_W, "KEY_W"); 1305 | dukglue_register_global(ctx, (int)KEY_X, "KEY_X"); 1306 | dukglue_register_global(ctx, (int)KEY_Y, "KEY_Y"); 1307 | dukglue_register_global(ctx, (int)KEY_Z, "KEY_Z"); 1308 | dukglue_register_global(ctx, (int)KEY_LEFT_BRACKET, "KEY_LEFT_BRACKET"); 1309 | dukglue_register_global(ctx, (int)KEY_BACKSLASH, "KEY_BACKSLASH"); 1310 | dukglue_register_global(ctx, (int)KEY_RIGHT_BRACKET, "KEY_RIGHT_BRACKET"); 1311 | dukglue_register_global(ctx, (int)KEY_GRAVE, "KEY_GRAVE"); 1312 | dukglue_register_global(ctx, (int)KEY_SPACE, "KEY_SPACE"); 1313 | dukglue_register_global(ctx, (int)KEY_ESCAPE, "KEY_ESCAPE"); 1314 | dukglue_register_global(ctx, (int)KEY_ENTER, "KEY_ENTER"); 1315 | dukglue_register_global(ctx, (int)KEY_TAB, "KEY_TAB"); 1316 | dukglue_register_global(ctx, (int)KEY_BACKSPACE, "KEY_BACKSPACE"); 1317 | dukglue_register_global(ctx, (int)KEY_INSERT, "KEY_INSERT"); 1318 | dukglue_register_global(ctx, (int)KEY_DELETE, "KEY_DELETE"); 1319 | dukglue_register_global(ctx, (int)KEY_RIGHT, "KEY_RIGHT"); 1320 | dukglue_register_global(ctx, (int)KEY_LEFT, "KEY_LEFT"); 1321 | dukglue_register_global(ctx, (int)KEY_DOWN, "KEY_DOWN"); 1322 | dukglue_register_global(ctx, (int)KEY_UP, "KEY_UP"); 1323 | dukglue_register_global(ctx, (int)KEY_PAGE_UP, "KEY_PAGE_UP"); 1324 | dukglue_register_global(ctx, (int)KEY_PAGE_DOWN, "KEY_PAGE_DOWN"); 1325 | dukglue_register_global(ctx, (int)KEY_HOME, "KEY_HOME"); 1326 | dukglue_register_global(ctx, (int)KEY_END, "KEY_END"); 1327 | dukglue_register_global(ctx, (int)KEY_CAPS_LOCK, "KEY_CAPS_LOCK"); 1328 | dukglue_register_global(ctx, (int)KEY_SCROLL_LOCK, "KEY_SCROLL_LOCK"); 1329 | dukglue_register_global(ctx, (int)KEY_NUM_LOCK, "KEY_NUM_LOCK"); 1330 | dukglue_register_global(ctx, (int)KEY_PRINT_SCREEN, "KEY_PRINT_SCREEN"); 1331 | dukglue_register_global(ctx, (int)KEY_PAUSE, "KEY_PAUSE"); 1332 | dukglue_register_global(ctx, (int)KEY_F1, "KEY_F1"); 1333 | dukglue_register_global(ctx, (int)KEY_F2, "KEY_F2"); 1334 | dukglue_register_global(ctx, (int)KEY_F3, "KEY_F3"); 1335 | dukglue_register_global(ctx, (int)KEY_F4, "KEY_F4"); 1336 | dukglue_register_global(ctx, (int)KEY_F5, "KEY_F5"); 1337 | dukglue_register_global(ctx, (int)KEY_F6, "KEY_F6"); 1338 | dukglue_register_global(ctx, (int)KEY_F7, "KEY_F7"); 1339 | dukglue_register_global(ctx, (int)KEY_F8, "KEY_F8"); 1340 | dukglue_register_global(ctx, (int)KEY_F9, "KEY_F9"); 1341 | dukglue_register_global(ctx, (int)KEY_F10, "KEY_F10"); 1342 | dukglue_register_global(ctx, (int)KEY_F11, "KEY_F11"); 1343 | dukglue_register_global(ctx, (int)KEY_F12, "KEY_F12"); 1344 | dukglue_register_global(ctx, (int)KEY_LEFT_SHIFT, "KEY_LEFT_SHIFT"); 1345 | dukglue_register_global(ctx, (int)KEY_LEFT_CONTROL, "KEY_LEFT_CONTROL"); 1346 | dukglue_register_global(ctx, (int)KEY_LEFT_ALT, "KEY_LEFT_ALT"); 1347 | dukglue_register_global(ctx, (int)KEY_LEFT_SUPER, "KEY_LEFT_SUPER"); 1348 | dukglue_register_global(ctx, (int)KEY_RIGHT_SHIFT, "KEY_RIGHT_SHIFT"); 1349 | dukglue_register_global(ctx, (int)KEY_RIGHT_CONTROL, "KEY_RIGHT_CONTROL"); 1350 | dukglue_register_global(ctx, (int)KEY_RIGHT_ALT, "KEY_RIGHT_ALT"); 1351 | dukglue_register_global(ctx, (int)KEY_RIGHT_SUPER, "KEY_RIGHT_SUPER"); 1352 | dukglue_register_global(ctx, (int)KEY_KB_MENU, "KEY_KB_MENU"); 1353 | dukglue_register_global(ctx, (int)KEY_KP_0, "KEY_KP_0"); 1354 | dukglue_register_global(ctx, (int)KEY_KP_1, "KEY_KP_1"); 1355 | dukglue_register_global(ctx, (int)KEY_KP_2, "KEY_KP_2"); 1356 | dukglue_register_global(ctx, (int)KEY_KP_3, "KEY_KP_3"); 1357 | dukglue_register_global(ctx, (int)KEY_KP_4, "KEY_KP_4"); 1358 | dukglue_register_global(ctx, (int)KEY_KP_5, "KEY_KP_5"); 1359 | dukglue_register_global(ctx, (int)KEY_KP_6, "KEY_KP_6"); 1360 | dukglue_register_global(ctx, (int)KEY_KP_7, "KEY_KP_7"); 1361 | dukglue_register_global(ctx, (int)KEY_KP_8, "KEY_KP_8"); 1362 | dukglue_register_global(ctx, (int)KEY_KP_9, "KEY_KP_9"); 1363 | dukglue_register_global(ctx, (int)KEY_KP_DECIMAL, "KEY_KP_DECIMAL"); 1364 | dukglue_register_global(ctx, (int)KEY_KP_DIVIDE, "KEY_KP_DIVIDE"); 1365 | dukglue_register_global(ctx, (int)KEY_KP_MULTIPLY, "KEY_KP_MULTIPLY"); 1366 | dukglue_register_global(ctx, (int)KEY_KP_SUBTRACT, "KEY_KP_SUBTRACT"); 1367 | dukglue_register_global(ctx, (int)KEY_KP_ADD, "KEY_KP_ADD"); 1368 | dukglue_register_global(ctx, (int)KEY_KP_ENTER, "KEY_KP_ENTER"); 1369 | dukglue_register_global(ctx, (int)KEY_KP_EQUAL, "KEY_KP_EQUAL"); 1370 | dukglue_register_global(ctx, (int)KEY_BACK, "KEY_BACK"); 1371 | dukglue_register_global(ctx, (int)KEY_MENU, "KEY_MENU"); 1372 | dukglue_register_global(ctx, (int)KEY_VOLUME_UP, "KEY_VOLUME_UP"); 1373 | dukglue_register_global(ctx, (int)KEY_VOLUME_DOWN, "KEY_VOLUME_DOWN"); 1374 | 1375 | // MouseButton 1376 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_LEFT, "MOUSE_BUTTON_LEFT"); 1377 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_RIGHT, "MOUSE_BUTTON_RIGHT"); 1378 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_MIDDLE, "MOUSE_BUTTON_MIDDLE"); 1379 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_SIDE, "MOUSE_BUTTON_SIDE"); 1380 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_EXTRA, "MOUSE_BUTTON_EXTRA"); 1381 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_FORWARD, "MOUSE_BUTTON_FORWARD"); 1382 | dukglue_register_global(ctx, (int)MOUSE_BUTTON_BACK, "MOUSE_BUTTON_BACK"); 1383 | 1384 | // MouseCursor 1385 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_DEFAULT, "MOUSE_CURSOR_DEFAULT"); 1386 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_ARROW, "MOUSE_CURSOR_ARROW"); 1387 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_IBEAM, "MOUSE_CURSOR_IBEAM"); 1388 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_CROSSHAIR, "MOUSE_CURSOR_CROSSHAIR"); 1389 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_POINTING_HAND, "MOUSE_CURSOR_POINTING_HAND"); 1390 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_RESIZE_EW, "MOUSE_CURSOR_RESIZE_EW"); 1391 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_RESIZE_NS, "MOUSE_CURSOR_RESIZE_NS"); 1392 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_RESIZE_NWSE, "MOUSE_CURSOR_RESIZE_NWSE"); 1393 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_RESIZE_NESW, "MOUSE_CURSOR_RESIZE_NESW"); 1394 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_RESIZE_ALL, "MOUSE_CURSOR_RESIZE_ALL"); 1395 | dukglue_register_global(ctx, (int)MOUSE_CURSOR_NOT_ALLOWED, "MOUSE_CURSOR_NOT_ALLOWED"); 1396 | 1397 | // GamepadButton 1398 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_UNKNOWN, "GAMEPAD_BUTTON_UNKNOWN"); 1399 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_FACE_UP, "GAMEPAD_BUTTON_LEFT_FACE_UP"); 1400 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_FACE_RIGHT, "GAMEPAD_BUTTON_LEFT_FACE_RIGHT"); 1401 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_FACE_DOWN, "GAMEPAD_BUTTON_LEFT_FACE_DOWN"); 1402 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_FACE_LEFT, "GAMEPAD_BUTTON_LEFT_FACE_LEFT"); 1403 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_FACE_UP, "GAMEPAD_BUTTON_RIGHT_FACE_UP"); 1404 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_FACE_RIGHT, "GAMEPAD_BUTTON_RIGHT_FACE_RIGHT"); 1405 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_FACE_DOWN, "GAMEPAD_BUTTON_RIGHT_FACE_DOWN"); 1406 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_FACE_LEFT, "GAMEPAD_BUTTON_RIGHT_FACE_LEFT"); 1407 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_TRIGGER_1, "GAMEPAD_BUTTON_LEFT_TRIGGER_1"); 1408 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_TRIGGER_2, "GAMEPAD_BUTTON_LEFT_TRIGGER_2"); 1409 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_TRIGGER_1, "GAMEPAD_BUTTON_RIGHT_TRIGGER_1"); 1410 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_TRIGGER_2, "GAMEPAD_BUTTON_RIGHT_TRIGGER_2"); 1411 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_MIDDLE_LEFT, "GAMEPAD_BUTTON_MIDDLE_LEFT"); 1412 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_MIDDLE, "GAMEPAD_BUTTON_MIDDLE"); 1413 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_MIDDLE_RIGHT, "GAMEPAD_BUTTON_MIDDLE_RIGHT"); 1414 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_LEFT_THUMB, "GAMEPAD_BUTTON_LEFT_THUMB"); 1415 | dukglue_register_global(ctx, (int)GAMEPAD_BUTTON_RIGHT_THUMB, "GAMEPAD_BUTTON_RIGHT_THUMB"); 1416 | 1417 | // GamepadAxis 1418 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_LEFT_X, "GAMEPAD_AXIS_LEFT_X"); 1419 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_LEFT_Y, "GAMEPAD_AXIS_LEFT_Y"); 1420 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_RIGHT_X, "GAMEPAD_AXIS_RIGHT_X"); 1421 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_RIGHT_Y, "GAMEPAD_AXIS_RIGHT_Y"); 1422 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_LEFT_TRIGGER, "GAMEPAD_AXIS_LEFT_TRIGGER"); 1423 | dukglue_register_global(ctx, (int)GAMEPAD_AXIS_RIGHT_TRIGGER, "GAMEPAD_AXIS_RIGHT_TRIGGER"); 1424 | 1425 | // MaterialMapIndex 1426 | dukglue_register_global(ctx, (int)MATERIAL_MAP_ALBEDO, "MATERIAL_MAP_ALBEDO"); 1427 | dukglue_register_global(ctx, (int)MATERIAL_MAP_METALNESS, "MATERIAL_MAP_METALNESS"); 1428 | dukglue_register_global(ctx, (int)MATERIAL_MAP_NORMAL, "MATERIAL_MAP_NORMAL"); 1429 | dukglue_register_global(ctx, (int)MATERIAL_MAP_ROUGHNESS, "MATERIAL_MAP_ROUGHNESS"); 1430 | dukglue_register_global(ctx, (int)MATERIAL_MAP_OCCLUSION, "MATERIAL_MAP_OCCLUSION"); 1431 | dukglue_register_global(ctx, (int)MATERIAL_MAP_EMISSION, "MATERIAL_MAP_EMISSION"); 1432 | dukglue_register_global(ctx, (int)MATERIAL_MAP_HEIGHT, "MATERIAL_MAP_HEIGHT"); 1433 | dukglue_register_global(ctx, (int)MATERIAL_MAP_CUBEMAP, "MATERIAL_MAP_CUBEMAP"); 1434 | dukglue_register_global(ctx, (int)MATERIAL_MAP_IRRADIANCE, "MATERIAL_MAP_IRRADIANCE"); 1435 | dukglue_register_global(ctx, (int)MATERIAL_MAP_PREFILTER, "MATERIAL_MAP_PREFILTER"); 1436 | dukglue_register_global(ctx, (int)MATERIAL_MAP_BRDF, "MATERIAL_MAP_BRDF"); 1437 | 1438 | // ShaderLocationIndex 1439 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_POSITION, "SHADER_LOC_VERTEX_POSITION"); 1440 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_TEXCOORD01, "SHADER_LOC_VERTEX_TEXCOORD01"); 1441 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_TEXCOORD02, "SHADER_LOC_VERTEX_TEXCOORD02"); 1442 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_NORMAL, "SHADER_LOC_VERTEX_NORMAL"); 1443 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_TANGENT, "SHADER_LOC_VERTEX_TANGENT"); 1444 | dukglue_register_global(ctx, (int)SHADER_LOC_VERTEX_COLOR, "SHADER_LOC_VERTEX_COLOR"); 1445 | dukglue_register_global(ctx, (int)SHADER_LOC_MATRIX_MVP, "SHADER_LOC_MATRIX_MVP"); 1446 | dukglue_register_global(ctx, (int)SHADER_LOC_MATRIX_VIEW, "SHADER_LOC_MATRIX_VIEW"); 1447 | dukglue_register_global(ctx, (int)SHADER_LOC_MATRIX_PROJECTION, "SHADER_LOC_MATRIX_PROJECTION"); 1448 | dukglue_register_global(ctx, (int)SHADER_LOC_MATRIX_MODEL, "SHADER_LOC_MATRIX_MODEL"); 1449 | dukglue_register_global(ctx, (int)SHADER_LOC_MATRIX_NORMAL, "SHADER_LOC_MATRIX_NORMAL"); 1450 | dukglue_register_global(ctx, (int)SHADER_LOC_VECTOR_VIEW, "SHADER_LOC_VECTOR_VIEW"); 1451 | dukglue_register_global(ctx, (int)SHADER_LOC_COLOR_DIFFUSE, "SHADER_LOC_COLOR_DIFFUSE"); 1452 | dukglue_register_global(ctx, (int)SHADER_LOC_COLOR_SPECULAR, "SHADER_LOC_COLOR_SPECULAR"); 1453 | dukglue_register_global(ctx, (int)SHADER_LOC_COLOR_AMBIENT, "SHADER_LOC_COLOR_AMBIENT"); 1454 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_ALBEDO, "SHADER_LOC_MAP_ALBEDO"); 1455 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_METALNESS, "SHADER_LOC_MAP_METALNESS"); 1456 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_NORMAL, "SHADER_LOC_MAP_NORMAL"); 1457 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_ROUGHNESS, "SHADER_LOC_MAP_ROUGHNESS"); 1458 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_OCCLUSION, "SHADER_LOC_MAP_OCCLUSION"); 1459 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_EMISSION, "SHADER_LOC_MAP_EMISSION"); 1460 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_HEIGHT, "SHADER_LOC_MAP_HEIGHT"); 1461 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_CUBEMAP, "SHADER_LOC_MAP_CUBEMAP"); 1462 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_IRRADIANCE, "SHADER_LOC_MAP_IRRADIANCE"); 1463 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_PREFILTER, "SHADER_LOC_MAP_PREFILTER"); 1464 | dukglue_register_global(ctx, (int)SHADER_LOC_MAP_BRDF, "SHADER_LOC_MAP_BRDF"); 1465 | 1466 | // ShaderUniformDataType 1467 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_FLOAT, "SHADER_UNIFORM_FLOAT"); 1468 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_VEC2, "SHADER_UNIFORM_VEC2"); 1469 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_VEC3, "SHADER_UNIFORM_VEC3"); 1470 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_VEC4, "SHADER_UNIFORM_VEC4"); 1471 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_INT, "SHADER_UNIFORM_INT"); 1472 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_IVEC2, "SHADER_UNIFORM_IVEC2"); 1473 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_IVEC3, "SHADER_UNIFORM_IVEC3"); 1474 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_IVEC4, "SHADER_UNIFORM_IVEC4"); 1475 | dukglue_register_global(ctx, (int)SHADER_UNIFORM_SAMPLER2D, "SHADER_UNIFORM_SAMPLER2D"); 1476 | 1477 | // ShaderAttributeDataType 1478 | dukglue_register_global(ctx, (int)SHADER_ATTRIB_FLOAT, "SHADER_ATTRIB_FLOAT"); 1479 | dukglue_register_global(ctx, (int)SHADER_ATTRIB_VEC2, "SHADER_ATTRIB_VEC2"); 1480 | dukglue_register_global(ctx, (int)SHADER_ATTRIB_VEC3, "SHADER_ATTRIB_VEC3"); 1481 | dukglue_register_global(ctx, (int)SHADER_ATTRIB_VEC4, "SHADER_ATTRIB_VEC4"); 1482 | 1483 | // PixelFormat 1484 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_GRAYSCALE, "PIXELFORMAT_UNCOMPRESSED_GRAYSCALE"); 1485 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA, "PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA"); 1486 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R5G6B5, "PIXELFORMAT_UNCOMPRESSED_R5G6B5"); 1487 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R8G8B8, "PIXELFORMAT_UNCOMPRESSED_R8G8B8"); 1488 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R5G5B5A1, "PIXELFORMAT_UNCOMPRESSED_R5G5B5A1"); 1489 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R4G4B4A4, "PIXELFORMAT_UNCOMPRESSED_R4G4B4A4"); 1490 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R8G8B8A8, "PIXELFORMAT_UNCOMPRESSED_R8G8B8A8"); 1491 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R32, "PIXELFORMAT_UNCOMPRESSED_R32"); 1492 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R32G32B32, "PIXELFORMAT_UNCOMPRESSED_R32G32B32"); 1493 | dukglue_register_global(ctx, (int)PIXELFORMAT_UNCOMPRESSED_R32G32B32A32, "PIXELFORMAT_UNCOMPRESSED_R32G32B32A32"); 1494 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_DXT1_RGB, "PIXELFORMAT_COMPRESSED_DXT1_RGB"); 1495 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_DXT1_RGBA, "PIXELFORMAT_COMPRESSED_DXT1_RGBA"); 1496 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_DXT3_RGBA, "PIXELFORMAT_COMPRESSED_DXT3_RGBA"); 1497 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_DXT5_RGBA, "PIXELFORMAT_COMPRESSED_DXT5_RGBA"); 1498 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_ETC1_RGB, "PIXELFORMAT_COMPRESSED_ETC1_RGB"); 1499 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_ETC2_RGB, "PIXELFORMAT_COMPRESSED_ETC2_RGB"); 1500 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA, "PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA"); 1501 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_PVRT_RGB, "PIXELFORMAT_COMPRESSED_PVRT_RGB"); 1502 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_PVRT_RGBA, "PIXELFORMAT_COMPRESSED_PVRT_RGBA"); 1503 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA, "PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA"); 1504 | dukglue_register_global(ctx, (int)PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA, "PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA"); 1505 | 1506 | // TextureFilter 1507 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_POINT, "TEXTURE_FILTER_POINT"); 1508 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_BILINEAR, "TEXTURE_FILTER_BILINEAR"); 1509 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_TRILINEAR, "TEXTURE_FILTER_TRILINEAR"); 1510 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_ANISOTROPIC_4X, "TEXTURE_FILTER_ANISOTROPIC_4X"); 1511 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_ANISOTROPIC_8X, "TEXTURE_FILTER_ANISOTROPIC_8X"); 1512 | dukglue_register_global(ctx, (int)TEXTURE_FILTER_ANISOTROPIC_16X, "TEXTURE_FILTER_ANISOTROPIC_16X"); 1513 | 1514 | // TextureWrap 1515 | dukglue_register_global(ctx, (int)TEXTURE_WRAP_REPEAT, "TEXTURE_WRAP_REPEAT"); 1516 | dukglue_register_global(ctx, (int)TEXTURE_WRAP_CLAMP, "TEXTURE_WRAP_CLAMP"); 1517 | dukglue_register_global(ctx, (int)TEXTURE_WRAP_MIRROR_REPEAT, "TEXTURE_WRAP_MIRROR_REPEAT"); 1518 | dukglue_register_global(ctx, (int)TEXTURE_WRAP_MIRROR_CLAMP, "TEXTURE_WRAP_MIRROR_CLAMP"); 1519 | 1520 | // CubemapLayout 1521 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_AUTO_DETECT, "CUBEMAP_LAYOUT_AUTO_DETECT"); 1522 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_LINE_VERTICAL, "CUBEMAP_LAYOUT_LINE_VERTICAL"); 1523 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_LINE_HORIZONTAL, "CUBEMAP_LAYOUT_LINE_HORIZONTAL"); 1524 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR, "CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR"); 1525 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE, "CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE"); 1526 | dukglue_register_global(ctx, (int)CUBEMAP_LAYOUT_PANORAMA, "CUBEMAP_LAYOUT_PANORAMA"); 1527 | 1528 | // FontType 1529 | dukglue_register_global(ctx, (int)FONT_DEFAULT, "FONT_DEFAULT"); 1530 | dukglue_register_global(ctx, (int)FONT_BITMAP, "FONT_BITMAP"); 1531 | dukglue_register_global(ctx, (int)FONT_SDF, "FONT_SDF"); 1532 | 1533 | // BlendMode 1534 | dukglue_register_global(ctx, (int)BLEND_ALPHA, "BLEND_ALPHA"); 1535 | dukglue_register_global(ctx, (int)BLEND_ADDITIVE, "BLEND_ADDITIVE"); 1536 | dukglue_register_global(ctx, (int)BLEND_MULTIPLIED, "BLEND_MULTIPLIED"); 1537 | dukglue_register_global(ctx, (int)BLEND_ADD_COLORS, "BLEND_ADD_COLORS"); 1538 | dukglue_register_global(ctx, (int)BLEND_SUBTRACT_COLORS, "BLEND_SUBTRACT_COLORS"); 1539 | dukglue_register_global(ctx, (int)BLEND_ALPHA_PREMULTIPLY, "BLEND_ALPHA_PREMULTIPLY"); 1540 | dukglue_register_global(ctx, (int)BLEND_CUSTOM, "BLEND_CUSTOM"); 1541 | 1542 | // Gesture 1543 | dukglue_register_global(ctx, (int)GESTURE_NONE, "GESTURE_NONE"); 1544 | dukglue_register_global(ctx, (int)GESTURE_TAP, "GESTURE_TAP"); 1545 | dukglue_register_global(ctx, (int)GESTURE_DOUBLETAP, "GESTURE_DOUBLETAP"); 1546 | dukglue_register_global(ctx, (int)GESTURE_HOLD, "GESTURE_HOLD"); 1547 | dukglue_register_global(ctx, (int)GESTURE_DRAG, "GESTURE_DRAG"); 1548 | dukglue_register_global(ctx, (int)GESTURE_SWIPE_RIGHT, "GESTURE_SWIPE_RIGHT"); 1549 | dukglue_register_global(ctx, (int)GESTURE_SWIPE_LEFT, "GESTURE_SWIPE_LEFT"); 1550 | dukglue_register_global(ctx, (int)GESTURE_SWIPE_UP, "GESTURE_SWIPE_UP"); 1551 | dukglue_register_global(ctx, (int)GESTURE_SWIPE_DOWN, "GESTURE_SWIPE_DOWN"); 1552 | dukglue_register_global(ctx, (int)GESTURE_PINCH_IN, "GESTURE_PINCH_IN"); 1553 | dukglue_register_global(ctx, (int)GESTURE_PINCH_OUT, "GESTURE_PINCH_OUT"); 1554 | 1555 | // CameraMode 1556 | dukglue_register_global(ctx, (int)CAMERA_CUSTOM, "CAMERA_CUSTOM"); 1557 | dukglue_register_global(ctx, (int)CAMERA_FREE, "CAMERA_FREE"); 1558 | dukglue_register_global(ctx, (int)CAMERA_ORBITAL, "CAMERA_ORBITAL"); 1559 | dukglue_register_global(ctx, (int)CAMERA_FIRST_PERSON, "CAMERA_FIRST_PERSON"); 1560 | dukglue_register_global(ctx, (int)CAMERA_THIRD_PERSON, "CAMERA_THIRD_PERSON"); 1561 | 1562 | // CameraProjection 1563 | dukglue_register_global(ctx, (int)CAMERA_PERSPECTIVE, "CAMERA_PERSPECTIVE"); 1564 | dukglue_register_global(ctx, (int)CAMERA_ORTHOGRAPHIC, "CAMERA_ORTHOGRAPHIC"); 1565 | 1566 | // NPatchLayout 1567 | dukglue_register_global(ctx, (int)NPATCH_NINE_PATCH, "NPATCH_NINE_PATCH"); 1568 | dukglue_register_global(ctx, (int)NPATCH_THREE_PATCH_VERTICAL, "NPATCH_THREE_PATCH_VERTICAL"); 1569 | dukglue_register_global(ctx, (int)NPATCH_THREE_PATCH_HORIZONTAL, "NPATCH_THREE_PATCH_HORIZONTAL"); 1570 | 1571 | // Custom 1572 | dukglue_register_global(ctx, (int)MOUSE_LEFT_BUTTON, "MOUSE_LEFT_BUTTON"); 1573 | dukglue_register_global(ctx, (int)MOUSE_RIGHT_BUTTON, "MOUSE_RIGHT_BUTTON"); 1574 | dukglue_register_global(ctx, (int)MOUSE_MIDDLE_BUTTON, "MOUSE_MIDDLE_BUTTON"); 1575 | 1576 | // Skipped: RAYLIB_H 1577 | // Skipped: RAYLIB_VERSION 1578 | // Skipped: __declspec(x) 1579 | // Skipped: RLAPI 1580 | dukglue_register_global(ctx, PI, "PI"); 1581 | // Skipped: DEG2RAD 1582 | // Skipped: RAD2DEG 1583 | // Skipped: RL_MALLOC(sz) 1584 | // Skipped: RL_CALLOC(n,sz) 1585 | // Skipped: RL_REALLOC(ptr,sz) 1586 | // Skipped: RL_FREE(ptr) 1587 | // Skipped: CLITERAL(type) 1588 | // Skipped: RL_COLOR_TYPE 1589 | // Skipped: RL_RECTANGLE_TYPE 1590 | // Skipped: RL_VECTOR2_TYPE 1591 | // Skipped: RL_VECTOR3_TYPE 1592 | // Skipped: RL_VECTOR4_TYPE 1593 | // Skipped: RL_QUATERNION_TYPE 1594 | // Skipped: RL_MATRIX_TYPE 1595 | dukglue_register_global(ctx, LIGHTGRAY, "LIGHTGRAY"); 1596 | dukglue_register_global(ctx, GRAY, "GRAY"); 1597 | dukglue_register_global(ctx, DARKGRAY, "DARKGRAY"); 1598 | dukglue_register_global(ctx, YELLOW, "YELLOW"); 1599 | dukglue_register_global(ctx, GOLD, "GOLD"); 1600 | dukglue_register_global(ctx, ORANGE, "ORANGE"); 1601 | dukglue_register_global(ctx, PINK, "PINK"); 1602 | dukglue_register_global(ctx, RED, "RED"); 1603 | dukglue_register_global(ctx, MAROON, "MAROON"); 1604 | dukglue_register_global(ctx, GREEN, "GREEN"); 1605 | dukglue_register_global(ctx, LIME, "LIME"); 1606 | dukglue_register_global(ctx, DARKGREEN, "DARKGREEN"); 1607 | dukglue_register_global(ctx, SKYBLUE, "SKYBLUE"); 1608 | dukglue_register_global(ctx, BLUE, "BLUE"); 1609 | dukglue_register_global(ctx, DARKBLUE, "DARKBLUE"); 1610 | dukglue_register_global(ctx, PURPLE, "PURPLE"); 1611 | dukglue_register_global(ctx, VIOLET, "VIOLET"); 1612 | dukglue_register_global(ctx, DARKPURPLE, "DARKPURPLE"); 1613 | dukglue_register_global(ctx, BEIGE, "BEIGE"); 1614 | dukglue_register_global(ctx, BROWN, "BROWN"); 1615 | dukglue_register_global(ctx, DARKBROWN, "DARKBROWN"); 1616 | dukglue_register_global(ctx, WHITE, "WHITE"); 1617 | dukglue_register_global(ctx, BLACK, "BLACK"); 1618 | dukglue_register_global(ctx, BLANK, "BLANK"); 1619 | dukglue_register_global(ctx, MAGENTA, "MAGENTA"); 1620 | dukglue_register_global(ctx, RAYWHITE, "RAYWHITE"); 1621 | // Skipped: RL_BOOL_TYPE 1622 | // Skipped: MOUSE_LEFT_BUTTON 1623 | // Skipped: MOUSE_RIGHT_BUTTON 1624 | // Skipped: MOUSE_MIDDLE_BUTTON 1625 | // Skipped: MATERIAL_MAP_DIFFUSE 1626 | // Skipped: MATERIAL_MAP_SPECULAR 1627 | // Skipped: SHADER_LOC_MAP_DIFFUSE 1628 | // Skipped: SHADER_LOC_MAP_SPECULAR 1629 | dukglue_register_function(ctx, &InitWindow, "InitWindow"); 1630 | dukglue_register_function(ctx, &WindowShouldClose, "WindowShouldClose"); 1631 | dukglue_register_function(ctx, &CloseWindow, "CloseWindow"); 1632 | dukglue_register_function(ctx, &IsWindowReady, "IsWindowReady"); 1633 | dukglue_register_function(ctx, &IsWindowFullscreen, "IsWindowFullscreen"); 1634 | dukglue_register_function(ctx, &IsWindowHidden, "IsWindowHidden"); 1635 | dukglue_register_function(ctx, &IsWindowMinimized, "IsWindowMinimized"); 1636 | dukglue_register_function(ctx, &IsWindowMaximized, "IsWindowMaximized"); 1637 | dukglue_register_function(ctx, &IsWindowFocused, "IsWindowFocused"); 1638 | dukglue_register_function(ctx, &IsWindowResized, "IsWindowResized"); 1639 | dukglue_register_function(ctx, &IsWindowState, "IsWindowState"); 1640 | dukglue_register_function(ctx, &SetWindowState, "SetWindowState"); 1641 | dukglue_register_function(ctx, &ClearWindowState, "ClearWindowState"); 1642 | dukglue_register_function(ctx, &ToggleFullscreen, "ToggleFullscreen"); 1643 | dukglue_register_function(ctx, &MaximizeWindow, "MaximizeWindow"); 1644 | dukglue_register_function(ctx, &MinimizeWindow, "MinimizeWindow"); 1645 | dukglue_register_function(ctx, &RestoreWindow, "RestoreWindow"); 1646 | dukglue_register_function(ctx, &SetWindowIcon, "SetWindowIcon"); 1647 | dukglue_register_function(ctx, &SetWindowTitle, "SetWindowTitle"); 1648 | dukglue_register_function(ctx, &SetWindowPosition, "SetWindowPosition"); 1649 | dukglue_register_function(ctx, &SetWindowMonitor, "SetWindowMonitor"); 1650 | dukglue_register_function(ctx, &SetWindowMinSize, "SetWindowMinSize"); 1651 | dukglue_register_function(ctx, &SetWindowSize, "SetWindowSize"); 1652 | dukglue_register_function(ctx, &SetWindowOpacity, "SetWindowOpacity"); 1653 | // dukglue_register_function(ctx, &GetWindowHandle, "GetWindowHandle"); 1654 | dukglue_register_function(ctx, &GetScreenWidth, "GetScreenWidth"); 1655 | dukglue_register_function(ctx, &GetScreenHeight, "GetScreenHeight"); 1656 | dukglue_register_function(ctx, &GetRenderWidth, "GetRenderWidth"); 1657 | dukglue_register_function(ctx, &GetRenderHeight, "GetRenderHeight"); 1658 | dukglue_register_function(ctx, &GetMonitorCount, "GetMonitorCount"); 1659 | dukglue_register_function(ctx, &GetCurrentMonitor, "GetCurrentMonitor"); 1660 | dukglue_register_function(ctx, &GetMonitorPosition, "GetMonitorPosition"); 1661 | dukglue_register_function(ctx, &GetMonitorWidth, "GetMonitorWidth"); 1662 | dukglue_register_function(ctx, &GetMonitorHeight, "GetMonitorHeight"); 1663 | dukglue_register_function(ctx, &GetMonitorPhysicalWidth, "GetMonitorPhysicalWidth"); 1664 | dukglue_register_function(ctx, &GetMonitorPhysicalHeight, "GetMonitorPhysicalHeight"); 1665 | dukglue_register_function(ctx, &GetMonitorRefreshRate, "GetMonitorRefreshRate"); 1666 | dukglue_register_function(ctx, &GetWindowPosition, "GetWindowPosition"); 1667 | dukglue_register_function(ctx, &GetWindowScaleDPI, "GetWindowScaleDPI"); 1668 | dukglue_register_function(ctx, &GetMonitorName, "GetMonitorName"); 1669 | dukglue_register_function(ctx, &SetClipboardText, "SetClipboardText"); 1670 | dukglue_register_function(ctx, &GetClipboardText, "GetClipboardText"); 1671 | dukglue_register_function(ctx, &EnableEventWaiting, "EnableEventWaiting"); 1672 | dukglue_register_function(ctx, &DisableEventWaiting, "DisableEventWaiting"); 1673 | dukglue_register_function(ctx, &SwapScreenBuffer, "SwapScreenBuffer"); 1674 | dukglue_register_function(ctx, &PollInputEvents, "PollInputEvents"); 1675 | dukglue_register_function(ctx, &WaitTime, "WaitTime"); 1676 | dukglue_register_function(ctx, &ShowCursor, "ShowCursor"); 1677 | dukglue_register_function(ctx, &HideCursor, "HideCursor"); 1678 | dukglue_register_function(ctx, &IsCursorHidden, "IsCursorHidden"); 1679 | dukglue_register_function(ctx, &EnableCursor, "EnableCursor"); 1680 | dukglue_register_function(ctx, &DisableCursor, "DisableCursor"); 1681 | dukglue_register_function(ctx, &IsCursorOnScreen, "IsCursorOnScreen"); 1682 | dukglue_register_function(ctx, &ClearBackground, "ClearBackground"); 1683 | dukglue_register_function(ctx, &BeginDrawing, "BeginDrawing"); 1684 | dukglue_register_function(ctx, &EndDrawing, "EndDrawing"); 1685 | dukglue_register_function(ctx, &BeginMode2D, "BeginMode2D"); 1686 | dukglue_register_function(ctx, &EndMode2D, "EndMode2D"); 1687 | dukglue_register_function(ctx, &BeginMode3D, "BeginMode3D"); 1688 | dukglue_register_function(ctx, &EndMode3D, "EndMode3D"); 1689 | dukglue_register_function(ctx, &BeginTextureMode, "BeginTextureMode"); 1690 | dukglue_register_function(ctx, &EndTextureMode, "EndTextureMode"); 1691 | dukglue_register_function(ctx, &BeginShaderMode, "BeginShaderMode"); 1692 | dukglue_register_function(ctx, &EndShaderMode, "EndShaderMode"); 1693 | dukglue_register_function(ctx, &BeginBlendMode, "BeginBlendMode"); 1694 | dukglue_register_function(ctx, &EndBlendMode, "EndBlendMode"); 1695 | dukglue_register_function(ctx, &BeginScissorMode, "BeginScissorMode"); 1696 | dukglue_register_function(ctx, &EndScissorMode, "EndScissorMode"); 1697 | dukglue_register_function(ctx, &BeginVrStereoMode, "BeginVrStereoMode"); 1698 | dukglue_register_function(ctx, &EndVrStereoMode, "EndVrStereoMode"); 1699 | dukglue_register_function(ctx, &LoadVrStereoConfig, "LoadVrStereoConfig"); 1700 | dukglue_register_function(ctx, &UnloadVrStereoConfig, "UnloadVrStereoConfig"); 1701 | dukglue_register_function(ctx, &LoadShader, "LoadShader"); 1702 | dukglue_register_function(ctx, &LoadShaderFromMemory, "LoadShaderFromMemory"); 1703 | dukglue_register_function(ctx, &GetShaderLocation, "GetShaderLocation"); 1704 | // dukglue_register_function(ctx, &GetShaderLocationAttrib, "GetShaderLocationAttrib"); 1705 | // dukglue_register_function(ctx, &SetShaderValue, "SetShaderValue"); 1706 | // dukglue_register_function(ctx, &SetShaderValueV, "SetShaderValueV"); 1707 | // dukglue_register_function(ctx, &SetShaderValueMatrix, "SetShaderValueMatrix"); 1708 | // dukglue_register_function(ctx, &SetShaderValueTexture, "SetShaderValueTexture"); 1709 | // dukglue_register_function(ctx, &UnloadShader, "UnloadShader"); 1710 | dukglue_register_function(ctx, &GetMouseRay, "GetMouseRay"); 1711 | dukglue_register_function(ctx, &GetCameraMatrix, "GetCameraMatrix"); 1712 | dukglue_register_function(ctx, &GetCameraMatrix2D, "GetCameraMatrix2D"); 1713 | dukglue_register_function(ctx, &GetWorldToScreen, "GetWorldToScreen"); 1714 | dukglue_register_function(ctx, &GetScreenToWorld2D, "GetScreenToWorld2D"); 1715 | dukglue_register_function(ctx, &GetWorldToScreenEx, "GetWorldToScreenEx"); 1716 | dukglue_register_function(ctx, &GetWorldToScreen2D, "GetWorldToScreen2D"); 1717 | dukglue_register_function(ctx, &SetTargetFPS, "SetTargetFPS"); 1718 | dukglue_register_function(ctx, &GetFPS, "GetFPS"); 1719 | dukglue_register_function(ctx, &GetFrameTime, "GetFrameTime"); 1720 | dukglue_register_function(ctx, &GetTime, "GetTime"); 1721 | dukglue_register_function(ctx, &GetRandomValue, "GetRandomValue"); 1722 | dukglue_register_function(ctx, &SetRandomSeed, "SetRandomSeed"); 1723 | dukglue_register_function(ctx, &TakeScreenshot, "TakeScreenshot"); 1724 | dukglue_register_function(ctx, &SetConfigFlags, "SetConfigFlags"); 1725 | // dukglue_register_function(ctx, &TraceLog, "TraceLog"); 1726 | dukglue_register_function(ctx, &SetTraceLogLevel, "SetTraceLogLevel"); 1727 | // dukglue_register_function(ctx, &MemAlloc, "MemAlloc"); 1728 | // dukglue_register_function(ctx, &MemRealloc, "MemRealloc"); 1729 | // dukglue_register_function(ctx, &MemFree, "MemFree"); 1730 | dukglue_register_function(ctx, &OpenURL, "OpenURL"); 1731 | // dukglue_register_function(ctx, &SetTraceLogCallback, "SetTraceLogCallback"); 1732 | // dukglue_register_function(ctx, &SetLoadFileDataCallback, "SetLoadFileDataCallback"); 1733 | // dukglue_register_function(ctx, &SetSaveFileDataCallback, "SetSaveFileDataCallback"); 1734 | // dukglue_register_function(ctx, &SetLoadFileTextCallback, "SetLoadFileTextCallback"); 1735 | // dukglue_register_function(ctx, &SetSaveFileTextCallback, "SetSaveFileTextCallback"); 1736 | // dukglue_register_function(ctx, &LoadFileData, "LoadFileData"); 1737 | // dukglue_register_function(ctx, &UnloadFileData, "UnloadFileData"); 1738 | // dukglue_register_function(ctx, &SaveFileData, "SaveFileData"); 1739 | dukglue_register_function(ctx, &ExportDataAsCode, "ExportDataAsCode"); 1740 | // dukglue_register_function(ctx, &LoadFileText, "LoadFileText"); 1741 | // dukglue_register_function(ctx, &UnloadFileText, "UnloadFileText"); 1742 | // dukglue_register_function(ctx, &SaveFileText, "SaveFileText"); 1743 | dukglue_register_function(ctx, &FileExists, "FileExists"); 1744 | dukglue_register_function(ctx, &DirectoryExists, "DirectoryExists"); 1745 | dukglue_register_function(ctx, &IsFileExtension, "IsFileExtension"); 1746 | dukglue_register_function(ctx, &GetFileLength, "GetFileLength"); 1747 | dukglue_register_function(ctx, &GetFileExtension, "GetFileExtension"); 1748 | dukglue_register_function(ctx, &GetFileName, "GetFileName"); 1749 | dukglue_register_function(ctx, &GetFileNameWithoutExt, "GetFileNameWithoutExt"); 1750 | dukglue_register_function(ctx, &GetDirectoryPath, "GetDirectoryPath"); 1751 | dukglue_register_function(ctx, &GetPrevDirectoryPath, "GetPrevDirectoryPath"); 1752 | dukglue_register_function(ctx, &GetWorkingDirectory, "GetWorkingDirectory"); 1753 | dukglue_register_function(ctx, &GetApplicationDirectory, "GetApplicationDirectory"); 1754 | dukglue_register_function(ctx, &ChangeDirectory, "ChangeDirectory"); 1755 | dukglue_register_function(ctx, &IsPathFile, "IsPathFile"); 1756 | dukglue_register_function(ctx, &LoadDirectoryFiles, "LoadDirectoryFiles"); 1757 | dukglue_register_function(ctx, &LoadDirectoryFilesEx, "LoadDirectoryFilesEx"); 1758 | dukglue_register_function(ctx, &UnloadDirectoryFiles, "UnloadDirectoryFiles"); 1759 | dukglue_register_function(ctx, &IsFileDropped, "IsFileDropped"); 1760 | dukglue_register_function(ctx, &LoadDroppedFiles, "LoadDroppedFiles"); 1761 | dukglue_register_function(ctx, &UnloadDroppedFiles, "UnloadDroppedFiles"); 1762 | dukglue_register_function(ctx, &GetFileModTime, "GetFileModTime"); 1763 | // dukglue_register_function(ctx, &CompressData, "CompressData"); 1764 | // dukglue_register_function(ctx, &DecompressData, "DecompressData"); 1765 | // dukglue_register_function(ctx, &EncodeDataBase64, "EncodeDataBase64"); 1766 | // dukglue_register_function(ctx, &DecodeDataBase64, "DecodeDataBase64"); 1767 | dukglue_register_function(ctx, &IsKeyPressed, "IsKeyPressed"); 1768 | dukglue_register_function(ctx, &IsKeyDown, "IsKeyDown"); 1769 | dukglue_register_function(ctx, &IsKeyReleased, "IsKeyReleased"); 1770 | dukglue_register_function(ctx, &IsKeyUp, "IsKeyUp"); 1771 | dukglue_register_function(ctx, &SetExitKey, "SetExitKey"); 1772 | dukglue_register_function(ctx, &GetKeyPressed, "GetKeyPressed"); 1773 | dukglue_register_function(ctx, &GetCharPressed, "GetCharPressed"); 1774 | dukglue_register_function(ctx, &IsGamepadAvailable, "IsGamepadAvailable"); 1775 | dukglue_register_function(ctx, &GetGamepadName, "GetGamepadName"); 1776 | dukglue_register_function(ctx, &IsGamepadButtonPressed, "IsGamepadButtonPressed"); 1777 | dukglue_register_function(ctx, &IsGamepadButtonDown, "IsGamepadButtonDown"); 1778 | dukglue_register_function(ctx, &IsGamepadButtonReleased, "IsGamepadButtonReleased"); 1779 | dukglue_register_function(ctx, &IsGamepadButtonUp, "IsGamepadButtonUp"); 1780 | dukglue_register_function(ctx, &GetGamepadButtonPressed, "GetGamepadButtonPressed"); 1781 | dukglue_register_function(ctx, &GetGamepadAxisCount, "GetGamepadAxisCount"); 1782 | dukglue_register_function(ctx, &GetGamepadAxisMovement, "GetGamepadAxisMovement"); 1783 | dukglue_register_function(ctx, &SetGamepadMappings, "SetGamepadMappings"); 1784 | dukglue_register_function(ctx, &IsMouseButtonPressed, "IsMouseButtonPressed"); 1785 | dukglue_register_function(ctx, &IsMouseButtonDown, "IsMouseButtonDown"); 1786 | dukglue_register_function(ctx, &IsMouseButtonReleased, "IsMouseButtonReleased"); 1787 | dukglue_register_function(ctx, &IsMouseButtonUp, "IsMouseButtonUp"); 1788 | dukglue_register_function(ctx, &GetMouseX, "GetMouseX"); 1789 | dukglue_register_function(ctx, &GetMouseY, "GetMouseY"); 1790 | dukglue_register_function(ctx, &GetMousePosition, "GetMousePosition"); 1791 | dukglue_register_function(ctx, &GetMouseDelta, "GetMouseDelta"); 1792 | dukglue_register_function(ctx, &SetMousePosition, "SetMousePosition"); 1793 | dukglue_register_function(ctx, &SetMouseOffset, "SetMouseOffset"); 1794 | dukglue_register_function(ctx, &SetMouseScale, "SetMouseScale"); 1795 | dukglue_register_function(ctx, &GetMouseWheelMove, "GetMouseWheelMove"); 1796 | dukglue_register_function(ctx, &GetMouseWheelMoveV, "GetMouseWheelMoveV"); 1797 | dukglue_register_function(ctx, &SetMouseCursor, "SetMouseCursor"); 1798 | dukglue_register_function(ctx, &GetTouchX, "GetTouchX"); 1799 | dukglue_register_function(ctx, &GetTouchY, "GetTouchY"); 1800 | dukglue_register_function(ctx, &GetTouchPosition, "GetTouchPosition"); 1801 | dukglue_register_function(ctx, &GetTouchPointId, "GetTouchPointId"); 1802 | dukglue_register_function(ctx, &GetTouchPointCount, "GetTouchPointCount"); 1803 | dukglue_register_function(ctx, &SetGesturesEnabled, "SetGesturesEnabled"); 1804 | dukglue_register_function(ctx, &IsGestureDetected, "IsGestureDetected"); 1805 | dukglue_register_function(ctx, &GetGestureDetected, "GetGestureDetected"); 1806 | dukglue_register_function(ctx, &GetGestureHoldDuration, "GetGestureHoldDuration"); 1807 | dukglue_register_function(ctx, &GetGestureDragVector, "GetGestureDragVector"); 1808 | dukglue_register_function(ctx, &GetGestureDragAngle, "GetGestureDragAngle"); 1809 | dukglue_register_function(ctx, &GetGesturePinchVector, "GetGesturePinchVector"); 1810 | dukglue_register_function(ctx, &GetGesturePinchAngle, "GetGesturePinchAngle"); 1811 | dukglue_register_function(ctx, &SetCameraMode, "SetCameraMode"); 1812 | // dukglue_register_function(ctx, &UpdateCamera, "UpdateCamera"); 1813 | dukglue_register_function(ctx, &SetCameraPanControl, "SetCameraPanControl"); 1814 | dukglue_register_function(ctx, &SetCameraAltControl, "SetCameraAltControl"); 1815 | dukglue_register_function(ctx, &SetCameraSmoothZoomControl, "SetCameraSmoothZoomControl"); 1816 | dukglue_register_function(ctx, &SetCameraMoveControls, "SetCameraMoveControls"); 1817 | dukglue_register_function(ctx, &SetShapesTexture, "SetShapesTexture"); 1818 | dukglue_register_function(ctx, &DrawPixel, "DrawPixel"); 1819 | dukglue_register_function(ctx, &DrawPixelV, "DrawPixelV"); 1820 | dukglue_register_function(ctx, &DrawLine, "DrawLine"); 1821 | dukglue_register_function(ctx, &DrawLineV, "DrawLineV"); 1822 | dukglue_register_function(ctx, &DrawLineEx, "DrawLineEx"); 1823 | dukglue_register_function(ctx, &DrawLineBezier, "DrawLineBezier"); 1824 | dukglue_register_function(ctx, &DrawLineBezierQuad, "DrawLineBezierQuad"); 1825 | dukglue_register_function(ctx, &DrawLineBezierCubic, "DrawLineBezierCubic"); 1826 | // dukglue_register_function(ctx, &DrawLineStrip, "DrawLineStrip"); 1827 | dukglue_register_function(ctx, &DrawCircle, "DrawCircle"); 1828 | dukglue_register_function(ctx, &DrawCircleSector, "DrawCircleSector"); 1829 | dukglue_register_function(ctx, &DrawCircleSectorLines, "DrawCircleSectorLines"); 1830 | dukglue_register_function(ctx, &DrawCircleGradient, "DrawCircleGradient"); 1831 | dukglue_register_function(ctx, &DrawCircleV, "DrawCircleV"); 1832 | dukglue_register_function(ctx, &DrawCircleLines, "DrawCircleLines"); 1833 | dukglue_register_function(ctx, &DrawEllipse, "DrawEllipse"); 1834 | dukglue_register_function(ctx, &DrawEllipseLines, "DrawEllipseLines"); 1835 | dukglue_register_function(ctx, &DrawRing, "DrawRing"); 1836 | dukglue_register_function(ctx, &DrawRingLines, "DrawRingLines"); 1837 | dukglue_register_function(ctx, &DrawRectangle, "DrawRectangle"); 1838 | dukglue_register_function(ctx, &DrawRectangleV, "DrawRectangleV"); 1839 | dukglue_register_function(ctx, &DrawRectangleRec, "DrawRectangleRec"); 1840 | dukglue_register_function(ctx, &DrawRectanglePro, "DrawRectanglePro"); 1841 | dukglue_register_function(ctx, &DrawRectangleGradientV, "DrawRectangleGradientV"); 1842 | dukglue_register_function(ctx, &DrawRectangleGradientH, "DrawRectangleGradientH"); 1843 | dukglue_register_function(ctx, &DrawRectangleGradientEx, "DrawRectangleGradientEx"); 1844 | dukglue_register_function(ctx, &DrawRectangleLines, "DrawRectangleLines"); 1845 | dukglue_register_function(ctx, &DrawRectangleLinesEx, "DrawRectangleLinesEx"); 1846 | dukglue_register_function(ctx, &DrawRectangleRounded, "DrawRectangleRounded"); 1847 | dukglue_register_function(ctx, &DrawRectangleRoundedLines, "DrawRectangleRoundedLines"); 1848 | dukglue_register_function(ctx, &DrawTriangle, "DrawTriangle"); 1849 | dukglue_register_function(ctx, &DrawTriangleLines, "DrawTriangleLines"); 1850 | // dukglue_register_function(ctx, &DrawTriangleFan, "DrawTriangleFan"); 1851 | // dukglue_register_function(ctx, &DrawTriangleStrip, "DrawTriangleStrip"); 1852 | // dukglue_register_function(ctx, &DrawPoly, "DrawPoly"); 1853 | // dukglue_register_function(ctx, &DrawPolyLines, "DrawPolyLines"); 1854 | // dukglue_register_function(ctx, &DrawPolyLinesEx, "DrawPolyLinesEx"); 1855 | dukglue_register_function(ctx, &CheckCollisionRecs, "CheckCollisionRecs"); 1856 | dukglue_register_function(ctx, &CheckCollisionCircles, "CheckCollisionCircles"); 1857 | dukglue_register_function(ctx, &CheckCollisionCircleRec, "CheckCollisionCircleRec"); 1858 | dukglue_register_function(ctx, &CheckCollisionPointRec, "CheckCollisionPointRec"); 1859 | dukglue_register_function(ctx, &CheckCollisionPointCircle, "CheckCollisionPointCircle"); 1860 | dukglue_register_function(ctx, &CheckCollisionPointTriangle, "CheckCollisionPointTriangle"); 1861 | // dukglue_register_function(ctx, &CheckCollisionLines, "CheckCollisionLines"); 1862 | dukglue_register_function(ctx, &CheckCollisionPointLine, "CheckCollisionPointLine"); 1863 | dukglue_register_function(ctx, &GetCollisionRec, "GetCollisionRec"); 1864 | dukglue_register_function(ctx, &LoadImage, "LoadImage"); 1865 | dukglue_register_function(ctx, &LoadImageRaw, "LoadImageRaw"); 1866 | // dukglue_register_function(ctx, &LoadImageAnim, "LoadImageAnim"); 1867 | // dukglue_register_function(ctx, &LoadImageFromMemory, "LoadImageFromMemory"); 1868 | dukglue_register_function(ctx, &LoadImageFromTexture, "LoadImageFromTexture"); 1869 | dukglue_register_function(ctx, &LoadImageFromScreen, "LoadImageFromScreen"); 1870 | dukglue_register_function(ctx, &UnloadImage, "UnloadImage"); 1871 | dukglue_register_function(ctx, &ExportImage, "ExportImage"); 1872 | dukglue_register_function(ctx, &ExportImageAsCode, "ExportImageAsCode"); 1873 | dukglue_register_function(ctx, &GenImageColor, "GenImageColor"); 1874 | dukglue_register_function(ctx, &GenImageGradientV, "GenImageGradientV"); 1875 | dukglue_register_function(ctx, &GenImageGradientH, "GenImageGradientH"); 1876 | dukglue_register_function(ctx, &GenImageGradientRadial, "GenImageGradientRadial"); 1877 | dukglue_register_function(ctx, &GenImageChecked, "GenImageChecked"); 1878 | dukglue_register_function(ctx, &GenImageWhiteNoise, "GenImageWhiteNoise"); 1879 | dukglue_register_function(ctx, &GenImageCellular, "GenImageCellular"); 1880 | dukglue_register_function(ctx, &ImageCopy, "ImageCopy"); 1881 | dukglue_register_function(ctx, &ImageFromImage, "ImageFromImage"); 1882 | dukglue_register_function(ctx, &ImageText, "ImageText"); 1883 | dukglue_register_function(ctx, &ImageTextEx, "ImageTextEx"); 1884 | // dukglue_register_function(ctx, &ImageFormat, "ImageFormat"); 1885 | // dukglue_register_function(ctx, &ImageToPOT, "ImageToPOT"); 1886 | // dukglue_register_function(ctx, &ImageCrop, "ImageCrop"); 1887 | // dukglue_register_function(ctx, &ImageAlphaCrop, "ImageAlphaCrop"); 1888 | // dukglue_register_function(ctx, &ImageAlphaClear, "ImageAlphaClear"); 1889 | // dukglue_register_function(ctx, &ImageAlphaMask, "ImageAlphaMask"); 1890 | // dukglue_register_function(ctx, &ImageAlphaPremultiply, "ImageAlphaPremultiply"); 1891 | // dukglue_register_function(ctx, &ImageResize, "ImageResize"); 1892 | // dukglue_register_function(ctx, &ImageResizeNN, "ImageResizeNN"); 1893 | // dukglue_register_function(ctx, &ImageResizeCanvas, "ImageResizeCanvas"); 1894 | // dukglue_register_function(ctx, &ImageMipmaps, "ImageMipmaps"); 1895 | // dukglue_register_function(ctx, &ImageDither, "ImageDither"); 1896 | // dukglue_register_function(ctx, &ImageFlipVertical, "ImageFlipVertical"); 1897 | // dukglue_register_function(ctx, &ImageFlipHorizontal, "ImageFlipHorizontal"); 1898 | // dukglue_register_function(ctx, &ImageRotateCW, "ImageRotateCW"); 1899 | // dukglue_register_function(ctx, &ImageRotateCCW, "ImageRotateCCW"); 1900 | // dukglue_register_function(ctx, &ImageColorTint, "ImageColorTint"); 1901 | // dukglue_register_function(ctx, &ImageColorInvert, "ImageColorInvert"); 1902 | // dukglue_register_function(ctx, &ImageColorGrayscale, "ImageColorGrayscale"); 1903 | // dukglue_register_function(ctx, &ImageColorContrast, "ImageColorContrast"); 1904 | // dukglue_register_function(ctx, &ImageColorBrightness, "ImageColorBrightness"); 1905 | // dukglue_register_function(ctx, &ImageColorReplace, "ImageColorReplace"); 1906 | // dukglue_register_function(ctx, &LoadImageColors, "LoadImageColors"); 1907 | // dukglue_register_function(ctx, &LoadImagePalette, "LoadImagePalette"); 1908 | // dukglue_register_function(ctx, &UnloadImageColors, "UnloadImageColors"); 1909 | // dukglue_register_function(ctx, &UnloadImagePalette, "UnloadImagePalette"); 1910 | // dukglue_register_function(ctx, &GetImageAlphaBorder, "GetImageAlphaBorder"); 1911 | // dukglue_register_function(ctx, &GetImageColor, "GetImageColor"); 1912 | // dukglue_register_function(ctx, &ImageClearBackground, "ImageClearBackground"); 1913 | // dukglue_register_function(ctx, &ImageDrawPixel, "ImageDrawPixel"); 1914 | // dukglue_register_function(ctx, &ImageDrawPixelV, "ImageDrawPixelV"); 1915 | // dukglue_register_function(ctx, &ImageDrawLine, "ImageDrawLine"); 1916 | // dukglue_register_function(ctx, &ImageDrawLineV, "ImageDrawLineV"); 1917 | // dukglue_register_function(ctx, &ImageDrawCircle, "ImageDrawCircle"); 1918 | // dukglue_register_function(ctx, &ImageDrawCircleV, "ImageDrawCircleV"); 1919 | // dukglue_register_function(ctx, &ImageDrawRectangle, "ImageDrawRectangle"); 1920 | // dukglue_register_function(ctx, &ImageDrawRectangleV, "ImageDrawRectangleV"); 1921 | // dukglue_register_function(ctx, &ImageDrawRectangleRec, "ImageDrawRectangleRec"); 1922 | // dukglue_register_function(ctx, &ImageDrawRectangleLines, "ImageDrawRectangleLines"); 1923 | // dukglue_register_function(ctx, &ImageDraw, "ImageDraw"); 1924 | // dukglue_register_function(ctx, &ImageDrawText, "ImageDrawText"); 1925 | // dukglue_register_function(ctx, &ImageDrawTextEx, "ImageDrawTextEx"); 1926 | dukglue_register_function(ctx, &LoadTexture, "LoadTexture"); 1927 | dukglue_register_function(ctx, &LoadTextureFromImage, "LoadTextureFromImage"); 1928 | dukglue_register_function(ctx, &LoadTextureCubemap, "LoadTextureCubemap"); 1929 | dukglue_register_function(ctx, &LoadRenderTexture, "LoadRenderTexture"); 1930 | dukglue_register_function(ctx, &UnloadTexture, "UnloadTexture"); 1931 | dukglue_register_function(ctx, &UnloadRenderTexture, "UnloadRenderTexture"); 1932 | // dukglue_register_function(ctx, &UpdateTexture, "UpdateTexture"); 1933 | // dukglue_register_function(ctx, &UpdateTextureRec, "UpdateTextureRec"); 1934 | // dukglue_register_function(ctx, &GenTextureMipmaps, "GenTextureMipmaps"); 1935 | dukglue_register_function(ctx, &SetTextureFilter, "SetTextureFilter"); 1936 | dukglue_register_function(ctx, &SetTextureWrap, "SetTextureWrap"); 1937 | dukglue_register_function(ctx, &DrawTexture, "DrawTexture"); 1938 | dukglue_register_function(ctx, &DrawTextureV, "DrawTextureV"); 1939 | dukglue_register_function(ctx, &DrawTextureEx, "DrawTextureEx"); 1940 | dukglue_register_function(ctx, &DrawTextureRec, "DrawTextureRec"); 1941 | dukglue_register_function(ctx, &DrawTextureQuad, "DrawTextureQuad"); 1942 | dukglue_register_function(ctx, &DrawTextureTiled, "DrawTextureTiled"); 1943 | dukglue_register_function(ctx, &DrawTexturePro, "DrawTexturePro"); 1944 | dukglue_register_function(ctx, &DrawTextureNPatch, "DrawTextureNPatch"); 1945 | // dukglue_register_function(ctx, &DrawTexturePoly, "DrawTexturePoly"); 1946 | dukglue_register_function(ctx, &Fade, "Fade"); 1947 | dukglue_register_function(ctx, &ColorToInt, "ColorToInt"); 1948 | dukglue_register_function(ctx, &ColorNormalize, "ColorNormalize"); 1949 | dukglue_register_function(ctx, &ColorFromNormalized, "ColorFromNormalized"); 1950 | dukglue_register_function(ctx, &ColorToHSV, "ColorToHSV"); 1951 | dukglue_register_function(ctx, &ColorFromHSV, "ColorFromHSV"); 1952 | dukglue_register_function(ctx, &ColorAlpha, "ColorAlpha"); 1953 | dukglue_register_function(ctx, &ColorAlphaBlend, "ColorAlphaBlend"); 1954 | dukglue_register_function(ctx, &GetColor, "GetColor"); 1955 | // dukglue_register_function(ctx, &GetPixelColor, "GetPixelColor"); 1956 | // dukglue_register_function(ctx, &SetPixelColor, "SetPixelColor"); 1957 | // dukglue_register_function(ctx, &GetPixelDataSize, "GetPixelDataSize"); 1958 | dukglue_register_function(ctx, &GetFontDefault, "GetFontDefault"); 1959 | dukglue_register_function(ctx, &LoadFont, "LoadFont"); 1960 | // dukglue_register_function(ctx, &LoadFontEx, "LoadFontEx"); 1961 | dukglue_register_function(ctx, &LoadFontFromImage, "LoadFontFromImage"); 1962 | // dukglue_register_function(ctx, &LoadFontFromMemory, "LoadFontFromMemory"); 1963 | // dukglue_register_function(ctx, &LoadFontData, "LoadFontData"); 1964 | // dukglue_register_function(ctx, &GenImageFontAtlas, "GenImageFontAtlas"); 1965 | // dukglue_register_function(ctx, &UnloadFontData, "UnloadFontData"); 1966 | dukglue_register_function(ctx, &UnloadFont, "UnloadFont"); 1967 | // dukglue_register_function(ctx, &ExportFontAsCode, "ExportFontAsCode"); 1968 | dukglue_register_function(ctx, &DrawFPS, "DrawFPS"); 1969 | dukglue_register_function(ctx, &DrawText, "DrawText"); 1970 | dukglue_register_function(ctx, &DrawTextEx, "DrawTextEx"); 1971 | dukglue_register_function(ctx, &DrawTextPro, "DrawTextPro"); 1972 | dukglue_register_function(ctx, &DrawTextCodepoint, "DrawTextCodepoint"); 1973 | // dukglue_register_function(ctx, &DrawTextCodepoints, "DrawTextCodepoints"); 1974 | dukglue_register_function(ctx, &MeasureText, "MeasureText"); 1975 | dukglue_register_function(ctx, &MeasureTextEx, "MeasureTextEx"); 1976 | dukglue_register_function(ctx, &GetGlyphIndex, "GetGlyphIndex"); 1977 | dukglue_register_function(ctx, &GetGlyphInfo, "GetGlyphInfo"); 1978 | dukglue_register_function(ctx, &GetGlyphAtlasRec, "GetGlyphAtlasRec"); 1979 | // dukglue_register_function(ctx, &LoadCodepoints, "LoadCodepoints"); 1980 | // dukglue_register_function(ctx, &UnloadCodepoints, "UnloadCodepoints"); 1981 | dukglue_register_function(ctx, &GetCodepointCount, "GetCodepointCount"); 1982 | // dukglue_register_function(ctx, &GetCodepoint, "GetCodepoint"); 1983 | // dukglue_register_function(ctx, &CodepointToUTF8, "CodepointToUTF8"); 1984 | // dukglue_register_function(ctx, &TextCodepointsToUTF8, "TextCodepointsToUTF8"); 1985 | // dukglue_register_function(ctx, &TextCopy, "TextCopy"); 1986 | dukglue_register_function(ctx, &TextIsEqual, "TextIsEqual"); 1987 | dukglue_register_function(ctx, &TextLength, "TextLength"); 1988 | // dukglue_register_function(ctx, &TextFormat, "TextFormat"); 1989 | dukglue_register_function(ctx, &TextSubtext, "TextSubtext"); 1990 | // dukglue_register_function(ctx, &TextReplace, "TextReplace"); 1991 | // dukglue_register_function(ctx, &TextInsert, "TextInsert"); 1992 | // dukglue_register_function(ctx, &TextJoin, "TextJoin"); 1993 | // dukglue_register_function(ctx, &TextSplit, "TextSplit"); 1994 | // dukglue_register_function(ctx, &TextAppend, "TextAppend"); 1995 | dukglue_register_function(ctx, &TextFindIndex, "TextFindIndex"); 1996 | dukglue_register_function(ctx, &TextToUpper, "TextToUpper"); 1997 | dukglue_register_function(ctx, &TextToLower, "TextToLower"); 1998 | dukglue_register_function(ctx, &TextToPascal, "TextToPascal"); 1999 | dukglue_register_function(ctx, &TextToInteger, "TextToInteger"); 2000 | dukglue_register_function(ctx, &DrawLine3D, "DrawLine3D"); 2001 | dukglue_register_function(ctx, &DrawPoint3D, "DrawPoint3D"); 2002 | dukglue_register_function(ctx, &DrawCircle3D, "DrawCircle3D"); 2003 | dukglue_register_function(ctx, &DrawTriangle3D, "DrawTriangle3D"); 2004 | // dukglue_register_function(ctx, &DrawTriangleStrip3D, "DrawTriangleStrip3D"); 2005 | dukglue_register_function(ctx, &DrawCube, "DrawCube"); 2006 | dukglue_register_function(ctx, &DrawCubeV, "DrawCubeV"); 2007 | dukglue_register_function(ctx, &DrawCubeWires, "DrawCubeWires"); 2008 | dukglue_register_function(ctx, &DrawCubeWiresV, "DrawCubeWiresV"); 2009 | dukglue_register_function(ctx, &DrawCubeTexture, "DrawCubeTexture"); 2010 | dukglue_register_function(ctx, &DrawCubeTextureRec, "DrawCubeTextureRec"); 2011 | dukglue_register_function(ctx, &DrawSphere, "DrawSphere"); 2012 | dukglue_register_function(ctx, &DrawSphereEx, "DrawSphereEx"); 2013 | dukglue_register_function(ctx, &DrawSphereWires, "DrawSphereWires"); 2014 | dukglue_register_function(ctx, &DrawCylinder, "DrawCylinder"); 2015 | dukglue_register_function(ctx, &DrawCylinderEx, "DrawCylinderEx"); 2016 | dukglue_register_function(ctx, &DrawCylinderWires, "DrawCylinderWires"); 2017 | dukglue_register_function(ctx, &DrawCylinderWiresEx, "DrawCylinderWiresEx"); 2018 | dukglue_register_function(ctx, &DrawPlane, "DrawPlane"); 2019 | dukglue_register_function(ctx, &DrawRay, "DrawRay"); 2020 | dukglue_register_function(ctx, &DrawGrid, "DrawGrid"); 2021 | dukglue_register_function(ctx, &LoadModel, "LoadModel"); 2022 | dukglue_register_function(ctx, &LoadModelFromMesh, "LoadModelFromMesh"); 2023 | dukglue_register_function(ctx, &UnloadModel, "UnloadModel"); 2024 | dukglue_register_function(ctx, &UnloadModelKeepMeshes, "UnloadModelKeepMeshes"); 2025 | dukglue_register_function(ctx, &GetModelBoundingBox, "GetModelBoundingBox"); 2026 | dukglue_register_function(ctx, &DrawModel, "DrawModel"); 2027 | dukglue_register_function(ctx, &DrawModelEx, "DrawModelEx"); 2028 | dukglue_register_function(ctx, &DrawModelWires, "DrawModelWires"); 2029 | dukglue_register_function(ctx, &DrawModelWiresEx, "DrawModelWiresEx"); 2030 | dukglue_register_function(ctx, &DrawBoundingBox, "DrawBoundingBox"); 2031 | dukglue_register_function(ctx, &DrawBillboard, "DrawBillboard"); 2032 | dukglue_register_function(ctx, &DrawBillboardRec, "DrawBillboardRec"); 2033 | dukglue_register_function(ctx, &DrawBillboardPro, "DrawBillboardPro"); 2034 | // dukglue_register_function(ctx, &UploadMesh, "UploadMesh"); 2035 | // dukglue_register_function(ctx, &UpdateMeshBuffer, "UpdateMeshBuffer"); 2036 | dukglue_register_function(ctx, &UnloadMesh, "UnloadMesh"); 2037 | dukglue_register_function(ctx, &DrawMesh, "DrawMesh"); 2038 | // dukglue_register_function(ctx, &DrawMeshInstanced, "DrawMeshInstanced"); 2039 | dukglue_register_function(ctx, &ExportMesh, "ExportMesh"); 2040 | dukglue_register_function(ctx, &GetMeshBoundingBox, "GetMeshBoundingBox"); 2041 | // dukglue_register_function(ctx, &GenMeshTangents, "GenMeshTangents"); 2042 | dukglue_register_function(ctx, &GenMeshPoly, "GenMeshPoly"); 2043 | dukglue_register_function(ctx, &GenMeshPlane, "GenMeshPlane"); 2044 | dukglue_register_function(ctx, &GenMeshCube, "GenMeshCube"); 2045 | dukglue_register_function(ctx, &GenMeshSphere, "GenMeshSphere"); 2046 | dukglue_register_function(ctx, &GenMeshHemiSphere, "GenMeshHemiSphere"); 2047 | dukglue_register_function(ctx, &GenMeshCylinder, "GenMeshCylinder"); 2048 | dukglue_register_function(ctx, &GenMeshCone, "GenMeshCone"); 2049 | dukglue_register_function(ctx, &GenMeshTorus, "GenMeshTorus"); 2050 | dukglue_register_function(ctx, &GenMeshKnot, "GenMeshKnot"); 2051 | dukglue_register_function(ctx, &GenMeshHeightmap, "GenMeshHeightmap"); 2052 | dukglue_register_function(ctx, &GenMeshCubicmap, "GenMeshCubicmap"); 2053 | // dukglue_register_function(ctx, &LoadMaterials, "LoadMaterials"); 2054 | dukglue_register_function(ctx, &LoadMaterialDefault, "LoadMaterialDefault"); 2055 | dukglue_register_function(ctx, &UnloadMaterial, "UnloadMaterial"); 2056 | // dukglue_register_function(ctx, &SetMaterialTexture, "SetMaterialTexture"); 2057 | // dukglue_register_function(ctx, &SetModelMeshMaterial, "SetModelMeshMaterial"); 2058 | // dukglue_register_function(ctx, &LoadModelAnimations, "LoadModelAnimations"); 2059 | dukglue_register_function(ctx, &UpdateModelAnimation, "UpdateModelAnimation"); 2060 | dukglue_register_function(ctx, &UnloadModelAnimation, "UnloadModelAnimation"); 2061 | // dukglue_register_function(ctx, &UnloadModelAnimations, "UnloadModelAnimations"); 2062 | dukglue_register_function(ctx, &IsModelAnimationValid, "IsModelAnimationValid"); 2063 | dukglue_register_function(ctx, &CheckCollisionSpheres, "CheckCollisionSpheres"); 2064 | dukglue_register_function(ctx, &CheckCollisionBoxes, "CheckCollisionBoxes"); 2065 | dukglue_register_function(ctx, &CheckCollisionBoxSphere, "CheckCollisionBoxSphere"); 2066 | dukglue_register_function(ctx, &GetRayCollisionSphere, "GetRayCollisionSphere"); 2067 | dukglue_register_function(ctx, &GetRayCollisionBox, "GetRayCollisionBox"); 2068 | dukglue_register_function(ctx, &GetRayCollisionMesh, "GetRayCollisionMesh"); 2069 | dukglue_register_function(ctx, &GetRayCollisionTriangle, "GetRayCollisionTriangle"); 2070 | dukglue_register_function(ctx, &GetRayCollisionQuad, "GetRayCollisionQuad"); 2071 | dukglue_register_function(ctx, &InitAudioDevice, "InitAudioDevice"); 2072 | dukglue_register_function(ctx, &CloseAudioDevice, "CloseAudioDevice"); 2073 | dukglue_register_function(ctx, &IsAudioDeviceReady, "IsAudioDeviceReady"); 2074 | dukglue_register_function(ctx, &SetMasterVolume, "SetMasterVolume"); 2075 | dukglue_register_function(ctx, &LoadWave, "LoadWave"); 2076 | // dukglue_register_function(ctx, &LoadWaveFromMemory, "LoadWaveFromMemory"); 2077 | dukglue_register_function(ctx, &LoadSound, "LoadSound"); 2078 | dukglue_register_function(ctx, &LoadSoundFromWave, "LoadSoundFromWave"); 2079 | // dukglue_register_function(ctx, &UpdateSound, "UpdateSound"); 2080 | dukglue_register_function(ctx, &UnloadWave, "UnloadWave"); 2081 | dukglue_register_function(ctx, &UnloadSound, "UnloadSound"); 2082 | dukglue_register_function(ctx, &ExportWave, "ExportWave"); 2083 | dukglue_register_function(ctx, &ExportWaveAsCode, "ExportWaveAsCode"); 2084 | dukglue_register_function(ctx, &PlaySound, "PlaySound"); 2085 | dukglue_register_function(ctx, &StopSound, "StopSound"); 2086 | dukglue_register_function(ctx, &PauseSound, "PauseSound"); 2087 | dukglue_register_function(ctx, &ResumeSound, "ResumeSound"); 2088 | dukglue_register_function(ctx, &PlaySoundMulti, "PlaySoundMulti"); 2089 | dukglue_register_function(ctx, &StopSoundMulti, "StopSoundMulti"); 2090 | dukglue_register_function(ctx, &GetSoundsPlaying, "GetSoundsPlaying"); 2091 | dukglue_register_function(ctx, &IsSoundPlaying, "IsSoundPlaying"); 2092 | dukglue_register_function(ctx, &SetSoundVolume, "SetSoundVolume"); 2093 | dukglue_register_function(ctx, &SetSoundPitch, "SetSoundPitch"); 2094 | dukglue_register_function(ctx, &SetSoundPan, "SetSoundPan"); 2095 | dukglue_register_function(ctx, &WaveCopy, "WaveCopy"); 2096 | // dukglue_register_function(ctx, &WaveCrop, "WaveCrop"); 2097 | // dukglue_register_function(ctx, &WaveFormat, "WaveFormat"); 2098 | // dukglue_register_function(ctx, &LoadWaveSamples, "LoadWaveSamples"); 2099 | // dukglue_register_function(ctx, &UnloadWaveSamples, "UnloadWaveSamples"); 2100 | dukglue_register_function(ctx, &LoadMusicStream, "LoadMusicStream"); 2101 | // dukglue_register_function(ctx, &LoadMusicStreamFromMemory, "LoadMusicStreamFromMemory"); 2102 | dukglue_register_function(ctx, &UnloadMusicStream, "UnloadMusicStream"); 2103 | dukglue_register_function(ctx, &PlayMusicStream, "PlayMusicStream"); 2104 | dukglue_register_function(ctx, &IsMusicStreamPlaying, "IsMusicStreamPlaying"); 2105 | dukglue_register_function(ctx, &UpdateMusicStream, "UpdateMusicStream"); 2106 | dukglue_register_function(ctx, &StopMusicStream, "StopMusicStream"); 2107 | dukglue_register_function(ctx, &PauseMusicStream, "PauseMusicStream"); 2108 | dukglue_register_function(ctx, &ResumeMusicStream, "ResumeMusicStream"); 2109 | dukglue_register_function(ctx, &SeekMusicStream, "SeekMusicStream"); 2110 | dukglue_register_function(ctx, &SetMusicVolume, "SetMusicVolume"); 2111 | dukglue_register_function(ctx, &SetMusicPitch, "SetMusicPitch"); 2112 | dukglue_register_function(ctx, &SetMusicPan, "SetMusicPan"); 2113 | dukglue_register_function(ctx, &GetMusicTimeLength, "GetMusicTimeLength"); 2114 | dukglue_register_function(ctx, &GetMusicTimePlayed, "GetMusicTimePlayed"); 2115 | dukglue_register_function(ctx, &LoadAudioStream, "LoadAudioStream"); 2116 | dukglue_register_function(ctx, &UnloadAudioStream, "UnloadAudioStream"); 2117 | // dukglue_register_function(ctx, &UpdateAudioStream, "UpdateAudioStream"); 2118 | dukglue_register_function(ctx, &IsAudioStreamProcessed, "IsAudioStreamProcessed"); 2119 | dukglue_register_function(ctx, &PlayAudioStream, "PlayAudioStream"); 2120 | dukglue_register_function(ctx, &PauseAudioStream, "PauseAudioStream"); 2121 | dukglue_register_function(ctx, &ResumeAudioStream, "ResumeAudioStream"); 2122 | dukglue_register_function(ctx, &IsAudioStreamPlaying, "IsAudioStreamPlaying"); 2123 | dukglue_register_function(ctx, &StopAudioStream, "StopAudioStream"); 2124 | dukglue_register_function(ctx, &SetAudioStreamVolume, "SetAudioStreamVolume"); 2125 | dukglue_register_function(ctx, &SetAudioStreamPitch, "SetAudioStreamPitch"); 2126 | dukglue_register_function(ctx, &SetAudioStreamPan, "SetAudioStreamPan"); 2127 | dukglue_register_function(ctx, &SetAudioStreamBufferSizeDefault, "SetAudioStreamBufferSizeDefault"); 2128 | // dukglue_register_function(ctx, &SetAudioStreamCallback, "SetAudioStreamCallback"); 2129 | // dukglue_register_function(ctx, &AttachAudioStreamProcessor, "AttachAudioStreamProcessor"); 2130 | // dukglue_register_function(ctx, &DetachAudioStreamProcessor, "DetachAudioStreamProcessor"); 2131 | } 2132 | -------------------------------------------------------------------------------- /lib/raylib-duktape.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include "raylib-duktape.h" 6 | 7 | template 8 | T raylib_duktape_get(duk_context* ctx, duk_idx_t idx) { 9 | T* out; 10 | dukglue_read(ctx, idx, out); 11 | return *out; 12 | } 13 | 14 | template 15 | void raylib_duktape_push(duk_context* ctx, T input) { 16 | dukglue_push(ctx, input); 17 | } 18 | 19 | #include "raylib-duktape-gen.h" 20 | void duk_raylib_init(duk_context* ctx, duk_uint_t flags) { 21 | raylib_duktape_gen(ctx); 22 | 23 | // Introduce some contructors. 24 | // TODO: Move these constructors to the structs? 25 | duk_eval_string(ctx, "\ 26 | function Color(red, green, blue, alpha) { return {r: red, g: green, b: blue, a: alpha}} \ 27 | function Vector2(x, y) { return {x:x, y:y}} \ 28 | function Vector3(x, y, z) { return {x:x, y:y, z:z}}" 29 | ); 30 | 31 | } 32 | -------------------------------------------------------------------------------- /lib/raylib-duktape.h: -------------------------------------------------------------------------------- 1 | #ifndef RAYLIB_DUKTAPE_H__ 2 | #define RAYLIB_DUKTAPE_H__ 3 | 4 | #include 5 | 6 | void duk_raylib_init(duk_context* ctx, duk_uint_t flags); 7 | 8 | #endif 9 | -------------------------------------------------------------------------------- /package-lock.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "raylib-duktape", 3 | "version": "0.0.1", 4 | "lockfileVersion": 2, 5 | "requires": true, 6 | "packages": { 7 | "": { 8 | "name": "raylib-duktape", 9 | "version": "0.0.1", 10 | "license": "ISC", 11 | "devDependencies": { 12 | "@raylib/api": "^4.2.0", 13 | "meow": "^10.1.4" 14 | } 15 | }, 16 | "node_modules/@babel/code-frame": { 17 | "version": "7.18.6", 18 | "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", 19 | "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", 20 | "dev": true, 21 | "dependencies": { 22 | "@babel/highlight": "^7.18.6" 23 | }, 24 | "engines": { 25 | "node": ">=6.9.0" 26 | } 27 | }, 28 | "node_modules/@babel/helper-validator-identifier": { 29 | "version": "7.19.1", 30 | "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", 31 | "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", 32 | "dev": true, 33 | "engines": { 34 | "node": ">=6.9.0" 35 | } 36 | }, 37 | "node_modules/@babel/highlight": { 38 | "version": "7.18.6", 39 | "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", 40 | "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", 41 | "dev": true, 42 | "dependencies": { 43 | "@babel/helper-validator-identifier": "^7.18.6", 44 | "chalk": "^2.0.0", 45 | "js-tokens": "^4.0.0" 46 | }, 47 | "engines": { 48 | "node": ">=6.9.0" 49 | } 50 | }, 51 | "node_modules/@raylib/api": { 52 | "version": "4.2.0", 53 | "resolved": "https://registry.npmjs.org/@raylib/api/-/api-4.2.0.tgz", 54 | "integrity": "sha512-YWUpL2zUYYaE5dSkbpUKWkSU6x/z9a9Go7ZPlvusm3BSyDBN7cH0DMrP5mQUo4VoqdpEsm0hfMGt2YOl9anWaQ==", 55 | "dev": true 56 | }, 57 | "node_modules/@types/minimist": { 58 | "version": "1.2.2", 59 | "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz", 60 | "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==", 61 | "dev": true 62 | }, 63 | "node_modules/@types/normalize-package-data": { 64 | "version": "2.4.1", 65 | "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz", 66 | "integrity": "sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==", 67 | "dev": true 68 | }, 69 | "node_modules/ansi-styles": { 70 | "version": "3.2.1", 71 | "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", 72 | "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", 73 | "dev": true, 74 | "dependencies": { 75 | "color-convert": "^1.9.0" 76 | }, 77 | "engines": { 78 | "node": ">=4" 79 | } 80 | }, 81 | "node_modules/arrify": { 82 | "version": "1.0.1", 83 | "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", 84 | "integrity": "sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==", 85 | "dev": true, 86 | "engines": { 87 | "node": ">=0.10.0" 88 | } 89 | }, 90 | "node_modules/camelcase": { 91 | "version": "6.3.0", 92 | "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", 93 | "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", 94 | "dev": true, 95 | "engines": { 96 | "node": ">=10" 97 | }, 98 | "funding": { 99 | "url": "https://github.com/sponsors/sindresorhus" 100 | } 101 | }, 102 | "node_modules/camelcase-keys": { 103 | "version": "7.0.2", 104 | "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-7.0.2.tgz", 105 | "integrity": "sha512-Rjs1H+A9R+Ig+4E/9oyB66UC5Mj9Xq3N//vcLf2WzgdTi/3gUu3Z9KoqmlrEG4VuuLK8wJHofxzdQXz/knhiYg==", 106 | "dev": true, 107 | "dependencies": { 108 | "camelcase": "^6.3.0", 109 | "map-obj": "^4.1.0", 110 | "quick-lru": "^5.1.1", 111 | "type-fest": "^1.2.1" 112 | }, 113 | "engines": { 114 | "node": ">=12" 115 | }, 116 | "funding": { 117 | "url": "https://github.com/sponsors/sindresorhus" 118 | } 119 | }, 120 | "node_modules/chalk": { 121 | "version": "2.4.2", 122 | "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", 123 | "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", 124 | "dev": true, 125 | "dependencies": { 126 | "ansi-styles": "^3.2.1", 127 | "escape-string-regexp": "^1.0.5", 128 | "supports-color": "^5.3.0" 129 | }, 130 | "engines": { 131 | "node": ">=4" 132 | } 133 | }, 134 | "node_modules/color-convert": { 135 | "version": "1.9.3", 136 | "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", 137 | "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", 138 | "dev": true, 139 | "dependencies": { 140 | "color-name": "1.1.3" 141 | } 142 | }, 143 | "node_modules/color-name": { 144 | "version": "1.1.3", 145 | "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", 146 | "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", 147 | "dev": true 148 | }, 149 | "node_modules/decamelize": { 150 | "version": "5.0.1", 151 | "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-5.0.1.tgz", 152 | "integrity": "sha512-VfxadyCECXgQlkoEAjeghAr5gY3Hf+IKjKb+X8tGVDtveCjN+USwprd2q3QXBR9T1+x2DG0XZF5/w+7HAtSaXA==", 153 | "dev": true, 154 | "engines": { 155 | "node": ">=10" 156 | }, 157 | "funding": { 158 | "url": "https://github.com/sponsors/sindresorhus" 159 | } 160 | }, 161 | "node_modules/decamelize-keys": { 162 | "version": "1.1.0", 163 | "resolved": "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz", 164 | "integrity": "sha512-ocLWuYzRPoS9bfiSdDd3cxvrzovVMZnRDVEzAs+hWIVXGDbHxWMECij2OBuyB/An0FFW/nLuq6Kv1i/YC5Qfzg==", 165 | "dev": true, 166 | "dependencies": { 167 | "decamelize": "^1.1.0", 168 | "map-obj": "^1.0.0" 169 | }, 170 | "engines": { 171 | "node": ">=0.10.0" 172 | } 173 | }, 174 | "node_modules/decamelize-keys/node_modules/decamelize": { 175 | "version": "1.2.0", 176 | "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", 177 | "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", 178 | "dev": true, 179 | "engines": { 180 | "node": ">=0.10.0" 181 | } 182 | }, 183 | "node_modules/decamelize-keys/node_modules/map-obj": { 184 | "version": "1.0.1", 185 | "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", 186 | "integrity": "sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==", 187 | "dev": true, 188 | "engines": { 189 | "node": ">=0.10.0" 190 | } 191 | }, 192 | "node_modules/error-ex": { 193 | "version": "1.3.2", 194 | "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", 195 | "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", 196 | "dev": true, 197 | "dependencies": { 198 | "is-arrayish": "^0.2.1" 199 | } 200 | }, 201 | "node_modules/escape-string-regexp": { 202 | "version": "1.0.5", 203 | "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", 204 | "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", 205 | "dev": true, 206 | "engines": { 207 | "node": ">=0.8.0" 208 | } 209 | }, 210 | "node_modules/find-up": { 211 | "version": "5.0.0", 212 | "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", 213 | "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", 214 | "dev": true, 215 | "dependencies": { 216 | "locate-path": "^6.0.0", 217 | "path-exists": "^4.0.0" 218 | }, 219 | "engines": { 220 | "node": ">=10" 221 | }, 222 | "funding": { 223 | "url": "https://github.com/sponsors/sindresorhus" 224 | } 225 | }, 226 | "node_modules/function-bind": { 227 | "version": "1.1.1", 228 | "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", 229 | "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", 230 | "dev": true 231 | }, 232 | "node_modules/hard-rejection": { 233 | "version": "2.1.0", 234 | "resolved": "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz", 235 | "integrity": "sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==", 236 | "dev": true, 237 | "engines": { 238 | "node": ">=6" 239 | } 240 | }, 241 | "node_modules/has": { 242 | "version": "1.0.3", 243 | "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", 244 | "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", 245 | "dev": true, 246 | "dependencies": { 247 | "function-bind": "^1.1.1" 248 | }, 249 | "engines": { 250 | "node": ">= 0.4.0" 251 | } 252 | }, 253 | "node_modules/has-flag": { 254 | "version": "3.0.0", 255 | "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", 256 | "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", 257 | "dev": true, 258 | "engines": { 259 | "node": ">=4" 260 | } 261 | }, 262 | "node_modules/hosted-git-info": { 263 | "version": "4.1.0", 264 | "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", 265 | "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", 266 | "dev": true, 267 | "dependencies": { 268 | "lru-cache": "^6.0.0" 269 | }, 270 | "engines": { 271 | "node": ">=10" 272 | } 273 | }, 274 | "node_modules/indent-string": { 275 | "version": "5.0.0", 276 | "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz", 277 | "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==", 278 | "dev": true, 279 | "engines": { 280 | "node": ">=12" 281 | }, 282 | "funding": { 283 | "url": "https://github.com/sponsors/sindresorhus" 284 | } 285 | }, 286 | "node_modules/is-arrayish": { 287 | "version": "0.2.1", 288 | "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", 289 | "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", 290 | "dev": true 291 | }, 292 | "node_modules/is-core-module": { 293 | "version": "2.10.0", 294 | "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz", 295 | "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==", 296 | "dev": true, 297 | "dependencies": { 298 | "has": "^1.0.3" 299 | }, 300 | "funding": { 301 | "url": "https://github.com/sponsors/ljharb" 302 | } 303 | }, 304 | "node_modules/is-plain-obj": { 305 | "version": "1.1.0", 306 | "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", 307 | "integrity": "sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==", 308 | "dev": true, 309 | "engines": { 310 | "node": ">=0.10.0" 311 | } 312 | }, 313 | "node_modules/js-tokens": { 314 | "version": "4.0.0", 315 | "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", 316 | "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", 317 | "dev": true 318 | }, 319 | "node_modules/json-parse-even-better-errors": { 320 | "version": "2.3.1", 321 | "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", 322 | "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", 323 | "dev": true 324 | }, 325 | "node_modules/kind-of": { 326 | "version": "6.0.3", 327 | "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", 328 | "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", 329 | "dev": true, 330 | "engines": { 331 | "node": ">=0.10.0" 332 | } 333 | }, 334 | "node_modules/lines-and-columns": { 335 | "version": "1.2.4", 336 | "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", 337 | "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", 338 | "dev": true 339 | }, 340 | "node_modules/locate-path": { 341 | "version": "6.0.0", 342 | "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", 343 | "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", 344 | "dev": true, 345 | "dependencies": { 346 | "p-locate": "^5.0.0" 347 | }, 348 | "engines": { 349 | "node": ">=10" 350 | }, 351 | "funding": { 352 | "url": "https://github.com/sponsors/sindresorhus" 353 | } 354 | }, 355 | "node_modules/lru-cache": { 356 | "version": "6.0.0", 357 | "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", 358 | "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", 359 | "dev": true, 360 | "dependencies": { 361 | "yallist": "^4.0.0" 362 | }, 363 | "engines": { 364 | "node": ">=10" 365 | } 366 | }, 367 | "node_modules/map-obj": { 368 | "version": "4.3.0", 369 | "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz", 370 | "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==", 371 | "dev": true, 372 | "engines": { 373 | "node": ">=8" 374 | }, 375 | "funding": { 376 | "url": "https://github.com/sponsors/sindresorhus" 377 | } 378 | }, 379 | "node_modules/meow": { 380 | "version": "10.1.4", 381 | "resolved": "https://registry.npmjs.org/meow/-/meow-10.1.4.tgz", 382 | "integrity": "sha512-FAlXANqPxtd6Od1kTzm39cHbhYn5t/TI0pP5yV9bmzteII7+couYcU+T9sgbzCgi0KVdiw85aRie9UBUfucYvQ==", 383 | "dev": true, 384 | "dependencies": { 385 | "@types/minimist": "^1.2.2", 386 | "camelcase-keys": "^7.0.0", 387 | "decamelize": "^5.0.0", 388 | "decamelize-keys": "^1.1.0", 389 | "hard-rejection": "^2.1.0", 390 | "minimist-options": "4.1.0", 391 | "normalize-package-data": "^3.0.2", 392 | "read-pkg-up": "^8.0.0", 393 | "redent": "^4.0.0", 394 | "trim-newlines": "^4.0.2", 395 | "type-fest": "^1.2.2", 396 | "yargs-parser": "^20.2.9" 397 | }, 398 | "engines": { 399 | "node": "^12.20.0 || ^14.13.1 || >=16.0.0" 400 | }, 401 | "funding": { 402 | "url": "https://github.com/sponsors/sindresorhus" 403 | } 404 | }, 405 | "node_modules/min-indent": { 406 | "version": "1.0.1", 407 | "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", 408 | "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", 409 | "dev": true, 410 | "engines": { 411 | "node": ">=4" 412 | } 413 | }, 414 | "node_modules/minimist-options": { 415 | "version": "4.1.0", 416 | "resolved": "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz", 417 | "integrity": "sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==", 418 | "dev": true, 419 | "dependencies": { 420 | "arrify": "^1.0.1", 421 | "is-plain-obj": "^1.1.0", 422 | "kind-of": "^6.0.3" 423 | }, 424 | "engines": { 425 | "node": ">= 6" 426 | } 427 | }, 428 | "node_modules/normalize-package-data": { 429 | "version": "3.0.3", 430 | "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz", 431 | "integrity": "sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==", 432 | "dev": true, 433 | "dependencies": { 434 | "hosted-git-info": "^4.0.1", 435 | "is-core-module": "^2.5.0", 436 | "semver": "^7.3.4", 437 | "validate-npm-package-license": "^3.0.1" 438 | }, 439 | "engines": { 440 | "node": ">=10" 441 | } 442 | }, 443 | "node_modules/p-limit": { 444 | "version": "3.1.0", 445 | "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", 446 | "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", 447 | "dev": true, 448 | "dependencies": { 449 | "yocto-queue": "^0.1.0" 450 | }, 451 | "engines": { 452 | "node": ">=10" 453 | }, 454 | "funding": { 455 | "url": "https://github.com/sponsors/sindresorhus" 456 | } 457 | }, 458 | "node_modules/p-locate": { 459 | "version": "5.0.0", 460 | "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", 461 | "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", 462 | "dev": true, 463 | "dependencies": { 464 | "p-limit": "^3.0.2" 465 | }, 466 | "engines": { 467 | "node": ">=10" 468 | }, 469 | "funding": { 470 | "url": "https://github.com/sponsors/sindresorhus" 471 | } 472 | }, 473 | "node_modules/parse-json": { 474 | "version": "5.2.0", 475 | "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", 476 | "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", 477 | "dev": true, 478 | "dependencies": { 479 | "@babel/code-frame": "^7.0.0", 480 | "error-ex": "^1.3.1", 481 | "json-parse-even-better-errors": "^2.3.0", 482 | "lines-and-columns": "^1.1.6" 483 | }, 484 | "engines": { 485 | "node": ">=8" 486 | }, 487 | "funding": { 488 | "url": "https://github.com/sponsors/sindresorhus" 489 | } 490 | }, 491 | "node_modules/path-exists": { 492 | "version": "4.0.0", 493 | "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", 494 | "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", 495 | "dev": true, 496 | "engines": { 497 | "node": ">=8" 498 | } 499 | }, 500 | "node_modules/quick-lru": { 501 | "version": "5.1.1", 502 | "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", 503 | "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", 504 | "dev": true, 505 | "engines": { 506 | "node": ">=10" 507 | }, 508 | "funding": { 509 | "url": "https://github.com/sponsors/sindresorhus" 510 | } 511 | }, 512 | "node_modules/read-pkg": { 513 | "version": "6.0.0", 514 | "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-6.0.0.tgz", 515 | "integrity": "sha512-X1Fu3dPuk/8ZLsMhEj5f4wFAF0DWoK7qhGJvgaijocXxBmSToKfbFtqbxMO7bVjNA1dmE5huAzjXj/ey86iw9Q==", 516 | "dev": true, 517 | "dependencies": { 518 | "@types/normalize-package-data": "^2.4.0", 519 | "normalize-package-data": "^3.0.2", 520 | "parse-json": "^5.2.0", 521 | "type-fest": "^1.0.1" 522 | }, 523 | "engines": { 524 | "node": ">=12" 525 | }, 526 | "funding": { 527 | "url": "https://github.com/sponsors/sindresorhus" 528 | } 529 | }, 530 | "node_modules/read-pkg-up": { 531 | "version": "8.0.0", 532 | "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-8.0.0.tgz", 533 | "integrity": "sha512-snVCqPczksT0HS2EC+SxUndvSzn6LRCwpfSvLrIfR5BKDQQZMaI6jPRC9dYvYFDRAuFEAnkwww8kBBNE/3VvzQ==", 534 | "dev": true, 535 | "dependencies": { 536 | "find-up": "^5.0.0", 537 | "read-pkg": "^6.0.0", 538 | "type-fest": "^1.0.1" 539 | }, 540 | "engines": { 541 | "node": ">=12" 542 | }, 543 | "funding": { 544 | "url": "https://github.com/sponsors/sindresorhus" 545 | } 546 | }, 547 | "node_modules/redent": { 548 | "version": "4.0.0", 549 | "resolved": "https://registry.npmjs.org/redent/-/redent-4.0.0.tgz", 550 | "integrity": "sha512-tYkDkVVtYkSVhuQ4zBgfvciymHaeuel+zFKXShfDnFP5SyVEP7qo70Rf1jTOTCx3vGNAbnEi/xFkcfQVMIBWag==", 551 | "dev": true, 552 | "dependencies": { 553 | "indent-string": "^5.0.0", 554 | "strip-indent": "^4.0.0" 555 | }, 556 | "engines": { 557 | "node": ">=12" 558 | }, 559 | "funding": { 560 | "url": "https://github.com/sponsors/sindresorhus" 561 | } 562 | }, 563 | "node_modules/semver": { 564 | "version": "7.3.7", 565 | "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", 566 | "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", 567 | "dev": true, 568 | "dependencies": { 569 | "lru-cache": "^6.0.0" 570 | }, 571 | "bin": { 572 | "semver": "bin/semver.js" 573 | }, 574 | "engines": { 575 | "node": ">=10" 576 | } 577 | }, 578 | "node_modules/spdx-correct": { 579 | "version": "3.1.1", 580 | "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", 581 | "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", 582 | "dev": true, 583 | "dependencies": { 584 | "spdx-expression-parse": "^3.0.0", 585 | "spdx-license-ids": "^3.0.0" 586 | } 587 | }, 588 | "node_modules/spdx-exceptions": { 589 | "version": "2.3.0", 590 | "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", 591 | "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", 592 | "dev": true 593 | }, 594 | "node_modules/spdx-expression-parse": { 595 | "version": "3.0.1", 596 | "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", 597 | "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", 598 | "dev": true, 599 | "dependencies": { 600 | "spdx-exceptions": "^2.1.0", 601 | "spdx-license-ids": "^3.0.0" 602 | } 603 | }, 604 | "node_modules/spdx-license-ids": { 605 | "version": "3.0.12", 606 | "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz", 607 | "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==", 608 | "dev": true 609 | }, 610 | "node_modules/strip-indent": { 611 | "version": "4.0.0", 612 | "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-4.0.0.tgz", 613 | "integrity": "sha512-mnVSV2l+Zv6BLpSD/8V87CW/y9EmmbYzGCIavsnsI6/nwn26DwffM/yztm30Z/I2DY9wdS3vXVCMnHDgZaVNoA==", 614 | "dev": true, 615 | "dependencies": { 616 | "min-indent": "^1.0.1" 617 | }, 618 | "engines": { 619 | "node": ">=12" 620 | }, 621 | "funding": { 622 | "url": "https://github.com/sponsors/sindresorhus" 623 | } 624 | }, 625 | "node_modules/supports-color": { 626 | "version": "5.5.0", 627 | "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", 628 | "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", 629 | "dev": true, 630 | "dependencies": { 631 | "has-flag": "^3.0.0" 632 | }, 633 | "engines": { 634 | "node": ">=4" 635 | } 636 | }, 637 | "node_modules/trim-newlines": { 638 | "version": "4.0.2", 639 | "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-4.0.2.tgz", 640 | "integrity": "sha512-GJtWyq9InR/2HRiLZgpIKv+ufIKrVrvjQWEj7PxAXNc5dwbNJkqhAUoAGgzRmULAnoOM5EIpveYd3J2VeSAIew==", 641 | "dev": true, 642 | "engines": { 643 | "node": ">=12" 644 | }, 645 | "funding": { 646 | "url": "https://github.com/sponsors/sindresorhus" 647 | } 648 | }, 649 | "node_modules/type-fest": { 650 | "version": "1.4.0", 651 | "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz", 652 | "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==", 653 | "dev": true, 654 | "engines": { 655 | "node": ">=10" 656 | }, 657 | "funding": { 658 | "url": "https://github.com/sponsors/sindresorhus" 659 | } 660 | }, 661 | "node_modules/validate-npm-package-license": { 662 | "version": "3.0.4", 663 | "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", 664 | "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", 665 | "dev": true, 666 | "dependencies": { 667 | "spdx-correct": "^3.0.0", 668 | "spdx-expression-parse": "^3.0.0" 669 | } 670 | }, 671 | "node_modules/yallist": { 672 | "version": "4.0.0", 673 | "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", 674 | "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", 675 | "dev": true 676 | }, 677 | "node_modules/yargs-parser": { 678 | "version": "20.2.9", 679 | "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", 680 | "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", 681 | "dev": true, 682 | "engines": { 683 | "node": ">=10" 684 | } 685 | }, 686 | "node_modules/yocto-queue": { 687 | "version": "0.1.0", 688 | "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", 689 | "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", 690 | "dev": true, 691 | "engines": { 692 | "node": ">=10" 693 | }, 694 | "funding": { 695 | "url": "https://github.com/sponsors/sindresorhus" 696 | } 697 | } 698 | }, 699 | "dependencies": { 700 | "@babel/code-frame": { 701 | "version": "7.18.6", 702 | "resolved": "https://registry.npmjs.org/@babel/code-frame/-/code-frame-7.18.6.tgz", 703 | "integrity": "sha512-TDCmlK5eOvH+eH7cdAFlNXeVJqWIQ7gW9tY1GJIpUtFb6CmjVyq2VM3u71bOyR8CRihcCgMUYoDNyLXao3+70Q==", 704 | "dev": true, 705 | "requires": { 706 | "@babel/highlight": "^7.18.6" 707 | } 708 | }, 709 | "@babel/helper-validator-identifier": { 710 | "version": "7.19.1", 711 | "resolved": "https://registry.npmjs.org/@babel/helper-validator-identifier/-/helper-validator-identifier-7.19.1.tgz", 712 | "integrity": "sha512-awrNfaMtnHUr653GgGEs++LlAvW6w+DcPrOliSMXWCKo597CwL5Acf/wWdNkf/tfEQE3mjkeD1YOVZOUV/od1w==", 713 | "dev": true 714 | }, 715 | "@babel/highlight": { 716 | "version": "7.18.6", 717 | "resolved": "https://registry.npmjs.org/@babel/highlight/-/highlight-7.18.6.tgz", 718 | "integrity": "sha512-u7stbOuYjaPezCuLj29hNW1v64M2Md2qupEKP1fHc7WdOA3DgLh37suiSrZYY7haUB7iBeQZ9P1uiRF359do3g==", 719 | "dev": true, 720 | "requires": { 721 | "@babel/helper-validator-identifier": "^7.18.6", 722 | "chalk": "^2.0.0", 723 | "js-tokens": "^4.0.0" 724 | } 725 | }, 726 | "@raylib/api": { 727 | "version": "4.2.0", 728 | "resolved": "https://registry.npmjs.org/@raylib/api/-/api-4.2.0.tgz", 729 | "integrity": "sha512-YWUpL2zUYYaE5dSkbpUKWkSU6x/z9a9Go7ZPlvusm3BSyDBN7cH0DMrP5mQUo4VoqdpEsm0hfMGt2YOl9anWaQ==", 730 | "dev": true 731 | }, 732 | "@types/minimist": { 733 | "version": "1.2.2", 734 | "resolved": "https://registry.npmjs.org/@types/minimist/-/minimist-1.2.2.tgz", 735 | "integrity": "sha512-jhuKLIRrhvCPLqwPcx6INqmKeiA5EWrsCOPhrlFSrbrmU4ZMPjj5Ul/oLCMDO98XRUIwVm78xICz4EPCektzeQ==", 736 | "dev": true 737 | }, 738 | "@types/normalize-package-data": { 739 | "version": "2.4.1", 740 | "resolved": "https://registry.npmjs.org/@types/normalize-package-data/-/normalize-package-data-2.4.1.tgz", 741 | "integrity": "sha512-Gj7cI7z+98M282Tqmp2K5EIsoouUEzbBJhQQzDE3jSIRk6r9gsz0oUokqIUR4u1R3dMHo0pDHM7sNOHyhulypw==", 742 | "dev": true 743 | }, 744 | "ansi-styles": { 745 | "version": "3.2.1", 746 | "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz", 747 | "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==", 748 | "dev": true, 749 | "requires": { 750 | "color-convert": "^1.9.0" 751 | } 752 | }, 753 | "arrify": { 754 | "version": "1.0.1", 755 | "resolved": "https://registry.npmjs.org/arrify/-/arrify-1.0.1.tgz", 756 | "integrity": "sha512-3CYzex9M9FGQjCGMGyi6/31c8GJbgb0qGyrx5HWxPd0aCwh4cB2YjMb2Xf9UuoogrMrlO9cTqnB5rI5GHZTcUA==", 757 | "dev": true 758 | }, 759 | "camelcase": { 760 | "version": "6.3.0", 761 | "resolved": "https://registry.npmjs.org/camelcase/-/camelcase-6.3.0.tgz", 762 | "integrity": "sha512-Gmy6FhYlCY7uOElZUSbxo2UCDH8owEk996gkbrpsgGtrJLM3J7jGxl9Ic7Qwwj4ivOE5AWZWRMecDdF7hqGjFA==", 763 | "dev": true 764 | }, 765 | "camelcase-keys": { 766 | "version": "7.0.2", 767 | "resolved": "https://registry.npmjs.org/camelcase-keys/-/camelcase-keys-7.0.2.tgz", 768 | "integrity": "sha512-Rjs1H+A9R+Ig+4E/9oyB66UC5Mj9Xq3N//vcLf2WzgdTi/3gUu3Z9KoqmlrEG4VuuLK8wJHofxzdQXz/knhiYg==", 769 | "dev": true, 770 | "requires": { 771 | "camelcase": "^6.3.0", 772 | "map-obj": "^4.1.0", 773 | "quick-lru": "^5.1.1", 774 | "type-fest": "^1.2.1" 775 | } 776 | }, 777 | "chalk": { 778 | "version": "2.4.2", 779 | "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz", 780 | "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==", 781 | "dev": true, 782 | "requires": { 783 | "ansi-styles": "^3.2.1", 784 | "escape-string-regexp": "^1.0.5", 785 | "supports-color": "^5.3.0" 786 | } 787 | }, 788 | "color-convert": { 789 | "version": "1.9.3", 790 | "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz", 791 | "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==", 792 | "dev": true, 793 | "requires": { 794 | "color-name": "1.1.3" 795 | } 796 | }, 797 | "color-name": { 798 | "version": "1.1.3", 799 | "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz", 800 | "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==", 801 | "dev": true 802 | }, 803 | "decamelize": { 804 | "version": "5.0.1", 805 | "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-5.0.1.tgz", 806 | "integrity": "sha512-VfxadyCECXgQlkoEAjeghAr5gY3Hf+IKjKb+X8tGVDtveCjN+USwprd2q3QXBR9T1+x2DG0XZF5/w+7HAtSaXA==", 807 | "dev": true 808 | }, 809 | "decamelize-keys": { 810 | "version": "1.1.0", 811 | "resolved": "https://registry.npmjs.org/decamelize-keys/-/decamelize-keys-1.1.0.tgz", 812 | "integrity": "sha512-ocLWuYzRPoS9bfiSdDd3cxvrzovVMZnRDVEzAs+hWIVXGDbHxWMECij2OBuyB/An0FFW/nLuq6Kv1i/YC5Qfzg==", 813 | "dev": true, 814 | "requires": { 815 | "decamelize": "^1.1.0", 816 | "map-obj": "^1.0.0" 817 | }, 818 | "dependencies": { 819 | "decamelize": { 820 | "version": "1.2.0", 821 | "resolved": "https://registry.npmjs.org/decamelize/-/decamelize-1.2.0.tgz", 822 | "integrity": "sha512-z2S+W9X73hAUUki+N+9Za2lBlun89zigOyGrsax+KUQ6wKW4ZoWpEYBkGhQjwAjjDCkWxhY0VKEhk8wzY7F5cA==", 823 | "dev": true 824 | }, 825 | "map-obj": { 826 | "version": "1.0.1", 827 | "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-1.0.1.tgz", 828 | "integrity": "sha512-7N/q3lyZ+LVCp7PzuxrJr4KMbBE2hW7BT7YNia330OFxIf4d3r5zVpicP2650l7CPN6RM9zOJRl3NGpqSiw3Eg==", 829 | "dev": true 830 | } 831 | } 832 | }, 833 | "error-ex": { 834 | "version": "1.3.2", 835 | "resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.2.tgz", 836 | "integrity": "sha512-7dFHNmqeFSEt2ZBsCriorKnn3Z2pj+fd9kmI6QoWw4//DL+icEBfc0U7qJCisqrTsKTjw4fNFy2pW9OqStD84g==", 837 | "dev": true, 838 | "requires": { 839 | "is-arrayish": "^0.2.1" 840 | } 841 | }, 842 | "escape-string-regexp": { 843 | "version": "1.0.5", 844 | "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz", 845 | "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==", 846 | "dev": true 847 | }, 848 | "find-up": { 849 | "version": "5.0.0", 850 | "resolved": "https://registry.npmjs.org/find-up/-/find-up-5.0.0.tgz", 851 | "integrity": "sha512-78/PXT1wlLLDgTzDs7sjq9hzz0vXD+zn+7wypEe4fXQxCmdmqfGsEPQxmiCSQI3ajFV91bVSsvNtrJRiW6nGng==", 852 | "dev": true, 853 | "requires": { 854 | "locate-path": "^6.0.0", 855 | "path-exists": "^4.0.0" 856 | } 857 | }, 858 | "function-bind": { 859 | "version": "1.1.1", 860 | "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.1.tgz", 861 | "integrity": "sha512-yIovAzMX49sF8Yl58fSCWJ5svSLuaibPxXQJFLmBObTuCr0Mf1KiPopGM9NiFjiYBCbfaa2Fh6breQ6ANVTI0A==", 862 | "dev": true 863 | }, 864 | "hard-rejection": { 865 | "version": "2.1.0", 866 | "resolved": "https://registry.npmjs.org/hard-rejection/-/hard-rejection-2.1.0.tgz", 867 | "integrity": "sha512-VIZB+ibDhx7ObhAe7OVtoEbuP4h/MuOTHJ+J8h/eBXotJYl0fBgR72xDFCKgIh22OJZIOVNxBMWuhAr10r8HdA==", 868 | "dev": true 869 | }, 870 | "has": { 871 | "version": "1.0.3", 872 | "resolved": "https://registry.npmjs.org/has/-/has-1.0.3.tgz", 873 | "integrity": "sha512-f2dvO0VU6Oej7RkWJGrehjbzMAjFp5/VKPp5tTpWIV4JHHZK1/BxbFRtf/siA2SWTe09caDmVtYYzWEIbBS4zw==", 874 | "dev": true, 875 | "requires": { 876 | "function-bind": "^1.1.1" 877 | } 878 | }, 879 | "has-flag": { 880 | "version": "3.0.0", 881 | "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz", 882 | "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==", 883 | "dev": true 884 | }, 885 | "hosted-git-info": { 886 | "version": "4.1.0", 887 | "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz", 888 | "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==", 889 | "dev": true, 890 | "requires": { 891 | "lru-cache": "^6.0.0" 892 | } 893 | }, 894 | "indent-string": { 895 | "version": "5.0.0", 896 | "resolved": "https://registry.npmjs.org/indent-string/-/indent-string-5.0.0.tgz", 897 | "integrity": "sha512-m6FAo/spmsW2Ab2fU35JTYwtOKa2yAwXSwgjSv1TJzh4Mh7mC3lzAOVLBprb72XsTrgkEIsl7YrFNAiDiRhIGg==", 898 | "dev": true 899 | }, 900 | "is-arrayish": { 901 | "version": "0.2.1", 902 | "resolved": "https://registry.npmjs.org/is-arrayish/-/is-arrayish-0.2.1.tgz", 903 | "integrity": "sha512-zz06S8t0ozoDXMG+ube26zeCTNXcKIPJZJi8hBrF4idCLms4CG9QtK7qBl1boi5ODzFpjswb5JPmHCbMpjaYzg==", 904 | "dev": true 905 | }, 906 | "is-core-module": { 907 | "version": "2.10.0", 908 | "resolved": "https://registry.npmjs.org/is-core-module/-/is-core-module-2.10.0.tgz", 909 | "integrity": "sha512-Erxj2n/LDAZ7H8WNJXd9tw38GYM3dv8rk8Zcs+jJuxYTW7sozH+SS8NtrSjVL1/vpLvWi1hxy96IzjJ3EHTJJg==", 910 | "dev": true, 911 | "requires": { 912 | "has": "^1.0.3" 913 | } 914 | }, 915 | "is-plain-obj": { 916 | "version": "1.1.0", 917 | "resolved": "https://registry.npmjs.org/is-plain-obj/-/is-plain-obj-1.1.0.tgz", 918 | "integrity": "sha512-yvkRyxmFKEOQ4pNXCmJG5AEQNlXJS5LaONXo5/cLdTZdWvsZ1ioJEonLGAosKlMWE8lwUy/bJzMjcw8az73+Fg==", 919 | "dev": true 920 | }, 921 | "js-tokens": { 922 | "version": "4.0.0", 923 | "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz", 924 | "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==", 925 | "dev": true 926 | }, 927 | "json-parse-even-better-errors": { 928 | "version": "2.3.1", 929 | "resolved": "https://registry.npmjs.org/json-parse-even-better-errors/-/json-parse-even-better-errors-2.3.1.tgz", 930 | "integrity": "sha512-xyFwyhro/JEof6Ghe2iz2NcXoj2sloNsWr/XsERDK/oiPCfaNhl5ONfp+jQdAZRQQ0IJWNzH9zIZF7li91kh2w==", 931 | "dev": true 932 | }, 933 | "kind-of": { 934 | "version": "6.0.3", 935 | "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz", 936 | "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==", 937 | "dev": true 938 | }, 939 | "lines-and-columns": { 940 | "version": "1.2.4", 941 | "resolved": "https://registry.npmjs.org/lines-and-columns/-/lines-and-columns-1.2.4.tgz", 942 | "integrity": "sha512-7ylylesZQ/PV29jhEDl3Ufjo6ZX7gCqJr5F7PKrqc93v7fzSymt1BpwEU8nAUXs8qzzvqhbjhK5QZg6Mt/HkBg==", 943 | "dev": true 944 | }, 945 | "locate-path": { 946 | "version": "6.0.0", 947 | "resolved": "https://registry.npmjs.org/locate-path/-/locate-path-6.0.0.tgz", 948 | "integrity": "sha512-iPZK6eYjbxRu3uB4/WZ3EsEIMJFMqAoopl3R+zuq0UjcAm/MO6KCweDgPfP3elTztoKP3KtnVHxTn2NHBSDVUw==", 949 | "dev": true, 950 | "requires": { 951 | "p-locate": "^5.0.0" 952 | } 953 | }, 954 | "lru-cache": { 955 | "version": "6.0.0", 956 | "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz", 957 | "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==", 958 | "dev": true, 959 | "requires": { 960 | "yallist": "^4.0.0" 961 | } 962 | }, 963 | "map-obj": { 964 | "version": "4.3.0", 965 | "resolved": "https://registry.npmjs.org/map-obj/-/map-obj-4.3.0.tgz", 966 | "integrity": "sha512-hdN1wVrZbb29eBGiGjJbeP8JbKjq1urkHJ/LIP/NY48MZ1QVXUsQBV1G1zvYFHn1XE06cwjBsOI2K3Ulnj1YXQ==", 967 | "dev": true 968 | }, 969 | "meow": { 970 | "version": "10.1.4", 971 | "resolved": "https://registry.npmjs.org/meow/-/meow-10.1.4.tgz", 972 | "integrity": "sha512-FAlXANqPxtd6Od1kTzm39cHbhYn5t/TI0pP5yV9bmzteII7+couYcU+T9sgbzCgi0KVdiw85aRie9UBUfucYvQ==", 973 | "dev": true, 974 | "requires": { 975 | "@types/minimist": "^1.2.2", 976 | "camelcase-keys": "^7.0.0", 977 | "decamelize": "^5.0.0", 978 | "decamelize-keys": "^1.1.0", 979 | "hard-rejection": "^2.1.0", 980 | "minimist-options": "4.1.0", 981 | "normalize-package-data": "^3.0.2", 982 | "read-pkg-up": "^8.0.0", 983 | "redent": "^4.0.0", 984 | "trim-newlines": "^4.0.2", 985 | "type-fest": "^1.2.2", 986 | "yargs-parser": "^20.2.9" 987 | } 988 | }, 989 | "min-indent": { 990 | "version": "1.0.1", 991 | "resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz", 992 | "integrity": "sha512-I9jwMn07Sy/IwOj3zVkVik2JTvgpaykDZEigL6Rx6N9LbMywwUSMtxET+7lVoDLLd3O3IXwJwvuuns8UB/HeAg==", 993 | "dev": true 994 | }, 995 | "minimist-options": { 996 | "version": "4.1.0", 997 | "resolved": "https://registry.npmjs.org/minimist-options/-/minimist-options-4.1.0.tgz", 998 | "integrity": "sha512-Q4r8ghd80yhO/0j1O3B2BjweX3fiHg9cdOwjJd2J76Q135c+NDxGCqdYKQ1SKBuFfgWbAUzBfvYjPUEeNgqN1A==", 999 | "dev": true, 1000 | "requires": { 1001 | "arrify": "^1.0.1", 1002 | "is-plain-obj": "^1.1.0", 1003 | "kind-of": "^6.0.3" 1004 | } 1005 | }, 1006 | "normalize-package-data": { 1007 | "version": "3.0.3", 1008 | "resolved": "https://registry.npmjs.org/normalize-package-data/-/normalize-package-data-3.0.3.tgz", 1009 | "integrity": "sha512-p2W1sgqij3zMMyRC067Dg16bfzVH+w7hyegmpIvZ4JNjqtGOVAIvLmjBx3yP7YTe9vKJgkoNOPjwQGogDoMXFA==", 1010 | "dev": true, 1011 | "requires": { 1012 | "hosted-git-info": "^4.0.1", 1013 | "is-core-module": "^2.5.0", 1014 | "semver": "^7.3.4", 1015 | "validate-npm-package-license": "^3.0.1" 1016 | } 1017 | }, 1018 | "p-limit": { 1019 | "version": "3.1.0", 1020 | "resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz", 1021 | "integrity": "sha512-TYOanM3wGwNGsZN2cVTYPArw454xnXj5qmWF1bEoAc4+cU/ol7GVh7odevjp1FNHduHc3KZMcFduxU5Xc6uJRQ==", 1022 | "dev": true, 1023 | "requires": { 1024 | "yocto-queue": "^0.1.0" 1025 | } 1026 | }, 1027 | "p-locate": { 1028 | "version": "5.0.0", 1029 | "resolved": "https://registry.npmjs.org/p-locate/-/p-locate-5.0.0.tgz", 1030 | "integrity": "sha512-LaNjtRWUBY++zB5nE/NwcaoMylSPk+S+ZHNB1TzdbMJMny6dynpAGt7X/tl/QYq3TIeE6nxHppbo2LGymrG5Pw==", 1031 | "dev": true, 1032 | "requires": { 1033 | "p-limit": "^3.0.2" 1034 | } 1035 | }, 1036 | "parse-json": { 1037 | "version": "5.2.0", 1038 | "resolved": "https://registry.npmjs.org/parse-json/-/parse-json-5.2.0.tgz", 1039 | "integrity": "sha512-ayCKvm/phCGxOkYRSCM82iDwct8/EonSEgCSxWxD7ve6jHggsFl4fZVQBPRNgQoKiuV/odhFrGzQXZwbifC8Rg==", 1040 | "dev": true, 1041 | "requires": { 1042 | "@babel/code-frame": "^7.0.0", 1043 | "error-ex": "^1.3.1", 1044 | "json-parse-even-better-errors": "^2.3.0", 1045 | "lines-and-columns": "^1.1.6" 1046 | } 1047 | }, 1048 | "path-exists": { 1049 | "version": "4.0.0", 1050 | "resolved": "https://registry.npmjs.org/path-exists/-/path-exists-4.0.0.tgz", 1051 | "integrity": "sha512-ak9Qy5Q7jYb2Wwcey5Fpvg2KoAc/ZIhLSLOSBmRmygPsGwkVVt0fZa0qrtMz+m6tJTAHfZQ8FnmB4MG4LWy7/w==", 1052 | "dev": true 1053 | }, 1054 | "quick-lru": { 1055 | "version": "5.1.1", 1056 | "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz", 1057 | "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==", 1058 | "dev": true 1059 | }, 1060 | "read-pkg": { 1061 | "version": "6.0.0", 1062 | "resolved": "https://registry.npmjs.org/read-pkg/-/read-pkg-6.0.0.tgz", 1063 | "integrity": "sha512-X1Fu3dPuk/8ZLsMhEj5f4wFAF0DWoK7qhGJvgaijocXxBmSToKfbFtqbxMO7bVjNA1dmE5huAzjXj/ey86iw9Q==", 1064 | "dev": true, 1065 | "requires": { 1066 | "@types/normalize-package-data": "^2.4.0", 1067 | "normalize-package-data": "^3.0.2", 1068 | "parse-json": "^5.2.0", 1069 | "type-fest": "^1.0.1" 1070 | } 1071 | }, 1072 | "read-pkg-up": { 1073 | "version": "8.0.0", 1074 | "resolved": "https://registry.npmjs.org/read-pkg-up/-/read-pkg-up-8.0.0.tgz", 1075 | "integrity": "sha512-snVCqPczksT0HS2EC+SxUndvSzn6LRCwpfSvLrIfR5BKDQQZMaI6jPRC9dYvYFDRAuFEAnkwww8kBBNE/3VvzQ==", 1076 | "dev": true, 1077 | "requires": { 1078 | "find-up": "^5.0.0", 1079 | "read-pkg": "^6.0.0", 1080 | "type-fest": "^1.0.1" 1081 | } 1082 | }, 1083 | "redent": { 1084 | "version": "4.0.0", 1085 | "resolved": "https://registry.npmjs.org/redent/-/redent-4.0.0.tgz", 1086 | "integrity": "sha512-tYkDkVVtYkSVhuQ4zBgfvciymHaeuel+zFKXShfDnFP5SyVEP7qo70Rf1jTOTCx3vGNAbnEi/xFkcfQVMIBWag==", 1087 | "dev": true, 1088 | "requires": { 1089 | "indent-string": "^5.0.0", 1090 | "strip-indent": "^4.0.0" 1091 | } 1092 | }, 1093 | "semver": { 1094 | "version": "7.3.7", 1095 | "resolved": "https://registry.npmjs.org/semver/-/semver-7.3.7.tgz", 1096 | "integrity": "sha512-QlYTucUYOews+WeEujDoEGziz4K6c47V/Bd+LjSSYcA94p+DmINdf7ncaUinThfvZyu13lN9OY1XDxt8C0Tw0g==", 1097 | "dev": true, 1098 | "requires": { 1099 | "lru-cache": "^6.0.0" 1100 | } 1101 | }, 1102 | "spdx-correct": { 1103 | "version": "3.1.1", 1104 | "resolved": "https://registry.npmjs.org/spdx-correct/-/spdx-correct-3.1.1.tgz", 1105 | "integrity": "sha512-cOYcUWwhCuHCXi49RhFRCyJEK3iPj1Ziz9DpViV3tbZOwXD49QzIN3MpOLJNxh2qwq2lJJZaKMVw9qNi4jTC0w==", 1106 | "dev": true, 1107 | "requires": { 1108 | "spdx-expression-parse": "^3.0.0", 1109 | "spdx-license-ids": "^3.0.0" 1110 | } 1111 | }, 1112 | "spdx-exceptions": { 1113 | "version": "2.3.0", 1114 | "resolved": "https://registry.npmjs.org/spdx-exceptions/-/spdx-exceptions-2.3.0.tgz", 1115 | "integrity": "sha512-/tTrYOC7PPI1nUAgx34hUpqXuyJG+DTHJTnIULG4rDygi4xu/tfgmq1e1cIRwRzwZgo4NLySi+ricLkZkw4i5A==", 1116 | "dev": true 1117 | }, 1118 | "spdx-expression-parse": { 1119 | "version": "3.0.1", 1120 | "resolved": "https://registry.npmjs.org/spdx-expression-parse/-/spdx-expression-parse-3.0.1.tgz", 1121 | "integrity": "sha512-cbqHunsQWnJNE6KhVSMsMeH5H/L9EpymbzqTQ3uLwNCLZ1Q481oWaofqH7nO6V07xlXwY6PhQdQ2IedWx/ZK4Q==", 1122 | "dev": true, 1123 | "requires": { 1124 | "spdx-exceptions": "^2.1.0", 1125 | "spdx-license-ids": "^3.0.0" 1126 | } 1127 | }, 1128 | "spdx-license-ids": { 1129 | "version": "3.0.12", 1130 | "resolved": "https://registry.npmjs.org/spdx-license-ids/-/spdx-license-ids-3.0.12.tgz", 1131 | "integrity": "sha512-rr+VVSXtRhO4OHbXUiAF7xW3Bo9DuuF6C5jH+q/x15j2jniycgKbxU09Hr0WqlSLUs4i4ltHGXqTe7VHclYWyA==", 1132 | "dev": true 1133 | }, 1134 | "strip-indent": { 1135 | "version": "4.0.0", 1136 | "resolved": "https://registry.npmjs.org/strip-indent/-/strip-indent-4.0.0.tgz", 1137 | "integrity": "sha512-mnVSV2l+Zv6BLpSD/8V87CW/y9EmmbYzGCIavsnsI6/nwn26DwffM/yztm30Z/I2DY9wdS3vXVCMnHDgZaVNoA==", 1138 | "dev": true, 1139 | "requires": { 1140 | "min-indent": "^1.0.1" 1141 | } 1142 | }, 1143 | "supports-color": { 1144 | "version": "5.5.0", 1145 | "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz", 1146 | "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==", 1147 | "dev": true, 1148 | "requires": { 1149 | "has-flag": "^3.0.0" 1150 | } 1151 | }, 1152 | "trim-newlines": { 1153 | "version": "4.0.2", 1154 | "resolved": "https://registry.npmjs.org/trim-newlines/-/trim-newlines-4.0.2.tgz", 1155 | "integrity": "sha512-GJtWyq9InR/2HRiLZgpIKv+ufIKrVrvjQWEj7PxAXNc5dwbNJkqhAUoAGgzRmULAnoOM5EIpveYd3J2VeSAIew==", 1156 | "dev": true 1157 | }, 1158 | "type-fest": { 1159 | "version": "1.4.0", 1160 | "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-1.4.0.tgz", 1161 | "integrity": "sha512-yGSza74xk0UG8k+pLh5oeoYirvIiWo5t0/o3zHHAO2tRDiZcxWP7fywNlXhqb6/r6sWvwi+RsyQMWhVLe4BVuA==", 1162 | "dev": true 1163 | }, 1164 | "validate-npm-package-license": { 1165 | "version": "3.0.4", 1166 | "resolved": "https://registry.npmjs.org/validate-npm-package-license/-/validate-npm-package-license-3.0.4.tgz", 1167 | "integrity": "sha512-DpKm2Ui/xN7/HQKCtpZxoRWBhZ9Z0kqtygG8XCgNQ8ZlDnxuQmWhj566j8fN4Cu3/JmbhsDo7fcAJq4s9h27Ew==", 1168 | "dev": true, 1169 | "requires": { 1170 | "spdx-correct": "^3.0.0", 1171 | "spdx-expression-parse": "^3.0.0" 1172 | } 1173 | }, 1174 | "yallist": { 1175 | "version": "4.0.0", 1176 | "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz", 1177 | "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==", 1178 | "dev": true 1179 | }, 1180 | "yargs-parser": { 1181 | "version": "20.2.9", 1182 | "resolved": "https://registry.npmjs.org/yargs-parser/-/yargs-parser-20.2.9.tgz", 1183 | "integrity": "sha512-y11nGElTIV+CT3Zv9t7VKl+Q3hTQoT9a1Qzezhhl6Rp21gJ/IVTW7Z3y9EWXhuUBC2Shnf+DX0antecpAwSP8w==", 1184 | "dev": true 1185 | }, 1186 | "yocto-queue": { 1187 | "version": "0.1.0", 1188 | "resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz", 1189 | "integrity": "sha512-rVksvsnNCdJ/ohGc6xgPwyN8eheCxsiLM8mxuE/t/mOVqJewPuO1miLpTHQiRgTKCLexL4MeAFVagts7HmNZ2Q==", 1190 | "dev": true 1191 | } 1192 | } 1193 | } 1194 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "name": "raylib-duktape", 3 | "version": "0.0.1", 4 | "description": "JavaScript bindings for [raylib](https://www.raylib.com/), a simple and easy-to-use library to learn videogames programming.", 5 | "main": "index.js", 6 | "private": true, 7 | "directories": { 8 | "example": "examples", 9 | "lib": "lib", 10 | "test": "tests" 11 | }, 12 | "scripts": { 13 | "test": "node generator" 14 | }, 15 | "repository": { 16 | "type": "git", 17 | "url": "git+https://github.com/RobLoach/raylib-duktape.git" 18 | }, 19 | "author": "Rob Loach", 20 | "license": "ISC", 21 | "bugs": { 22 | "url": "https://github.com/RobLoach/raylib-duktape/issues" 23 | }, 24 | "homepage": "https://github.com/RobLoach/raylib-duktape#readme", 25 | "devDependencies": { 26 | "@raylib/api": "^4.2.0", 27 | "meow": "^10.1.4" 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /tests/CMakeLists.txt: -------------------------------------------------------------------------------- 1 | add_executable(raylib-duktape-test 2 | raylib-duktape-test.cpp 3 | #${duktape_SOURCE_DIR}/extras/console/duk_console.c 4 | ) 5 | 6 | target_link_libraries(raylib-duktape-test raylib-duktape) 7 | 8 | add_test(NAME raylib-duktape-test COMMAND raylib-duktape-test) 9 | -------------------------------------------------------------------------------- /tests/raylib-assert.h: -------------------------------------------------------------------------------- 1 | /********************************************************************************************** 2 | * 3 | * raylib-assert - Assertion library for raylib. 4 | * https://github.com/robloach/raylib-assert 5 | * 6 | * Copyright 2021 Rob Loach (@RobLoach) 7 | * 8 | * DEPENDENCIES: 9 | * raylib https://www.raylib.com/ 10 | * 11 | * LICENSE: zlib/libpng 12 | * 13 | * raylib-assert is licensed under an unmodified zlib/libpng license, which is an OSI-certified, 14 | * BSD-like license that allows static linking with closed source software: 15 | * 16 | * This software is provided "as-is", without any express or implied warranty. In no event 17 | * will the authors be held liable for any damages arising from the use of this software. 18 | * 19 | * Permission is granted to anyone to use this software for any purpose, including commercial 20 | * applications, and to alter it and redistribute it freely, subject to the following restrictions: 21 | * 22 | * 1. The origin of this software must not be misrepresented; you must not claim that you 23 | * wrote the original software. If you use this software in a product, an acknowledgment 24 | * in the product documentation would be appreciated but is not required. 25 | * 26 | * 2. Altered source versions must be plainly marked as such, and must not be misrepresented 27 | * as being the original software. 28 | * 29 | * 3. This notice may not be removed or altered from any source distribution. 30 | * 31 | **********************************************************************************************/ 32 | 33 | #ifndef RAYLIB_ASSERT_H 34 | #define RAYLIB_ASSERT_H 35 | 36 | #ifdef __cplusplus 37 | extern "C" { 38 | #endif 39 | 40 | // How to report failed assertions 41 | #ifndef RAYLIB_ASSERT_LOG 42 | /** 43 | * The Trace Log Level used to report to TraceLog() on failed assertions. Defaults to LOG_FATAL. 44 | * 45 | * @example 46 | * #define RAYLIB_ASSERT_LOG LOG_WARNING 47 | * 48 | * @see TraceLogLevel 49 | */ 50 | #define RAYLIB_ASSERT_LOG LOG_FATAL 51 | #endif 52 | 53 | // Define NDEBUG or RAYLIB_ASSERT_NDEBUG to skip assertions 54 | #ifdef NDEBUG 55 | #ifndef RAYLIB_ASSERT_NDEBUG 56 | #define RAYLIB_ASSERT_NDEBUG 57 | #endif 58 | #endif 59 | 60 | // Variadic Arguments 61 | #define RAYLIB_ASSERT_CAT( A, B ) A ## B 62 | #define RAYLIB_ASSERT_SELECT( NAME, NUM ) RAYLIB_ASSERT_CAT( NAME ## _, NUM ) 63 | #define RAYLIB_ASSERT_GET_COUNT( _1, _2, _3, _4, _5, _6, _7, RAYLIB_ASSERT_COUNT, ... ) RAYLIB_ASSERT_COUNT 64 | #define RAYLIB_ASSERT_VA_SIZE( ... ) RAYLIB_ASSERT_GET_COUNT( __VA_ARGS__, 7, 6, 5, 4, 3, 2, 1 ) 65 | #define RAYLIB_ASSERT_VA_SELECT( NAME, ... ) RAYLIB_ASSERT_SELECT( NAME, RAYLIB_ASSERT_VA_SIZE(__VA_ARGS__) )(__VA_ARGS__) 66 | 67 | /** 68 | * Assert whether the given condition is true. 69 | * 70 | * @param condition The condition that is expected to be true. 71 | * @param message (Optional) The message to provide on failed assertions. 72 | * @param p1 (Optional) The first parameter in the message. 73 | * @param p2 (Optional) The second parameter in the message. 74 | * @param p3 (Optional) The third parameter in the message. 75 | * @param p4 (Optional) The fourth parameter in the message. 76 | * @param p5 (Optional) The fifth parameter in the message. 77 | */ 78 | #define Assert(...) RAYLIB_ASSERT_VA_SELECT(Assert, __VA_ARGS__) 79 | 80 | /** 81 | * Assert whether the two given parameters are equal. 82 | * 83 | * @param actual The actual value. 84 | * @param expected The expected value. 85 | * @param message (Optional) The message to provide on failed assertions. 86 | * @param p1 (Optional) The first parameter in the message. 87 | * @param p2 (Optional) The second parameter in the message. 88 | * @param p3 (Optional) The third parameter in the message. 89 | * @param p4 (Optional) The fourth parameter in the message. 90 | */ 91 | #define AssertEqual(...) RAYLIB_ASSERT_VA_SELECT(AssertEqual, __VA_ARGS__) 92 | 93 | /** 94 | * Assert whether the given condition is false. 95 | * 96 | * @param condition The condition that is expected to be false. 97 | * @param message (Optional) The message to provide on failed assertions. 98 | * @param p1 (Optional) The first parameter in the message. 99 | * @param p2 (Optional) The second parameter in the message. 100 | * @param p3 (Optional) The third parameter in the message. 101 | * @param p4 (Optional) The fourth parameter in the message. 102 | * @param p5 (Optional) The fifth parameter in the message. 103 | */ 104 | #define AssertNot(...) RAYLIB_ASSERT_VA_SELECT(AssertNot, __VA_ARGS__) 105 | 106 | /** 107 | * Assert whether the two given parameters are not equal. 108 | * 109 | * @param actual The actual value. 110 | * @param notexpected The expected value that shouldn't equal the actual value. 111 | * @param message (Optional) The message to provide on failed assertions. 112 | * @param p1 (Optional) The first parameter in the message. 113 | * @param p2 (Optional) The second parameter in the message. 114 | * @param p3 (Optional) The third parameter in the message. 115 | * @param p4 (Optional) The fourth parameter in the message. 116 | */ 117 | #define AssertNotEqual(...) RAYLIB_ASSERT_VA_SELECT(AssertNotEqual, __VA_ARGS__) 118 | 119 | /** 120 | * Sets a failed assertion, with the given message. 121 | * 122 | * @param message (Optional) The message to provide for the failed assertion. 123 | * @param p1 (Optional) The first parameter in the message. 124 | * @param p2 (Optional) The second parameter in the message. 125 | * @param p3 (Optional) The third parameter in the message. 126 | * @param p4 (Optional) The fourth parameter in the message. 127 | * @param p5 (Optional) The fifth parameter in the message. 128 | * @param p6 (Optional) The sixth parameter in the message. 129 | */ 130 | #define AssertFail(...) RAYLIB_ASSERT_VA_SELECT(AssertFail, __VA_ARGS__) 131 | 132 | /** 133 | * Assert whether an image is loaded. 134 | * 135 | * @param image The image to check for valid data. 136 | * @param message (Optional) The message to provide on failed assertions. 137 | * @param p1 (Optional) The first parameter in the message. 138 | * @param p2 (Optional) The second parameter in the message. 139 | * @param p3 (Optional) The third parameter in the message. 140 | * @param p4 (Optional) The fourth parameter in the message. 141 | * @param p5 (Optional) The fifth parameter in the message. 142 | */ 143 | #define AssertImage(...) RAYLIB_ASSERT_VA_SELECT(AssertImage, __VA_ARGS__) 144 | 145 | /** 146 | * Assert whether two images are the same. 147 | * 148 | * @param image1 The first image to check is equal to the second. 149 | * @param image2 The second image to check is equal to the first. 150 | * @param message (Optional) The message to provide on failed assertions. 151 | * @param p1 (Optional) The first parameter in the message. 152 | * @param p2 (Optional) The second parameter in the message. 153 | * @param p3 (Optional) The third parameter in the message. 154 | * @param p4 (Optional) The fourth parameter in the message. 155 | */ 156 | #define AssertImageSame(...) RAYLIB_ASSERT_VA_SELECT(AssertImageSame, __VA_ARGS__) 157 | 158 | /** 159 | * Assert whether two colors are the same. 160 | * 161 | * @param color1 The first color to check. 162 | * @param color2 The second color to check. 163 | * @param message (Optional) The message to provide on failed assertions. 164 | * @param p1 (Optional) The first parameter in the message. 165 | * @param p2 (Optional) The second parameter in the message. 166 | * @param p3 (Optional) The third parameter in the message. 167 | * @param p4 (Optional) The fourth parameter in the message. 168 | */ 169 | #define AssertColorSame(...) RAYLIB_ASSERT_VA_SELECT(AssertColorSame, __VA_ARGS__) 170 | 171 | // Assert() 172 | #ifdef RAYLIB_ASSERT_NDEBUG 173 | #define Assert_0() 174 | #define Assert_1(condition) 175 | #define Assert_2(condition, message) 176 | #define Assert_3(condition, message, p1) 177 | #define Assert_4(condition, message, p1, p2) 178 | #define Assert_5(condition, message, p1, p2, p3) 179 | #define Assert_6(condition, message, p1, p2, p3, p4) 180 | #define Assert_7(condition, message, p1, p2, p3, p4, p5) 181 | #else 182 | #define Assert_0() AssertFail_1("No condition provided for Assert()") 183 | #define Assert_1(condition) Assert_2(condition, #condition) 184 | #define Assert_2(condition, message) do { if (!((bool)(condition))) { TraceLog(RAYLIB_ASSERT_LOG, "ASSERT: %s (%s:%i)", message, __FILE__, __LINE__); } } while(0) 185 | #define Assert_3(condition, message, p1) Assert_2(condition, TextFormat(message, p1)) 186 | #define Assert_4(condition, message, p1, p2) Assert_2(condition, TextFormat(message, p1, p2)) 187 | #define Assert_5(condition, message, p1, p2, p3) Assert_2(condition, TextFormat(message, p1, p2, p3)) 188 | #define Assert_6(condition, message, p1, p2, p3, p4) Assert_2(condition, TextFormat(message, p1, p2, p3, p4)) 189 | #define Assert_7(condition, message, p1, p2, p3, p4, p5) Assert_2(condition, TextFormat(message, p1, p2, p3, p4, p5)) 190 | #endif 191 | 192 | // AssertEqual() 193 | #define AssertEqual_0() AssertFail_1("No condition provided for AssertEqual()") 194 | #define AssertEqual_1(condition) Assert_2(condition, #condition) 195 | #define AssertEqual_2(actual, expected) Assert_4((actual) == (expected), "AssertEqual(%s, %s) - Provided arguments are not equal", #actual, #expected) 196 | #define AssertEqual_3(actual, expected, message) Assert_2((actual) == (expected), message) 197 | #define AssertEqual_4(actual, expected, message, p1) Assert_3((actual) == (expected), message, p1) 198 | #define AssertEqual_5(actual, expected, message, p1, p2) Assert_4((actual) == (expected), message, p1, p2) 199 | #define AssertEqual_6(actual, expected, message, p1, p2, p3) Assert_5((actual) == (expected), message, p1, p2, p3) 200 | #define AssertEqual_7(actual, expected, message, p1, p2, p3, p4) Assert_6((actual) == (expected), message, p1, p2, p3, p4) 201 | 202 | // AssertNotEqual() 203 | #define AssertNotEqual_0() AssertFail_1("No condition provided for AssertNotEqual()") 204 | #define AssertNotEqual_1(condition) AssertNot_2(condition, #condition) 205 | #define AssertNotEqual_2(actual, expected) Assert_4((actual) != (expected), "AssertNotEqual(%s, %s) - Provided arguments are equal", #actual, #expected) 206 | #define AssertNotEqual_3(actual, expected, message) Assert_2((actual) != (expected), message) 207 | #define AssertNotEqual_4(actual, expected, message, p1) Assert_3((actual) != (expected), message, p1) 208 | #define AssertNotEqual_5(actual, expected, message, p1, p2) Assert_4((actual) != (expected), message, p1, p2) 209 | #define AssertNotEqual_6(actual, expected, message, p1, p2, p3) Assert_5((actual) != (expected), message, p1, p2, p3) 210 | #define AssertNotEqual_7(actual, expected, message, p1, p2, p3, p4) Assert_6((actual) != (expected), message, p1, p2, p3, p4) 211 | 212 | // AssertNot() 213 | #define AssertNot_0() AssertFail_1("No condition provided for AssertNot()") 214 | #define AssertNot_1(condition) Assert_2(!(bool)(condition), #condition) 215 | #define AssertNot_2(condition, message) Assert_2(!(bool)(condition), message) 216 | #define AssertNot_3(condition, message, p1) Assert_3(!(bool)(condition), message, p1) 217 | #define AssertNot_4(condition, message, p1, p2) Assert_4(!(bool)(condition), message, p1, p2) 218 | #define AssertNot_5(condition, message, p1, p2, p3) Assert_5(!(bool)(condition), message, p1, p2, p3) 219 | #define AssertNot_6(condition, message, p1, p2, p3, p4) Assert_6(!(bool)(condition), message, p1, p2, p3, p4) 220 | #define AssertNot_7(condition, message, p1, p2, p3, p4, p5) Assert_7(!(bool)(condition), message, p1, p2, p3, p4, p5) 221 | 222 | // AssertFail() 223 | #ifdef RAYLIB_ASSERT_NDEBUG 224 | #define AssertFail_0() 225 | #define AssertFail_1(message) 226 | #define AssertFail_2(message, p1) 227 | #define AssertFail_3(message, p1, p2) 228 | #define AssertFail_4(message, p1, p2, p3) 229 | #define AssertFail_5(message, p1, p2, p3, p4) 230 | #define AssertFail_6(message, p1, p2, p3, p4, p5) 231 | #define AssertFail_7(message, p1, p2, p3, p4, p5, p6) 232 | #else 233 | #define AssertFail_0() TraceLog(RAYLIB_ASSERT_LOG, "ASSERT: AssertFail() (%s:%i)", __FILE__, __LINE__) 234 | #define AssertFail_1(message) TraceLog(RAYLIB_ASSERT_LOG, "ASSERT: %s (%s:%i)", message, __FILE__, __LINE__) 235 | #define AssertFail_2(message, p1) AssertFail_1(TextFormat(message, p1)) 236 | #define AssertFail_3(message, p1, p2) AssertFail_1(TextFormat(message, p1, p2)) 237 | #define AssertFail_4(message, p1, p2, p3) AssertFail_1(TextFormat(message, p1, p2, p3)) 238 | #define AssertFail_5(message, p1, p2, p3, p4) AssertFail_1(TextFormat(message, p1, p2, p3, p4)) 239 | #define AssertFail_6(message, p1, p2, p3, p4, p5) AssertFail_1(TextFormat(message, p1, p2, p3, p4, p5)) 240 | #define AssertFail_7(message, p1, p2, p3, p4, p5, p6) AssertFail_1(TextFormat(message, p1, p2, p3, p4, p5, p6)) 241 | #endif 242 | 243 | // AssertImage() 244 | #define AssertImage_0() AssertFail_1("No image provided for AssertImage()") 245 | #define AssertImage_1(image) AssertNotEqual_4((image).data, 0, "AssertImage(%s) - Image not loaded", #image) 246 | #define AssertImage_2(image, message) AssertNotEqual_3((image).data, 0, message) 247 | #define AssertImage_3(image, message, p1) AssertNotEqual_4((image).data, 0, message, p1) 248 | #define AssertImage_4(image, message, p1, p2) AssertNotEqual_5((image).data, 0, message, p1, p2) 249 | #define AssertImage_5(image, message, p1, p2, p3) AssertNotEqual_6((image).data, 0, message, p1, p2, p3) 250 | #define AssertImage_6(image, message, p1, p2, p3, p4) AssertNotEqual_7((image).data, 0, message, p1, p2, p3, p4) 251 | 252 | // AssertTexture() 253 | #define AssertTexture_0() AssertFail_1("No texture provided for AssertTexture()") 254 | #define AssertTexture_1(texture) AssertNotEqual_4((texture).id, 0, "AssertTexture(%s) - Texture not loaded", #texture) 255 | #define AssertTexture_2(texture, message) AssertNotEqual_3((texture).data, 0, message) 256 | #define AssertTexture_3(texture, message, p1) AssertNotEqual_4((texture).data, 0, message, p1) 257 | #define AssertTexture_4(texture, message, p1, p2) AssertNotEqual_5((texture).data, 0, message, p1, p2) 258 | #define AssertTexture_5(texture, message, p1, p2, p3) AssertNotEqual_6((texture).data, 0, message, p1, p2, p3) 259 | #define AssertTexture_6(texture, message, p1, p2, p3, p4) AssertNotEqual_7((texture).data, 0, message, p1, p2, p3, p4) 260 | 261 | // AssertImageSame() 262 | #ifdef RAYLIB_ASSERT_NDEBUG 263 | #define AssertImageSame_0() 264 | #define AssertImageSame_1(image) 265 | #define AssertImageSame_2(image1, image2) 266 | #define AssertImageSame_3(image1, image2, message) 267 | #define AssertImageSame_4(image1, image2, message, p1) 268 | #define AssertImageSame_5(image1, image2, message, p1, p2) 269 | #define AssertImageSame_6(image1, image2, message, p1, p2, p3) 270 | #define AssertImageSame_7(image1, image2, message, p1, p2, p3, p4) 271 | #else 272 | #define AssertImageSame_0() AssertFail_1("AssertImageSame(): No images provided to AssertImageSame(), expected 2") 273 | #define AssertImageSame_1(image) AssertFail_1("Only one image provided for AssertImageSame()") 274 | #define AssertImageSame_2(image1, image2) AssertImageSame_5(image1, image2, "AssertImageSame(%s, %s) - Images do not match", #image1, #image2) 275 | #define AssertImageSame_3(image1, image2, message) do { \ 276 | if (image1.width != image2.width || image1.height != image2.height || image1.format != image2.format) { \ 277 | AssertFail_1(message); \ 278 | break; \ 279 | } \ 280 | Color* colors1 = LoadImageColors(image1); \ 281 | Color* colors2 = LoadImageColors(image2); \ 282 | bool failure = false; \ 283 | for (int i = 0; i < image1.width * image1.height; i++) { \ 284 | Color color1 = colors1[i]; \ 285 | Color color2 = colors2[i]; \ 286 | if (color1.r != color2.r || color1.g != color2.g || color1.b != color2.b || color1.a != color2.a) { \ 287 | failure = true; \ 288 | break; \ 289 | } \ 290 | } \ 291 | UnloadImageColors(colors1); \ 292 | UnloadImageColors(colors2); \ 293 | if (failure) { \ 294 | AssertFail_1(message); \ 295 | } \ 296 | } while(0) 297 | #define AssertImageSame_4(image1, image2, message, p1) AssertImageSame_3(image1, image2, TextFormat(message, p1)) 298 | #define AssertImageSame_5(image1, image2, message, p1, p2) AssertImageSame_3(image1, image2, TextFormat(message, p1, p2)) 299 | #define AssertImageSame_6(image1, image2, message, p1, p2, p3) AssertImageSame_3(image1, image2, TextFormat(message, p1, p2, p3)) 300 | #define AssertImageSame_7(image1, image2, message, p1, p2, p3, p4) AssertImageSame_3(image1, image2, TextFormat(message, p1, p2, p3, p4)) 301 | #endif 302 | 303 | // AssertColorSame() 304 | #ifdef RAYLIB_ASSERT_NDEBUG 305 | #define AssertColorSame_0() 306 | #define AssertColorSame_1(color) 307 | #define AssertColorSame_2(color1, color2) 308 | #define AssertColorSame_3(color1, color2, message) 309 | #define AssertColorSame_4(color1, color2, message, p1) 310 | #define AssertColorSame_5(color1, color2, message, p1, p2) 311 | #define AssertColorSame_6(color1, color2, message, p1, p2, p3) 312 | #define AssertColorSame_7(color1, color2, message, p1, p2, p3, p4) 313 | #else 314 | #define AssertColorSame_0() AssertFail_1("Colors not provided to AssertColorSame()") 315 | #define AssertColorSame_1(color) AssertFail_1("Expected two colors for AssertColorSame()") 316 | #define AssertColorSame_2(color1, color2) AssertColorSame_5(color1, color2, "AssertColorSame(%s, %s) - Colors do not match", #color1, #color2) 317 | #define AssertColorSame_3(color1, color2, message) do { \ 318 | if (color1.r != color2.r || color1.g != color2.g || color1.b != color2.b || color1.a != color2.a) { \ 319 | AssertFail_1(message); \ 320 | }\ 321 | } while (0) 322 | #define AssertColorSame_4(color1, color2, message, p1) AssertColorSame_3(color1, color2, TextFormat(message, p1)) 323 | #define AssertColorSame_5(color1, color2, message, p1, p2) AssertColorSame_3(color1, color2, TextFormat(message, p1, p2)) 324 | #define AssertColorSame_6(color1, color2, message, p1, p2, p3) AssertColorSame_3(color1, color2, TextFormat(message, p1, p2, p3)) 325 | #define AssertColorSame_7(color1, color2, message, p1, p2, p3, p4) AssertColorSame_3(color1, color2, TextFormat(message, p1, p2, p3, p4)) 326 | #endif 327 | 328 | #ifdef __cplusplus 329 | } 330 | #endif 331 | 332 | #endif // RAYLIB_ASSERT_H 333 | -------------------------------------------------------------------------------- /tests/raylib-duktape-test.cpp: -------------------------------------------------------------------------------- 1 | #include "raylib.h" 2 | #include "raylib-assert.h" 3 | #include 4 | #include 5 | #include "raylib-duktape.h" 6 | 7 | int main() { 8 | // Create the Duktape environment. 9 | duk_context* ctx = duk_create_heap_default(); 10 | 11 | // Register the raylib.js context. 12 | duk_raylib_init(ctx, 0); 13 | 14 | { 15 | bool output = dukglue_peval(ctx, "IsWindowReady()"); 16 | AssertNot(output, "IsWindowReady()"); 17 | } 18 | 19 | { 20 | int output = dukglue_peval(ctx, "GetRandomValue(10,20)"); 21 | Assert(output >= 10, "GetRandomValue(10,20)"); 22 | Assert(output <= 20, "GetRandomValue(10,20)"); 23 | } 24 | 25 | { 26 | int r = dukglue_peval(ctx, "RAYWHITE.r"); 27 | int expected = RAYWHITE.r; 28 | AssertEqual(r, expected); 29 | } 30 | 31 | duk_destroy_heap(ctx); 32 | 33 | TraceLog(LOG_INFO, "Tests completed successfully"); 34 | 35 | return 0; 36 | } 37 | --------------------------------------------------------------------------------