From 735968e68543bb5141122f181608d0d7ada9a3be Mon Sep 17 00:00:00 2001 From: raysan5 Date: Wed, 3 Aug 2016 21:38:21 +0200 Subject: [rlua] new module: raylib Lua binding --- src/rlua.h | 3631 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 3631 insertions(+) create mode 100644 src/rlua.h (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h new file mode 100644 index 00000000..6a909c43 --- /dev/null +++ b/src/rlua.h @@ -0,0 +1,3631 @@ +/********************************************************************************************** +* +* rlua - raylib Lua bindings +* +* NOTE 01: +* The following types: +* Color, Vector2, Vector3, Rectangle, Ray, Camera +* are treated as objects with named fields, same as in C. +* +* Lua defines utility functions for creating those objects. +* Usage: +* local cl = Color(255,255,255,255) +* local rec = Rectangle(10, 10, 100, 100) +* local ray = Ray(Vector3(20, 20, 20), Vector3(50, 50, 50)) +* local x2 = rec.x + rec.width +* +* The following types: +* Image, Texture2D, SpriteFont +* are immutable, and you can only read their non-pointer arguments (e.g. sprfnt.size). +* +* All other object types are opaque, that is, you cannot access or +* change their fields directly. +* +* Remember that ALL raylib types have REFERENCE SEMANTICS in Lua. +* There is currently no way to create a copy of an opaque object. +* +* NOTE 02: +* Some raylib functions take a pointer to an array, and the size of that array. +* The equivalent Lua functions take only an array table of the specified type UNLESS +* it's a pointer to a large char array (e.g. for images), then it takes (and potentially returns) +* a Lua string (without the size argument, as Lua strings are sized by default). +* +* NOTE 03: +* Some raylib functions take pointers to objects to modify (e.g. ImageToPOT, etc.) +* In Lua, these functions take values and return a new changed value, instead. +* So, in C: +* ImageToPOT(&img, BLACK); +* In Lua becomes: +* img = ImageToPOT(img, BLACK) +* +* Remember that functions can return multiple values, so: +* UpdateCameraPlayer(&cam, &playerPos); +* Vector3 vec = ResolveCollisionCubicmap(img, mapPos, &playerPos, 5.0); +* becomes: +* cam, playerPos = UpdateCameraPlayer(cam, playerPos) +* vec, playerPos = ResolveCollisionCubicmap(img, mapPos, playerPos, 5) +* +* This is to preserve value semantics of raylib objects. +* +* +* This Lua binding for raylib was originally created by Ghassan Al-Mashareqa (ghassan@ghassan.pl) +* for raylib 1.3 and later on reviewed and updated to raylib 1.6 by Ramon Santamaria. +* +* Copyright (c) 2015-2016 Ghassan Al-Mashareqa and Ramon Santamaria (@raysan5) +* +* This software is provided "as-is", without any express or implied warranty. In no event +* will the authors be held liable for any damages arising from the use of this software. +* +* Permission is granted to anyone to use this software for any purpose, including commercial +* applications, and to alter it and redistribute it freely, subject to the following restrictions: +* +* 1. The origin of this software must not be misrepresented; you must not claim that you +* wrote the original software. If you use this software in a product, an acknowledgment +* in the product documentation would be appreciated but is not required. +* +* 2. Altered source versions must be plainly marked as such, and must not be misrepresented +* as being the original software. +* +* 3. This notice may not be removed or altered from any source distribution. +* +**********************************************************************************************/ + +#pragma once + +#include "raylib.h" + +#define RLUA_STATIC +#ifdef RLUA_STATIC + #define RLUADEF static // Functions just visible to module including this file +#else + #ifdef __cplusplus + #define RLUADEF extern "C" // Functions visible from other files (no name mangling of functions in C++) + #else + #define RLUADEF extern // Functions visible from other files + #endif +#endif + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Module Functions Declaration +//---------------------------------------------------------------------------------- +RLUADEF void InitLuaDevice(void); // Initialize Lua system +RLUADEF void ExecuteLuaCode(const char *code); // Execute raylib Lua code +RLUADEF void ExecuteLuaFile(const char *filename); // Execute raylib Lua script +RLUADEF void CloseLuaDevice(void); // De-initialize Lua system + +/*********************************************************************************** +* +* RLUA IMPLEMENTATION +* +************************************************************************************/ + +#if defined(RLUA_IMPLEMENTATION) + +#include "raylib.h" +#include "utils.h" +#include "raymath.h" + +#include +#include + +#include +#include +#include + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#define LuaPush_Image(L, img) LuaPushOpaqueTypeWithMetatable(L, img, Image) +#define LuaPush_Texture2D(L, tex) LuaPushOpaqueTypeWithMetatable(L, tex, Texture2D) +#define LuaPush_RenderTexture2D(L, tex) LuaPushOpaqueTypeWithMetatable(L, tex, RenderTexture2D) +#define LuaPush_SpriteFont(L, sf) LuaPushOpaqueTypeWithMetatable(L, sf, SpriteFont) +#define LuaPush_Mesh(L, vd) LuaPushOpaqueType(L, vd) +#define LuaPush_Shader(L, s) LuaPushOpaqueType(L, s) +#define LuaPush_Sound(L, snd) LuaPushOpaqueType(L, snd) +#define LuaPush_Wave(L, wav) LuaPushOpaqueType(L, wav) +#define LuaPush_Music(L, mus) LuaPushOpaqueType(L, mus) + +#define LuaGetArgument_string luaL_checkstring +#define LuaGetArgument_int (int)luaL_checkinteger +#define LuaGetArgument_unsigned (unsigned)luaL_checkinteger +#define LuaGetArgument_char (char)luaL_checkinteger +#define LuaGetArgument_float (float)luaL_checknumber +#define LuaGetArgument_double luaL_checknumber +#define LuaGetArgument_Image(L, img) *(Image*)LuaGetArgumentOpaqueTypeWithMetatable(L, img, "Image") +#define LuaGetArgument_Texture2D(L, tex) *(Texture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, tex, "Texture2D") +#define LuaGetArgument_RenderTexture2D(L, rtex) *(RenderTexture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, rtex, "RenderTexture2D") +#define LuaGetArgument_SpriteFont(L, sf) *(SpriteFont*)LuaGetArgumentOpaqueTypeWithMetatable(L, sf, "SpriteFont") +#define LuaGetArgument_Mesh(L, vd) *(Mesh*)LuaGetArgumentOpaqueType(L, vd) +#define LuaGetArgument_Shader(L, s) *(Shader*)LuaGetArgumentOpaqueType(L, s) +#define LuaGetArgument_Sound(L, snd) *(Sound*)LuaGetArgumentOpaqueType(L, snd) +#define LuaGetArgument_Wave(L, wav) *(Wave*)LuaGetArgumentOpaqueType(L, wav) +#define LuaGetArgument_Music(L, mus) *(Music*)LuaGetArgumentOpaqueType(L, mus) + +#define LuaPushOpaqueType(L, str) LuaPushOpaque(L, &str, sizeof(str)) +#define LuaPushOpaqueTypeWithMetatable(L, str, meta) LuaPushOpaqueWithMetatable(L, &str, sizeof(str), #meta) + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- +static lua_State* mainLuaState = 0; +static lua_State* L = 0; + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static void LuaPush_Color(lua_State* L, Color color); +static void LuaPush_Vector2(lua_State* L, Vector2 vec); +static void LuaPush_Vector3(lua_State* L, Vector3 vec); +static void LuaPush_Quaternion(lua_State* L, Quaternion vec); +static void LuaPush_Matrix(lua_State* L, Matrix *matrix); +static void LuaPush_Rectangle(lua_State* L, Rectangle rect); +static void LuaPush_Model(lua_State* L, Model mdl); +static void LuaPush_Ray(lua_State* L, Ray ray); +static void LuaPush_Camera(lua_State* L, Camera cam); + +static Vector2 LuaGetArgument_Vector2(lua_State* L, int index); +static Vector3 LuaGetArgument_Vector3(lua_State* L, int index); +static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index); +static Color LuaGetArgument_Color(lua_State* L, int index); +static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index); +static Camera LuaGetArgument_Camera(lua_State* L, int index); +static Ray LuaGetArgument_Ray(lua_State* L, int index); +static Matrix LuaGetArgument_Matrix(lua_State* L, int index); +static Model LuaGetArgument_Model(lua_State* L, int index); + +//---------------------------------------------------------------------------------- +// rlua Helper Functions +//---------------------------------------------------------------------------------- +static void LuaStartEnum(void) +{ + lua_newtable(L); +} + +static void LuaSetEnum(const char *name, int value) +{ + lua_pushinteger(L, value); + lua_setfield(L, -2, name); +} + +static void LuaSetEnumColor(const char *name, Color color) +{ + LuaPush_Color(L, color); + lua_setfield(L, -2, name); +} + +static void LuaEndEnum(const char *name) +{ + lua_setglobal(L, name); +} + +static void LuaPushOpaque(lua_State* L, void *ptr, size_t size) +{ + void *ud = lua_newuserdata(L, size); + memcpy(ud, ptr, size); +} + +static void LuaPushOpaqueWithMetatable(lua_State* L, void *ptr, size_t size, const char *metatable_name) +{ + void *ud = lua_newuserdata(L, size); + memcpy(ud, ptr, size); + luaL_setmetatable(L, metatable_name); +} + +static void* LuaGetArgumentOpaqueType(lua_State* L, int index) +{ + return lua_touserdata(L, index); +} + +static void* LuaGetArgumentOpaqueTypeWithMetatable(lua_State* L, int index, const char *metatable_name) +{ + return luaL_checkudata(L, index, metatable_name); +} + +//---------------------------------------------------------------------------------- +// LuaIndex* functions +//---------------------------------------------------------------------------------- +static int LuaIndexImage(lua_State* L) +{ + Image img = LuaGetArgument_Image(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "width")) + lua_pushinteger(L, img.width); + else if (!strcmp(key, "height")) + lua_pushinteger(L, img.height); + else if (!strcmp(key, "mipmaps")) + lua_pushinteger(L, img.mipmaps); + else if (!strcmp(key, "format")) + lua_pushinteger(L, img.format); + else + return 0; + return 1; +} + +static int LuaIndexTexture2D(lua_State* L) +{ + Texture2D img = LuaGetArgument_Texture2D(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "width")) + lua_pushinteger(L, img.width); + else if (!strcmp(key, "height")) + lua_pushinteger(L, img.height); + else if (!strcmp(key, "mipmaps")) + lua_pushinteger(L, img.mipmaps); + else if (!strcmp(key, "format")) + lua_pushinteger(L, img.format); + else + return 0; + return 1; +} + +// TODO: RenderTexture2D? + +static int LuaIndexSpriteFont(lua_State* L) +{ + SpriteFont img = LuaGetArgument_SpriteFont(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "size")) + lua_pushinteger(L, img.size); + else if (!strcmp(key, "texture")) + LuaPush_Texture2D(L, img.texture); + else if (!strcmp(key, "numChars")) + lua_pushinteger(L, img.numChars); + else + return 0; + return 1; +} + +static void LuaBuildOpaqueMetatables(void) +{ + luaL_newmetatable(L, "Image"); + lua_pushcfunction(L, &LuaIndexImage); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); + + luaL_newmetatable(L, "Texture2D"); + lua_pushcfunction(L, &LuaIndexTexture2D); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); + + // TODO? + /* + luaL_newmetatable(L, "RenderTexture2D"); + lua_pushcfunction(L, &LuaIndexRenderTexture2D); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); + */ + luaL_newmetatable(L, "SpriteFont"); + lua_pushcfunction(L, &LuaIndexSpriteFont); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); +} + +//---------------------------------------------------------------------------------- +// LuaGetArgument functions +//---------------------------------------------------------------------------------- + +static Vector2 LuaGetArgument_Vector2(lua_State* L, int index) +{ + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2"); + float y = (float)lua_tonumber(L, -1); + lua_pop(L, 2); + return (Vector2) { x, y }; +} + +static Vector3 LuaGetArgument_Vector3(lua_State* L, int index) +{ + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3"); + float y = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Vector3"); + float z = (float)lua_tonumber(L, -1); + lua_pop(L, 3); + return (Vector3) { x, y, z }; +} + +static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index) +{ + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion"); + float y = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Quaternion"); + float z = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "w") == LUA_TNUMBER, index, "Expected Quaternion"); + float w = (float)lua_tonumber(L, -1); + lua_pop(L, 4); + return (Quaternion) { x, y, z, w }; +} + +static Color LuaGetArgument_Color(lua_State* L, int index) +{ + luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color"); + unsigned char r = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color"); + unsigned char g = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "b") == LUA_TNUMBER, index, "Expected Color"); + unsigned char b = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "a") == LUA_TNUMBER, index, "Expected Color"); + unsigned char a = (unsigned char)lua_tointeger(L, -1); + lua_pop(L, 4); + return (Color) { r, g, b, a }; +} + +static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index) +{ + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle"); + int x = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle"); + int y = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "width") == LUA_TNUMBER, index, "Expected Rectangle"); + int w = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "height") == LUA_TNUMBER, index, "Expected Rectangle"); + int h = (int)lua_tointeger(L, -1); + lua_pop(L, 4); + return (Rectangle) { x, y, w, h }; +} + +static Camera LuaGetArgument_Camera(lua_State* L, int index) +{ + Camera result; + luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera"); + result.position = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera"); + result.target = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera"); + result.up = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "fovy") == LUA_TTABLE, index, "Expected Camera"); + result.fovy = LuaGetArgument_float(L, -1); + lua_pop(L, 4); + return result; +} + +static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) +{ + Camera2D result; + luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D"); + result.offset = LuaGetArgument_Vector2(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D"); + result.target = LuaGetArgument_Vector2(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TTABLE, index, "Expected Camera2D"); + result.rotation = LuaGetArgument_float(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TTABLE, index, "Expected Camera2D"); + result.zoom = LuaGetArgument_float(L, -1); + lua_pop(L, 4); + return result; +} + +// TODO: +//BoundingBox +//LightData, *Light +//MusicData *Music; +//AudioStream + +// TODO: Review Mesh, Shader + +static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) +{ + BoundingBox result; + luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox"); + result.min = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox"); + result.max = LuaGetArgument_Vector3(L, -1); + lua_pop(L, 2); + return result; +} + +static Ray LuaGetArgument_Ray(lua_State* L, int index) +{ + Ray result; + luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray"); + result.position = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray"); + result.direction = LuaGetArgument_Vector3(L, -1); + lua_pop(L, 2); + return result; +} + +static Matrix LuaGetArgument_Matrix(lua_State* L, int index) +{ + Matrix result = { 0 }; + float* ptr = &result.m0; + for (int i = 0; i < 16; i++) + { + lua_geti(L, -1, i+1); + ptr[i] = luaL_checkinteger(L, -1); + } + lua_pop(L, 16); + return result; +} + +static Material LuaGetArgument_Material(lua_State* L, int index) +{ + Material result; + luaL_argcheck(L, lua_getfield(L, index, "shader") == LUA_TUSERDATA, index, "Expected Material"); + result.shader = LuaGetArgument_Shader(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "texDiffuse") == LUA_TUSERDATA, index, "Expected Material"); + result.texDiffuse = LuaGetArgument_Texture2D(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "texNormal") == LUA_TUSERDATA, index, "Expected Material"); + result.texNormal = LuaGetArgument_Texture2D(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "texSpecular") == LUA_TUSERDATA, index, "Expected Material"); + result.texSpecular = LuaGetArgument_Texture2D(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TUSERDATA, index, "Expected Material"); + result.colDiffuse = LuaGetArgument_Color(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TUSERDATA, index, "Expected Material"); + result.colAmbient = LuaGetArgument_Color(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TUSERDATA, index, "Expected Material"); + result.colSpecular = LuaGetArgument_Color(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TUSERDATA, index, "Expected Material"); + result.glossiness = LuaGetArgument_float(L, -1); + lua_pop(L, 8); + return result; +} + +static Model LuaGetArgument_Model(lua_State* L, int index) +{ + Model result; + luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model"); + result.mesh = LuaGetArgument_Mesh(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model"); + result.transform = LuaGetArgument_Matrix(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "material") == LUA_TTABLE, index, "Expected Model"); + result.material = LuaGetArgument_Material(L, -1); + lua_pop(L, 3); + return result; +} + +//---------------------------------------------------------------------------------- +// LuaPush functions +//---------------------------------------------------------------------------------- +static void LuaPush_Color(lua_State* L, Color color) +{ + lua_createtable(L, 0, 4); + lua_pushinteger(L, color.r); + lua_setfield(L, -2, "r"); + lua_pushinteger(L, color.g); + lua_setfield(L, -2, "g"); + lua_pushinteger(L, color.b); + lua_setfield(L, -2, "b"); + lua_pushinteger(L, color.a); + lua_setfield(L, -2, "a"); +} + +static void LuaPush_Vector2(lua_State* L, Vector2 vec) +{ + lua_createtable(L, 0, 2); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); +} + +static void LuaPush_Vector3(lua_State* L, Vector3 vec) +{ + lua_createtable(L, 0, 3); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); + lua_pushnumber(L, vec.z); + lua_setfield(L, -2, "z"); +} + +static void LuaPush_Quaternion(lua_State* L, Quaternion vec) +{ + lua_createtable(L, 0, 4); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); + lua_pushnumber(L, vec.z); + lua_setfield(L, -2, "z"); + lua_pushnumber(L, vec.w); + lua_setfield(L, -2, "w"); +} + +static void LuaPush_Matrix(lua_State* L, Matrix *matrix) +{ + int i; + lua_createtable(L, 16, 0); + float* num = (&matrix->m0); + for (i = 0; i < 16; i++) + { + lua_pushnumber(L, num[i]); + lua_rawseti(L, -2, i + 1); + } +} + +static void LuaPush_Rectangle(lua_State* L, Rectangle rect) +{ + lua_createtable(L, 0, 4); + lua_pushinteger(L, rect.x); + lua_setfield(L, -2, "x"); + lua_pushinteger(L, rect.y); + lua_setfield(L, -2, "y"); + lua_pushinteger(L, rect.width); + lua_setfield(L, -2, "width"); + lua_pushinteger(L, rect.height); + lua_setfield(L, -2, "height"); +} + +static void LuaPush_Ray(lua_State* L, Ray ray) +{ + lua_createtable(L, 0, 2); + LuaPush_Vector3(L, ray.position); + lua_setfield(L, -2, "position"); + LuaPush_Vector3(L, ray.direction); + lua_setfield(L, -2, "direction"); +} + +static void LuaPush_BoundingBox(lua_State* L, BoundingBox bb) +{ + lua_createtable(L, 0, 2); + LuaPush_Vector3(L, bb.min); + lua_setfield(L, -2, "min"); + LuaPush_Vector3(L, bb.max); + lua_setfield(L, -2, "max"); +} + +static void LuaPush_Camera(lua_State* L, Camera cam) +{ + lua_createtable(L, 0, 4); + LuaPush_Vector3(L, cam.position); + lua_setfield(L, -2, "position"); + LuaPush_Vector3(L, cam.target); + lua_setfield(L, -2, "target"); + LuaPush_Vector3(L, cam.up); + lua_setfield(L, -2, "up"); + lua_pushnumber(L, cam.fovy); + lua_setfield(L, -2, "fovy"); +} + +static void LuaPush_Camera2D(lua_State* L, Camera2D cam) +{ + lua_createtable(L, 0, 3); + LuaPush_Vector2(L, cam.offset); + lua_setfield(L, -2, "offset"); + LuaPush_Vector2(L, cam.target); + lua_setfield(L, -2, "target"); + lua_pushnumber(L, cam.rotation); + lua_setfield(L, -2, "rotation"); + lua_pushnumber(L, cam.zoom); + lua_setfield(L, -2, "zoom"); +} + +static void LuaPush_Material(lua_State* L, Material mat) +{ + lua_createtable(L, 0, 8); + LuaPush_Shader(L, mat.shader); + lua_setfield(L, -2, "shader"); + LuaPush_Texture2D(L, mat.texDiffuse); + lua_setfield(L, -2, "texDiffuse"); + LuaPush_Texture2D(L, mat.texNormal); + lua_setfield(L, -2, "texNormal"); + LuaPush_Texture2D(L, mat.texSpecular); + lua_setfield(L, -2, "texSpecular"); + LuaPush_Color(L, mat.colDiffuse); + lua_setfield(L, -2, "colDiffuse"); + LuaPush_Color(L, mat.colAmbient); + lua_setfield(L, -2, "colAmbient"); + LuaPush_Color(L, mat.colSpecular); + lua_setfield(L, -2, "colSpecular"); + lua_pushnumber(L, mat.glossiness); + lua_setfield(L, -2, "glossiness"); +} + +static void LuaPush_Model(lua_State* L, Model mdl) +{ + lua_createtable(L, 0, 4); + LuaPush_Mesh(L, mdl.mesh); + lua_setfield(L, -2, "mesh"); + LuaPush_Matrix(L, &mdl.transform); + lua_setfield(L, -2, "transform"); + LuaPush_Material(L, mdl.material); + lua_setfield(L, -2, "material"); +} + +//---------------------------------------------------------------------------------- +// raylib Lua Structure constructors +//---------------------------------------------------------------------------------- +static int lua_Color(lua_State* L) +{ + LuaPush_Color(L, (Color) { (unsigned char)luaL_checkinteger(L, 1), (unsigned char)luaL_checkinteger(L, 2), (unsigned char)luaL_checkinteger(L, 3), (unsigned char)luaL_checkinteger(L, 4) }); + return 1; +} + +static int lua_Vector2(lua_State* L) +{ + LuaPush_Vector2(L, (Vector2) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2) }); + return 1; +} + +static int lua_Vector3(lua_State* L) +{ + LuaPush_Vector3(L, (Vector3) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3) }); + return 1; +} + +static int lua_Rectangle(lua_State* L) +{ + LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) }); + return 1; +} + +static int lua_Ray(lua_State* L) +{ + Vector2 pos = LuaGetArgument_Vector2(L, 1); + Vector2 dir = LuaGetArgument_Vector2(L, 2); + LuaPush_Ray(L, (Ray) { { pos.x, pos.y }, { dir.x, dir.y } }); + return 1; +} + +static int lua_Camera(lua_State* L) +{ + Vector3 pos = LuaGetArgument_Vector3(L, 1); + Vector3 tar = LuaGetArgument_Vector3(L, 2); + Vector3 up = LuaGetArgument_Vector3(L, 3); + float fovy = LuaGetArgument_float(L, 4); + LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, fovy }); + return 1; +} + +static int lua_Camera2D(lua_State* L) +{ + Vector2 off = LuaGetArgument_Vector2(L, 1); + Vector2 tar = LuaGetArgument_Vector2(L, 2); + float rot = LuaGetArgument_float(L, 3); + float zoom = LuaGetArgument_float(L, 4); + LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom }); + return 1; +} + + +/************************************************************************************* +* raylib Lua Functions Bindings +**************************************************************************************/ + +//------------------------------------------------------------------------------------ +// raylib [core] module functions - Window and Graphics Device +//------------------------------------------------------------------------------------ +int lua_InitWindow(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + const char* arg3 = LuaGetArgument_string(L, 3); + InitWindow(arg1, arg2, arg3); + return 0; +} + +int lua_CloseWindow(lua_State* L) +{ + CloseWindow(); + return 0; +} + +int lua_WindowShouldClose(lua_State* L) +{ + bool result = WindowShouldClose(); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsWindowMinimized(lua_State* L) +{ + bool result = IsWindowMinimized(); + lua_pushboolean(L, result); + return 1; +} + +int lua_ToggleFullscreen(lua_State* L) +{ + ToggleFullscreen(); + return 0; +} + +int lua_GetScreenWidth(lua_State* L) +{ + int result = GetScreenWidth(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetScreenHeight(lua_State* L) +{ + int result = GetScreenHeight(); + lua_pushinteger(L, result); + return 1; +} + +int lua_ShowCursor(lua_State* L) +{ + ShowCursor(); + return 0; +} + +int lua_HideCursor(lua_State* L) +{ + HideCursor(); + return 0; +} + +int lua_IsCursorHidden(lua_State* L) +{ + bool result = IsCursorHidden(); + lua_pushboolean(L, result); + return 1; +} + +// TODO: +/* +void EnableCursor(void); // Enables cursor +void DisableCursor(void); // Disables cursor +*/ + +int lua_ClearBackground(lua_State* L) +{ + Color arg1 = LuaGetArgument_Color(L, 1); + ClearBackground(arg1); + return 0; +} + +int lua_BeginDrawing(lua_State* L) +{ + BeginDrawing(); + return 0; +} + +int lua_EndDrawing(lua_State* L) +{ + EndDrawing(); + return 0; +} + +// TODO: +//void Begin2dMode(Camera2D camera); // Initialize 2D mode with custom camera +//void End2dMode(void); // Ends 2D mode custom camera usage + +int lua_Begin3dMode(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + Begin3dMode(arg1); + return 0; +} + +int lua_End3dMode(lua_State* L) +{ + End3dMode(); + return 0; +} + +// TODO: +//void BeginTextureMode(RenderTexture2D target); // Initializes render texture for drawing +//void EndTextureMode(void); // Ends drawing to render texture + +int lua_GetMouseRay(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Camera arg2 = LuaGetArgument_Camera(L, 2); + Ray result = GetMouseRay(arg1, arg2); + LuaPush_Ray(L, result); + return 1; +} + +// TODO: +//Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Returns the screen space position from a 3d world space position +//Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix) + +#if defined(PLATFORM_WEB) + +static int LuaDrawLoopFunc; + +static void LuaDrawLoop() +{ + lua_rawgeti(L, LUA_REGISTRYINDEX, LuaDrawLoopFunc); + lua_call(L, 0, 0); +} + +int lua_SetDrawingLoop(lua_State* L) +{ + luaL_argcheck(L, lua_isfunction(L, 1), 1, "Loop function expected"); + lua_pushvalue(L, 1); + LuaDrawLoopFunc = luaL_ref(L, LUA_REGISTRYINDEX); + SetDrawingLoop(&LuaDrawLoop); + return 0; +} + +#else + +int lua_SetTargetFPS(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetTargetFPS(arg1); + return 0; +} +#endif + +int lua_GetFPS(lua_State* L) +{ + float result = GetFPS(); + lua_pushnumber(L, result); + return 1; +} + +int lua_GetFrameTime(lua_State* L) +{ + float result = GetFrameTime(); + lua_pushnumber(L, result); + return 1; +} + +int lua_GetColor(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + Color result = GetColor(arg1); + LuaPush_Color(L, result); + return 1; +} + +int lua_GetHexValue(lua_State* L) +{ + Color arg1 = LuaGetArgument_Color(L, 1); + int result = GetHexValue(arg1); + lua_pushinteger(L, result); + return 1; +} + +// TODO: +/* +float *ColorToFloat(Color color); // Converts Color to float array and normalizes +float *VectorToFloat(Vector3 vec); // Converts Vector3 to float array +float *MatrixToFloat(Matrix mat); // Converts Matrix to float array +*/ + +int lua_GetRandomValue(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int result = GetRandomValue(arg1, arg2); + lua_pushinteger(L, result); + return 1; +} + +int lua_Fade(lua_State* L) +{ + Color arg1 = LuaGetArgument_Color(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color result = Fade(arg1, arg2); + LuaPush_Color(L, result); + return 1; +} + +int lua_SetConfigFlags(lua_State* L) +{ + char arg1 = LuaGetArgument_char(L, 1); + SetConfigFlags(arg1); + return 0; +} + +int lua_ShowLogo(lua_State* L) +{ + ShowLogo(); + return 0; +} + +int lua_IsFileDropped(lua_State* L) +{ + bool result = IsFileDropped(); + lua_pushboolean(L, result); + return 1; +} +/* +int lua_*GetDroppedFiles(lua_State* L) +{ + int * arg1 = LuaGetArgument_int *(L, 1); + //char * result = *GetDroppedFiles(arg1); + LuaPush_//char *(L, result); + return 1; +} +*/ +int lua_ClearDroppedFiles(lua_State* L) +{ + ClearDroppedFiles(); + return 0; +} + +int lua_StorageSaveValue(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + StorageSaveValue(arg1, arg2); + return 0; +} + +int lua_StorageLoadValue(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int result = StorageLoadValue(arg1); + lua_pushinteger(L, result); + return 1; +} + +//------------------------------------------------------------------------------------ +// raylib [core] module functions - Input Handling +//------------------------------------------------------------------------------------ +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) +int lua_IsKeyPressed(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyPressed(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsKeyDown(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyDown(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsKeyReleased(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyReleased(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsKeyUp(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyUp(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_GetKeyPressed(lua_State* L) +{ + int result = GetKeyPressed(); + lua_pushinteger(L, result); + return 1; +} + +int lua_SetExitKey(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetExitKey(arg1); + return 0; +} + +int lua_IsGamepadAvailable(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsGamepadAvailable(arg1); + lua_pushboolean(L, result); + return 1; +} + +// TODO: Review +// float GetGamepadAxisMovement(int gamepad, int axis); // Return axis movement value for a gamepad axis +/* +int lua_GetGamepadMovement(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + Vector2 result = GetGamepadMovement(arg1); + LuaPush_Vector2(L, result); + return 1; +} +*/ + +int lua_IsGamepadButtonPressed(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonPressed(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsGamepadButtonDown(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonDown(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsGamepadButtonReleased(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonReleased(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsGamepadButtonUp(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonUp(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} +#endif + +int lua_IsMouseButtonPressed(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonPressed(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsMouseButtonDown(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonDown(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsMouseButtonReleased(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonReleased(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsMouseButtonUp(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonUp(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_GetMouseX(lua_State* L) +{ + int result = GetMouseX(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetMouseY(lua_State* L) +{ + int result = GetMouseY(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetMousePosition(lua_State* L) +{ + Vector2 result = GetMousePosition(); + LuaPush_Vector2(L, result); + return 1; +} + +int lua_SetMousePosition(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + SetMousePosition(arg1); + return 0; +} + +int lua_GetMouseWheelMove(lua_State* L) +{ + int result = GetMouseWheelMove(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetTouchX(lua_State* L) +{ + int result = GetTouchX(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetTouchY(lua_State* L) +{ + int result = GetTouchY(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetTouchPosition(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + Vector2 result = GetTouchPosition(arg1); + LuaPush_Vector2(L, result); + return 1; +} + +// TODO: +/* +#if defined(PLATFORM_ANDROID) +bool IsButtonPressed(int button); // Detect if an android physic button has been pressed +bool IsButtonDown(int button); // Detect if an android physic button is being pressed +bool IsButtonReleased(int button); // Detect if an android physic button has been released +#endif +*/ + +//------------------------------------------------------------------------------------ +// raylib [gestures] module functions - Gestures and Touch Handling +//------------------------------------------------------------------------------------ +int lua_SetGesturesEnabled(lua_State* L) +{ + unsigned arg1 = LuaGetArgument_unsigned(L, 1); + SetGesturesEnabled(arg1); + return 0; +} + +int lua_IsGestureDetected(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsGestureDetected(arg1); + lua_pushboolean(L, result); + return 1; +} + +// TODO: +///void ProcessGestureEvent(GestureEvent event); // Process gesture event and translate it into gestures + +int lua_UpdateGestures(lua_State* L) +{ + UpdateGestures(); + return 0; +} + +int lua_GetTouchPointsCount(lua_State* L) +{ + int result = GetTouchPointsCount(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetGestureDetected(lua_State* L) +{ + int result = GetGestureDetected(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetGestureHoldDuration(lua_State* L) +{ + int result = GetGestureHoldDuration(); + lua_pushinteger(L, result); + return 1; +} + +int lua_GetGestureDragVector(lua_State* L) +{ + Vector2 result = GetGestureDragVector(); + LuaPush_Vector2(L, result); + return 1; +} + +int lua_GetGestureDragAngle(lua_State* L) +{ + float result = GetGestureDragAngle(); + lua_pushnumber(L, result); + return 1; +} + +int lua_GetGesturePinchVector(lua_State* L) +{ + Vector2 result = GetGesturePinchVector(); + LuaPush_Vector2(L, result); + return 1; +} + +int lua_GetGesturePinchAngle(lua_State* L) +{ + float result = GetGesturePinchAngle(); + lua_pushnumber(L, result); + return 1; +} + +//------------------------------------------------------------------------------------ +// raylib [camera] module functions - Camera System +//------------------------------------------------------------------------------------ +int lua_SetCameraMode(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetCameraMode(arg1); + return 0; +} + +int lua_UpdateCamera(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + UpdateCamera(&arg1); + LuaPush_Camera(L, arg1); + return 1; +} + +int lua_UpdateCameraPlayer(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + UpdateCameraPlayer(&arg1, &arg2); + LuaPush_Camera(L, arg1); + LuaPush_Vector3(L, arg2); + return 2; +} + +int lua_SetCameraPosition(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + SetCameraPosition(arg1); + return 0; +} + +int lua_SetCameraTarget(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + SetCameraTarget(arg1); + return 0; +} + +int lua_SetCameraFovy(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + SetCameraFovy(arg1); + return 0; +} + +int lua_SetCameraPanControl(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetCameraPanControl(arg1); + return 0; +} + +int lua_SetCameraAltControl(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetCameraAltControl(arg1); + return 0; +} + +int lua_SetCameraSmoothZoomControl(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + SetCameraSmoothZoomControl(arg1); + return 0; +} + +int lua_SetCameraMoveControls(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + int arg6 = LuaGetArgument_int(L, 6); + SetCameraMoveControls(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_SetCameraMouseSensitivity(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + SetCameraMouseSensitivity(arg1); + return 0; +} + +//------------------------------------------------------------------------------------ +// raylib [shapes] module functions - Basic Shapes Drawing +//------------------------------------------------------------------------------------ +int lua_DrawPixel(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawPixel(arg1, arg2, arg3); + return 0; +} + +int lua_DrawPixelV(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPixelV(arg1, arg2); + return 0; +} + +int lua_DrawLine(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawLine(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawLineV(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawLineV(arg1, arg2, arg3); + return 0; +} + +int lua_DrawCircle(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawCircle(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawCircleGradient(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCircleGradient(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawCircleV(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawCircleV(arg1, arg2, arg3); + return 0; +} + +int lua_DrawCircleLines(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawCircleLines(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawRectangle(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawRectangle(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawRectangleRec(lua_State* L) +{ + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawRectangleRec(arg1, arg2); + return 0; +} + +int lua_DrawRectangleGradient(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawRectangleGradient(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawRectangleV(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawRectangleV(arg1, arg2, arg3); + return 0; +} + +int lua_DrawRectangleLines(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawRectangleLines(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawTriangle(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTriangle(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawTriangleLines(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTriangleLines(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawPoly(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawPoly(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +#define GET_TABLE(type, name, index) \ + type* name = 0; \ + size_t name##_size = 0; \ + { \ + size_t sz = 0; \ + luaL_checktype(L, index, LUA_TTABLE); \ + lua_pushnil(L); \ + while (lua_next(L, index)) { \ + LuaGetArgument_##type(L, -1); \ + sz++; \ + lua_pop(L, 1); \ + } \ + lua_pop(L, 1); \ + name = calloc(sz, sizeof(type)); \ + sz = 0; \ + lua_pushnil(L); \ + while (lua_next(L, index)) { \ + name[sz] = LuaGetArgument_##type(L, -1); \ + sz++; \ + lua_pop(L, 1); \ + } \ + lua_pop(L, 1); \ + name##_size = sz; \ + } + + +int lua_DrawPolyEx(lua_State* L) +{ + GET_TABLE(Vector2, arg1, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPolyEx(arg1, arg1_size, arg2); + free(arg1); + return 0; +} + +int lua_DrawPolyExLines(lua_State* L) +{ + GET_TABLE(Vector2, arg1, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPolyExLines(arg1, arg1_size, arg2); + free(arg1); + return 0; +} + +int lua_CheckCollisionRecs(lua_State* L) +{ + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + bool result = CheckCollisionRecs(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionCircles(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + bool result = CheckCollisionCircles(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionCircleRec(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + bool result = CheckCollisionCircleRec(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; +} + +int lua_GetCollisionRec(lua_State* L) +{ + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Rectangle result = GetCollisionRec(arg1, arg2); + LuaPush_Rectangle(L, result); + return 1; +} + +int lua_CheckCollisionPointRec(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + bool result = CheckCollisionPointRec(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionPointCircle(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + bool result = CheckCollisionPointCircle(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionPointTriangle(lua_State* L) +{ + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Vector2 arg4 = LuaGetArgument_Vector2(L, 4); + bool result = CheckCollisionPointTriangle(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; +} + +//------------------------------------------------------------------------------------ +// raylib [textures] module functions - Texture Loading and Drawing +//------------------------------------------------------------------------------------ +int lua_LoadImage(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Image result = LoadImage(arg1); + LuaPush_Image(L, result); + return 1; +} + +int lua_LoadImageEx(lua_State* L) +{ + //Color * arg1 = LuaGetArgument_Color *(L, 1); + GET_TABLE(Color, arg1, 1); + + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + Image result = LoadImageEx(arg1, arg2, arg3); + LuaPush_Image(L, result); + + free(arg1); + return 1; +} + +int lua_LoadImageRaw(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Image result = LoadImageRaw(arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, result); + return 1; +} + +int lua_LoadImageFromRES(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Image result = LoadImageFromRES(arg1, arg2); + LuaPush_Image(L, result); + return 1; +} + +int lua_LoadTexture(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Texture2D result = LoadTexture(arg1); + LuaPush_Texture2D(L, result); + return 1; +} + +// TODO: Texture2D LoadTextureEx(void *data, int width, int height, int textureFormat); +int lua_LoadTextureEx(lua_State* L) +{ + void * arg1 = LuaGetArgument_string(L, 1); // TODO: How to get a void * ? + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Texture2D result = LoadTextureEx(arg1, arg2, arg3, arg4); + LuaPush_Texture2D(L, result); + return 1; +} + +int lua_LoadTextureFromRES(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Texture2D result = LoadTextureFromRES(arg1, arg2); + LuaPush_Texture2D(L, result); + return 1; +} + +int lua_LoadTextureFromImage(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Texture2D result = LoadTextureFromImage(arg1); + LuaPush_Texture2D(L, result); + return 1; +} + +int lua_LoadRenderTexture(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + RenderTexture2D result = LoadRenderTexture(arg1, arg2); + LuaPush_RenderTexture2D(L, result); + return 1; +} + +int lua_UnloadImage(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + UnloadImage(arg1); + return 0; +} + +int lua_UnloadTexture(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + UnloadTexture(arg1); + return 0; +} + +int lua_UnloadRenderTexture(lua_State* L) +{ + RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); + UnloadRenderTexture(arg1); + return 0; +} + +int lua_GetImageData(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Color * result = GetImageData(arg1); + lua_createtable(L, arg1.width*arg1.height, 0); + for (int i = 0; i < arg1.width*arg1.height; i++) + { + LuaPush_Color(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; +} + +int lua_GetTextureData(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Image result = GetTextureData(arg1); + LuaPush_Image(L, result); + return 1; +} + +int lua_ImageToPOT(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + ImageToPOT(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageFormat(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + ImageFormat(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} + +// TODO: +/* +void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) +Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) +void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle +void ImageResize(Image *image, int newWidth, int newHeight); // Resize and image (bilinear filtering) +void ImageResizeNN(Image *image,int newWidth,int newHeight); // Resize and image (Nearest-Neighbor scaling algorithm) +Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) +Image ImageTextEx(SpriteFont font, const char *text, int fontSize, int spacing, Color tint); // Create an image from text (custom sprite font) +void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec); // Draw a source image within a destination image +void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color); // Draw text (default font) within an image (destination) +void ImageDrawTextEx(Image *dst, Vector2 position, SpriteFont font, const char *text, int fontSize, int spacing, Color color); // Draw text (custom sprite font) within an image (destination) +void ImageFlipVertical(Image *image); // Flip image vertically +void ImageFlipHorizontal(Image *image); // Flip image horizontally +void ImageColorTint(Image *image, Color color); // Modify image color: tint +void ImageColorInvert(Image *image); // Modify image color: invert +void ImageColorGrayscale(Image *image); // Modify image color: grayscale +void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) +void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) +*/ + +int lua_GenTextureMipmaps(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + GenTextureMipmaps(arg1); + return 0; +} + +// TODO: void UpdateTexture(Texture2D texture, void *pixels); // Update GPU texture with new data + +int lua_DrawTexture(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTexture(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawTextureV(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawTextureV(arg1, arg2, arg3); + return 0; +} + +int lua_DrawTextureEx(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawTextureEx(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawTextureRec(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTextureRec(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawTexturePro(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Vector2 arg4 = LuaGetArgument_Vector2(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawTexturePro(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +//------------------------------------------------------------------------------------ +// raylib [text] module functions - Font Loading and Text Drawing +//------------------------------------------------------------------------------------ +int lua_GetDefaultFont(lua_State* L) +{ + SpriteFont result = GetDefaultFont(); + LuaPush_SpriteFont(L, result); + return 1; +} + +int lua_LoadSpriteFont(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + SpriteFont result = LoadSpriteFont(arg1); + LuaPush_SpriteFont(L, result); + return 1; +} + +int lua_UnloadSpriteFont(lua_State* L) +{ + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + UnloadSpriteFont(arg1); + return 0; +} + +int lua_DrawText(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawText(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawTextEx(lua_State* L) +{ + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + const char* arg2 = LuaGetArgument_string(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_MeasureText(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int result = MeasureText(arg1, arg2); + lua_pushinteger(L, result); + return 1; +} + +int lua_MeasureTextEx(lua_State* L) +{ + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Vector2 result = MeasureTextEx(arg1, arg2, arg3, arg4); + LuaPush_Vector2(L, result); + return 1; +} + +int lua_DrawFPS(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + DrawFPS(arg1, arg2); + return 0; +} + +// TODO: +/* +const char *FormatText(const char *text, ...); // Formatting of text with variables to 'embed' +const char *SubText(const char *text, int position, int length); // Get a piece of a text string +*/ + +int lua_DrawCube(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCube(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawCubeV(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawCubeV(arg1, arg2, arg3); + return 0; +} + +int lua_DrawCubeWires(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCubeWires(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawCubeTexture(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCubeTexture(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawSphere(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawSphere(arg1, arg2, arg3); + return 0; +} + +int lua_DrawSphereEx(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawSphereEx(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawSphereWires(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawSphereWires(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawCylinder(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCylinder(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawCylinderWires(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCylinderWires(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawPlane(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawPlane(arg1, arg2, arg3); + return 0; +} + +int lua_DrawRay(lua_State* L) +{ + Ray arg1 = LuaGetArgument_Ray(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawRay(arg1, arg2); + return 0; +} + +int lua_DrawGrid(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + DrawGrid(arg1, arg2); + return 0; +} + +int lua_DrawGizmo(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + DrawGizmo(arg1); + return 0; +} + +// TODO: +/* +void DrawLight(Light light); // Draw light in 3D world +void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +void Draw3DCircle(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color); // Draw a circle in 3D world space +*/ + +//------------------------------------------------------------------------------------ +// raylib [models] module functions +//------------------------------------------------------------------------------------ +int lua_LoadModel(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Model result = LoadModel(arg1); + LuaPush_Model(L, result); + return 1; +} + +int lua_LoadModelEx(lua_State* L) +{ + Mesh arg1 = LuaGetArgument_Mesh(L, 1); + bool arg2 = LuaGetArgument_int(L, 2); + Model result = LoadModelEx(arg1, arg2); + LuaPush_Model(L, result); + return 1; +} + +int lua_LoadModelFromRES(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Model result = LoadModelFromRES(arg1, arg2); + LuaPush_Model(L, result); + return 1; +} + +int lua_LoadHeightmap(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Model result = LoadHeightmap(arg1, arg2); + LuaPush_Model(L, result); + return 1; +} + +int lua_LoadCubicmap(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Model result = LoadCubicmap(arg1); + LuaPush_Model(L, result); + return 1; +} + +int lua_UnloadModel(lua_State* L) +{ + Model arg1 = LuaGetArgument_Model(L, 1); + UnloadModel(arg1); + return 0; +} + +// TODO: GenMesh*() + +int lua_LoadMaterial(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Material result = LoadMaterial(arg1); + LuaPush_Material(L, result); + return 1; +} + +int lua_LoadDefaultMaterial(lua_State* L) +{ + Material result = LoadDefaultMaterial(); + LuaPush_Material(L, result); + return 1; +} + +int lua_LoadStandardMaterial(lua_State* L) +{ + Material result = LoadStandardMaterial(); + LuaPush_Material(L, result); + return 1; +} + +int lua_UnloadMaterial(lua_State* L) +{ + Material arg1 = LuaGetArgument_Material(L, 1); + UnloadMaterial(arg1); + return 0; +} + +int lua_DrawModel(lua_State* L) +{ + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawModel(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawModelEx(lua_State* L) +{ + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Vector3 arg5 = LuaGetArgument_Vector3(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawModelEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawModelWires(lua_State* L) +{ + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawModelWires(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_DrawModelWiresEx(lua_State* L) +{ + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Vector3 arg5 = LuaGetArgument_Vector3(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawModelWiresEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_DrawBillboard(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawBillboard(arg1, arg2, arg3, arg4, arg5); + return 0; +} + +int lua_DrawBillboardRec(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawBillboardRec(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; +} + +int lua_CalculateBoundingBox(lua_State* L) +{ + Mesh arg1 = LuaGetArgument_Mesh(L, 1); + BoundingBox result = CalculateBoundingBox(arg1); + LuaPush_BoundingBox(L, result); + return 0; +} + +int lua_CheckCollisionSpheres(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + bool result = CheckCollisionSpheres(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionBoxes(lua_State* L) +{ + BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); + BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); + bool result = CheckCollisionBoxes(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionBoxSphere(lua_State* L) +{ + BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 4); + bool result = CheckCollisionBoxSphere(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; +} + +// TODO: +/* +bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius); // Detect collision between ray and sphere +bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint); // Detect collision between ray and sphere with extended parameters and collision point detection +bool CheckCollisionRayBox(Ray ray, BoundingBox box); // Detect collision between ray and box +Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *playerPosition, float radius); // Detect collision of player radius with cubicmap +*/ + +int lua_ResolveCollisionCubicmap(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Vector3 result = ResolveCollisionCubicmap(arg1, arg2, &arg3, arg4); + LuaPush_Vector3(L, result); + LuaPush_Vector3(L, arg3); + return 2; +} + +//------------------------------------------------------------------------------------ +// raylib [raymath] module functions - Shaders +//------------------------------------------------------------------------------------ +int lua_LoadShader(lua_State* L) +{ + char * arg1 = (char*)LuaGetArgument_string(L, 1); + char * arg2 = (char*)LuaGetArgument_string(L, 2); + Shader result = LoadShader(arg1, arg2); + LuaPush_Shader(L, result); + return 1; +} + +int lua_UnloadShader(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + UnloadShader(arg1); + return 0; +} + +int lua_GetDefaultShader(lua_State* L) +{ + Shader result = GetDefaultShader(); + LuaPush_Shader(L, result); + return 1; +} + +int lua_GetStandardShader(lua_State* L) +{ + Shader result = GetStandardShader(); + LuaPush_Shader(L, result); + return 1; +} + +int lua_GetDefaultTexture(lua_State* L) +{ + Texture2D result = GetDefaultTexture(); + LuaPush_Texture2D(L, result); + return 1; +} + +int lua_GetShaderLocation(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + int result = GetShaderLocation(arg1, arg2); + lua_pushinteger(L, result); + return 1; +} + +int lua_SetShaderValue(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + GET_TABLE(float, arg3, 3); + SetShaderValue(arg1, arg2, arg3, arg3_size); + free(arg3); + return 0; +} + +int lua_SetShaderValuei(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + GET_TABLE(int, arg3, 3); + SetShaderValuei(arg1, arg2, arg3, arg3_size); + free(arg3); + return 0; +} + +int lua_SetShaderValueMatrix(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Matrix arg3 = LuaGetArgument_Matrix(L, 3); + SetShaderValueMatrix(arg1, arg2, arg3); + return 0; +} + +int lua_SetMatrixProjection(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + SetMatrixProjection(arg1); + return 0; +} + +int lua_SetMatrixModelview(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + SetMatrixModelview(arg1); + return 0; +} + +int lua_BeginShaderMode(lua_State* L) +{ + Shader arg1 = LuaGetArgument_Shader(L, 1); + BeginShaderMode(arg1); + return 0; +} + +int lua_EndShaderMode(lua_State* L) +{ + EndShaderMode(); + return 0; +} + +int lua_BeginBlendMode(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + BeginBlendMode(arg1); + return 0; +} + +int lua_EndBlendMode(lua_State* L) +{ + EndBlendMode(); + return 0; +} + +// TODO: +//Light CreateLight(int type, Vector3 position, Color diffuse); // Create a new light, initialize it and add to pool +//void DestroyLight(Light light); // Destroy a light and take it out of the list + +// TODO: +/* +//------------------------------------------------------------------------------------ +// raylib [rlgl] module functions - VR experience +//------------------------------------------------------------------------------------ +void InitVrDevice(int vdDevice); // Init VR device +void CloseVrDevice(void); // Close VR device +void UpdateVrTracking(void); // Update VR tracking (position and orientation) +void BeginVrDrawing(void); // Begin VR drawing configuration +void EndVrDrawing(void); // End VR drawing process (and desktop mirror) +bool IsVrDeviceReady(void); // Detect if VR device (or simulator) is ready +void ToggleVrMode(void); // Enable/Disable VR experience (device or simulator) +*/ + +//------------------------------------------------------------------------------------ +// raylib [audio] module functions +//------------------------------------------------------------------------------------ +int lua_InitAudioDevice(lua_State* L) +{ + InitAudioDevice(); + return 0; +} + +int lua_CloseAudioDevice(lua_State* L) +{ + CloseAudioDevice(); + return 0; +} + +int lua_IsAudioDeviceReady(lua_State* L) +{ + bool result = IsAudioDeviceReady(); + lua_pushboolean(L, result); + return 0; +} + +int lua_LoadSound(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Sound result = LoadSound((char*)arg1); + LuaPush_Sound(L, result); + return 1; +} + +int lua_LoadSoundFromWave(lua_State* L) +{ + Wave arg1 = LuaGetArgument_Wave(L, 1); + Sound result = LoadSoundFromWave(arg1); + LuaPush_Sound(L, result); + return 1; +} + +int lua_LoadSoundFromRES(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Sound result = LoadSoundFromRES(arg1, arg2); + LuaPush_Sound(L, result); + return 1; +} + +int lua_UnloadSound(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + UnloadSound(arg1); + return 0; +} + +int lua_PlaySound(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + PlaySound(arg1); + return 0; +} + +int lua_PauseSound(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + PauseSound(arg1); + return 0; +} + +int lua_ResumeSound(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + ResumeSound(arg1); + return 0; +} + +int lua_StopSound(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + StopSound(arg1); + return 0; +} + +int lua_IsSoundPlaying(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + bool result = IsSoundPlaying(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_SetSoundVolume(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetSoundVolume(arg1, arg2); + return 0; +} + +int lua_SetSoundPitch(lua_State* L) +{ + Sound arg1 = LuaGetArgument_Sound(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetSoundPitch(arg1, arg2); + return 0; +} + +int lua_LoadMusicStream(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + Music result = LoadMusicStream((char *)arg1); + LuaPush_Music(L, result); + return 0; +} + +int lua_UnloadMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + UnloadMusicStream(arg1); + return 0; +} + +int lua_PlayMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + PlayMusicStream(arg1); + return 0; +} + +int lua_UpdateMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + UpdateMusicStream(arg1); + return 0; +} + +int lua_StopMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + StopMusicStream(arg1); + return 0; +} + +int lua_PauseMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + PauseMusicStream(arg1); + return 0; +} + +int lua_ResumeMusicStream(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + ResumeMusicStream(arg1); + return 0; +} + +int lua_IsMusicPlaying(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + bool result = IsMusicPlaying(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_SetMusicVolume(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetMusicVolume(arg1, arg2); + return 0; +} + +int lua_GetMusicTimeLength(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + float result = GetMusicTimeLength(arg1); + lua_pushnumber(L, result); + return 1; +} + +int lua_GetMusicTimePlayed(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + float result = GetMusicTimePlayed(arg1); + lua_pushnumber(L, result); + return 1; +} + +// TODO: +/* +AudioStream InitAudioStream(unsigned int sampleRate, + unsigned int sampleSize, + unsigned int channels); // Init audio stream (to stream audio pcm data) +void UpdateAudioStream(AudioStream stream, void *data, int numSamples); // Update audio stream buffers with data +void CloseAudioStream(AudioStream stream); // Close audio stream and free memory +bool IsAudioBufferProcessed(AudioStream stream); // Check if any audio stream buffers requires refill +void PlayAudioStream(AudioStream stream); // Play audio stream +void PauseAudioStream(AudioStream stream); // Pause audio stream +void ResumeAudioStream(AudioStream stream); // Resume audio stream +void StopAudioStream(AudioStream stream); // Stop audio stream +*/ + +//---------------------------------------------------------------------------------- +// raylib [utils] module functions +//---------------------------------------------------------------------------------- +int lua_DecompressData(lua_State* L) +{ + unsigned char *arg1 = (unsigned char *)LuaGetArgument_string(L, 1); + unsigned arg2 = (unsigned)LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + unsigned char *result = DecompressData(arg1, arg2, arg3); + lua_pushlstring(L, (const char *)result, arg3); + return 1; +} + +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) +int lua_WriteBitmap(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + WriteBitmap(arg1, arg2, arg3, arg4); + return 0; +} + +int lua_WritePNG(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + WritePNG(arg1, arg2, arg3, arg4, arg5); + return 0; +} +#endif + +int lua_TraceLog(lua_State* L) +{ + int num_args = lua_gettop(L) - 1; + int arg1 = LuaGetArgument_int(L, 1); + + /// type, fmt, args... + + lua_rotate(L, 1, -1); /// fmt, args..., type + lua_pop(L, 1); /// fmt, args... + + lua_getglobal(L, "string"); /// fmt, args..., [string] + lua_getfield(L, 1, "format"); /// fmt, args..., [string], format() + lua_rotate(L, 1, 2); /// [string], format(), fmt, args... + lua_call(L, num_args, 1); /// [string], formatted_string + + TraceLog(arg1, "%s", luaL_checkstring(L,-1)); + return 0; +} + +int lua_GetExtension(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + const char* result = GetExtension(arg1); + lua_pushstring(L, result); + return 1; +} + +int lua_GetNextPOT(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int result = GetNextPOT(arg1); + lua_pushinteger(L, result); + return 1; +} + +//---------------------------------------------------------------------------------- +// raylib [raymath] module functions - Vector3 math +//---------------------------------------------------------------------------------- +int lua_VectorAdd(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorAdd(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorSubtract(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorSubtract(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorCrossProduct(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorCrossProduct(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorPerpendicular(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 result = VectorPerpendicular(arg1); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorDotProduct(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float result = VectorDotProduct(arg1, arg2); + lua_pushnumber(L, result); + return 1; +} + +int lua_VectorLength(lua_State* L) +{ + const Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float result = VectorLength(arg1); + lua_pushnumber(L, result); + return 1; +} + +int lua_VectorScale(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + VectorScale(&arg1, arg2); + LuaPush_Vector3(L, arg1); + return 1; +} + +int lua_VectorNegate(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + VectorNegate(&arg1); + LuaPush_Vector3(L, arg1); + return 1; +} + +int lua_VectorNormalize(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + VectorNormalize(&arg1); + LuaPush_Vector3(L, arg1); + return 1; +} + +int lua_VectorDistance(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float result = VectorDistance(arg1, arg2); + lua_pushnumber(L, result); + return 1; +} + +int lua_VectorLerp(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Vector3 result = VectorLerp(arg1, arg2, arg3); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorReflect(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorReflect(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; +} + +int lua_VectorTransform(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + VectorTransform(&arg1, arg2); + LuaPush_Vector3(L, arg1); + return 1; +} + +int lua_VectorZero(lua_State* L) +{ + Vector3 result = VectorZero(); + LuaPush_Vector3(L, result); + return 1; +} + +//---------------------------------------------------------------------------------- +// raylib [raymath] module functions - Matrix math +//---------------------------------------------------------------------------------- +int lua_MatrixDeterminant(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float result = MatrixDeterminant(arg1); + lua_pushnumber(L, result); + return 1; +} + +int lua_MatrixTrace(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float result = MatrixTrace(arg1); + lua_pushnumber(L, result); + return 1; +} + +int lua_MatrixTranspose(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixTranspose(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; +} + +int lua_MatrixInvert(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixInvert(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; +} + +int lua_MatrixNormalize(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixNormalize(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; +} + +int lua_MatrixIdentity(lua_State* L) +{ + Matrix result = MatrixIdentity(); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixAdd(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixAdd(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixSubstract(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixSubstract(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixTranslate(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Matrix result = MatrixTranslate(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixRotate(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Matrix result = MatrixRotate(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixRotateX(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateX(arg1); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixRotateY(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateY(arg1); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixRotateZ(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateZ(arg1); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixScale(lua_State* L) +{ + float arg1 = LuaGetArgument_float(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Matrix result = MatrixScale(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixMultiply(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixMultiply(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixFrustum(lua_State* L) +{ + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + double arg5 = LuaGetArgument_double(L, 5); + double arg6 = LuaGetArgument_double(L, 6); + Matrix result = MatrixFrustum(arg1, arg2, arg3, arg4, arg5, arg6); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixPerspective(lua_State* L) +{ + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + Matrix result = MatrixPerspective(arg1, arg2, arg3, arg4); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixOrtho(lua_State* L) +{ + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + double arg5 = LuaGetArgument_double(L, 5); + double arg6 = LuaGetArgument_double(L, 6); + Matrix result = MatrixOrtho(arg1, arg2, arg3, arg4, arg5, arg6); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_MatrixLookAt(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + Matrix result = MatrixLookAt(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; +} + +//---------------------------------------------------------------------------------- +// raylib [raymath] module functions - Quaternion math +//---------------------------------------------------------------------------------- +int lua_QuaternionLength(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + float result = QuaternionLength(arg1); + lua_pushnumber(L, result); + return 1; +} + +int lua_QuaternionNormalize(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + QuaternionNormalize(&arg1); + LuaPush_Quaternion(L, arg1); + return 1; +} + +int lua_QuaternionMultiply(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); + Quaternion result = QuaternionMultiply(arg1, arg2); + LuaPush_Quaternion(L, result); + return 1; +} + +int lua_QuaternionSlerp(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Quaternion result = QuaternionSlerp(arg1, arg2, arg3); + LuaPush_Quaternion(L, result); + return 1; +} + +int lua_QuaternionFromMatrix(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Quaternion result = QuaternionFromMatrix(arg1); + LuaPush_Quaternion(L, result); + return 1; +} + +int lua_QuaternionToMatrix(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Matrix result = QuaternionToMatrix(arg1); + LuaPush_Matrix(L, &result); + return 1; +} + +int lua_QuaternionFromAxisAngle(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Quaternion result = QuaternionFromAxisAngle(arg1, arg2); + LuaPush_Quaternion(L, result); + return 1; +} + +int lua_QuaternionToAxisAngle(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Vector3 arg2; + float arg3 = 0; + QuaternionToAxisAngle(arg1, &arg2, &arg3); + LuaPush_Vector3(L, arg2); + lua_pushnumber(L, arg3); + return 2; +} + +int lua_QuaternionTransform(lua_State* L) +{ + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + QuaternionTransform(&arg1, arg2); + LuaPush_Quaternion(L, arg1); + return 1; +} + + +//---------------------------------------------------------------------------------- +// Functions Registering +//---------------------------------------------------------------------------------- +#define REG(name) { #name, lua_##name }, + +// raylib Functions (and data types) list +static luaL_Reg raylib_functions[] = { + REG(Color) + REG(Vector2) + REG(Vector3) + REG(Rectangle) + REG(Ray) + REG(Camera) + // TODO: Additional structs + + // TODO: Review registered functions + REG(InitWindow) + REG(CloseWindow) + REG(WindowShouldClose) + REG(IsWindowMinimized) + REG(ToggleFullscreen) + + REG(GetScreenWidth) + REG(GetScreenHeight) + REG(ClearBackground) + REG(BeginDrawing) + REG(EndDrawing) + REG(Begin3dMode) + REG(End3dMode) + REG(GetMouseRay) +#if defined(PLATFORM_WEB) + REG(SetDrawingLoop) +#else + REG(SetTargetFPS) +#endif + REG(GetFPS) + REG(GetFrameTime) + REG(GetColor) + REG(GetHexValue) + REG(GetRandomValue) + REG(Fade) + REG(SetConfigFlags) + REG(ShowLogo) + REG(IsFileDropped) + //REG(*GetDroppedFiles) + REG(ClearDroppedFiles) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) + REG(IsKeyPressed) + REG(IsKeyDown) + REG(IsKeyReleased) + REG(IsKeyUp) + REG(GetKeyPressed) + REG(IsMouseButtonPressed) + REG(IsMouseButtonDown) + REG(IsMouseButtonReleased) + REG(IsMouseButtonUp) + REG(GetMouseX) + REG(GetMouseY) + REG(GetMousePosition) + REG(SetMousePosition) + REG(GetMouseWheelMove) + REG(ShowCursor) + REG(HideCursor) + REG(IsCursorHidden) +#endif + +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) + REG(IsGamepadAvailable) + + REG(IsGamepadButtonPressed) + REG(IsGamepadButtonDown) + REG(IsGamepadButtonReleased) + REG(IsGamepadButtonUp) +#endif + +#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) + REG(GetTouchX) + REG(GetTouchY) + REG(GetTouchPosition) +#if defined(PLATFORM_WEB) + REG(InitGesturesSystem) +#elif defined(PLATFORM_ANDROID) + //REG(InitGesturesSystem) +#endif + REG(UpdateGestures) + REG(IsGestureDetected) + REG(GetGestureType) + REG(SetGesturesEnabled) + REG(GetGestureDragIntensity) + REG(GetGestureDragAngle) + REG(GetGestureDragVector) + REG(GetGestureHoldDuration) + REG(GetGesturePinchDelta) + REG(GetGesturePinchAngle) +#endif + REG(SetCameraMode) + REG(UpdateCamera) + REG(UpdateCameraPlayer) + REG(SetCameraPosition) + REG(SetCameraTarget) + REG(SetCameraPanControl) + REG(SetCameraAltControl) + REG(SetCameraSmoothZoomControl) + REG(SetCameraMoveControls) + REG(SetCameraMouseSensitivity) + REG(DrawPixel) + REG(DrawPixelV) + REG(DrawLine) + REG(DrawLineV) + REG(DrawCircle) + REG(DrawCircleGradient) + REG(DrawCircleV) + REG(DrawCircleLines) + REG(DrawRectangle) + REG(DrawRectangleRec) + REG(DrawRectangleGradient) + REG(DrawRectangleV) + REG(DrawRectangleLines) + REG(DrawTriangle) + REG(DrawTriangleLines) + REG(DrawPoly) + REG(DrawPolyEx) + REG(DrawPolyExLines) + REG(CheckCollisionRecs) + REG(CheckCollisionCircles) + REG(CheckCollisionCircleRec) + REG(GetCollisionRec) + REG(CheckCollisionPointRec) + REG(CheckCollisionPointCircle) + REG(CheckCollisionPointTriangle) + REG(LoadImage) + REG(LoadImageEx) + REG(LoadImageRaw) + REG(LoadImageFromRES) + REG(LoadTexture) + REG(LoadTextureFromRES) + REG(LoadTextureFromImage) + REG(UnloadImage) + REG(UnloadTexture) + REG(GetImageData) + REG(GetTextureData) + REG(ImageToPOT) + REG(ImageFormat) + REG(GenTextureMipmaps) + REG(DrawTexture) + REG(DrawTextureV) + REG(DrawTextureEx) + REG(DrawTextureRec) + REG(DrawTexturePro) + REG(GetDefaultFont) + REG(LoadSpriteFont) + REG(UnloadSpriteFont) + REG(DrawText) + REG(DrawTextEx) + REG(MeasureText) + REG(MeasureTextEx) + REG(DrawFPS) + REG(DrawCube) + REG(DrawCubeV) + REG(DrawCubeWires) + REG(DrawCubeTexture) + REG(DrawSphere) + REG(DrawSphereEx) + REG(DrawSphereWires) + REG(DrawCylinder) + REG(DrawCylinderWires) + REG(DrawPlane) + REG(DrawRay) + REG(DrawGrid) + REG(DrawGizmo) + REG(LoadModel) + REG(LoadModelEx) + REG(LoadHeightmap) + REG(LoadCubicmap) + REG(UnloadModel) + REG(DrawModel) + REG(DrawModelEx) + REG(DrawModelWires) + REG(DrawBillboard) + REG(DrawBillboardRec) + REG(CheckCollisionSpheres) + REG(CheckCollisionBoxes) + REG(CheckCollisionBoxSphere) + REG(ResolveCollisionCubicmap) + REG(LoadShader) + REG(UnloadShader) + REG(GetShaderLocation) + REG(SetShaderValue) + REG(SetShaderValuei) + + REG(BeginBlendMode) + REG(EndBlendMode) + REG(InitAudioDevice) + REG(CloseAudioDevice) + REG(LoadSound) + REG(LoadSoundFromWave) + REG(LoadSoundFromRES) + REG(UnloadSound) + REG(PlaySound) + REG(PauseSound) + REG(StopSound) + REG(IsSoundPlaying) + REG(SetSoundVolume) + REG(SetSoundPitch) + REG(PlayMusicStream) + REG(UpdateMusicStream) + REG(StopMusicStream) + REG(PauseMusicStream) + REG(ResumeMusicStream) + REG(IsMusicPlaying) + REG(SetMusicVolume) + REG(GetMusicTimeLength) + REG(GetMusicTimePlayed) + + /// Math and util + REG(DecompressData) +#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) + REG(WriteBitmap) + REG(WritePNG) +#endif + REG(TraceLog) + REG(GetExtension) + REG(GetNextPOT) + REG(VectorAdd) + REG(VectorSubtract) + REG(VectorCrossProduct) + REG(VectorPerpendicular) + REG(VectorDotProduct) + REG(VectorLength) + REG(VectorScale) + REG(VectorNegate) + REG(VectorNormalize) + REG(VectorDistance) + REG(VectorLerp) + REG(VectorReflect) + REG(VectorTransform) + REG(VectorZero) + REG(MatrixDeterminant) + REG(MatrixTrace) + REG(MatrixTranspose) + REG(MatrixInvert) + REG(MatrixNormalize) + REG(MatrixIdentity) + REG(MatrixAdd) + REG(MatrixSubstract) + REG(MatrixTranslate) + REG(MatrixRotate) + REG(MatrixRotateX) + REG(MatrixRotateY) + REG(MatrixRotateZ) + REG(MatrixScale) + REG(MatrixMultiply) + REG(MatrixFrustum) + REG(MatrixPerspective) + REG(MatrixOrtho) + REG(MatrixLookAt) + REG(QuaternionLength) + REG(QuaternionNormalize) + REG(QuaternionMultiply) + REG(QuaternionSlerp) + REG(QuaternionFromMatrix) + REG(QuaternionToMatrix) + REG(QuaternionFromAxisAngle) + REG(QuaternionToAxisAngle) + REG(QuaternionTransform) + + {0,0} +}; + +// Register raylib functionality +static void LuaRegisterRayLib(const char *opt_table) +{ + if (opt_table) lua_createtable(L, 0, sizeof(raylib_functions)/sizeof(raylib_functions[0])); + else lua_pushglobaltable(L); + + luaL_setfuncs(L, raylib_functions, 0); +} + +//---------------------------------------------------------------------------------- +// raylib Lua API +//---------------------------------------------------------------------------------- + +// Initialize Lua system +RLUADEF void InitLuaDevice(void) +{ + mainLuaState = luaL_newstate(); + L = mainLuaState; + + LuaStartEnum(); + LuaSetEnum("FULLSCREEN_MODE", 1); + LuaSetEnum("SHOW_LOGO", 2); + LuaSetEnum("SHOW_MOUSE_CURSOR", 4); + LuaSetEnum("CENTERED_MODE", 8); + LuaSetEnum("MSAA_4X_HINT", 16); + LuaSetEnum("VSYNC_HINT", 32); + LuaEndEnum("FLAG"); + + LuaStartEnum(); + LuaSetEnum("SPACE", 32); + LuaSetEnum("ESCAPE", 256); + LuaSetEnum("ENTER", 257); + LuaSetEnum("BACKSPACE", 259); + LuaSetEnum("RIGHT", 262); + LuaSetEnum("LEFT", 263); + LuaSetEnum("DOWN", 264); + LuaSetEnum("UP", 265); + LuaSetEnum("F1", 290); + LuaSetEnum("F2", 291); + LuaSetEnum("F3", 292); + LuaSetEnum("F4", 293); + LuaSetEnum("F5", 294); + LuaSetEnum("F6", 295); + LuaSetEnum("F7", 296); + LuaSetEnum("F8", 297); + LuaSetEnum("F9", 298); + LuaSetEnum("F10", 299); + LuaSetEnum("LEFT_SHIFT", 340); + LuaSetEnum("LEFT_CONTROL", 341); + LuaSetEnum("LEFT_ALT", 342); + LuaSetEnum("RIGHT_SHIFT", 344); + LuaSetEnum("RIGHT_CONTROL", 345); + LuaSetEnum("RIGHT_ALT", 346); + LuaSetEnum("ZERO", 48); + LuaSetEnum("ONE", 49); + LuaSetEnum("TWO", 50); + LuaSetEnum("THREE", 51); + LuaSetEnum("FOUR", 52); + LuaSetEnum("FIVE", 53); + LuaSetEnum("SIX", 54); + LuaSetEnum("SEVEN", 55); + LuaSetEnum("EIGHT", 56); + LuaSetEnum("NINE", 57); + LuaSetEnum("A", 65); + LuaSetEnum("B", 66); + LuaSetEnum("C", 67); + LuaSetEnum("D", 68); + LuaSetEnum("E", 69); + LuaSetEnum("F", 70); + LuaSetEnum("G", 71); + LuaSetEnum("H", 72); + LuaSetEnum("I", 73); + LuaSetEnum("J", 74); + LuaSetEnum("K", 75); + LuaSetEnum("L", 76); + LuaSetEnum("M", 77); + LuaSetEnum("N", 78); + LuaSetEnum("O", 79); + LuaSetEnum("P", 80); + LuaSetEnum("Q", 81); + LuaSetEnum("R", 82); + LuaSetEnum("S", 83); + LuaSetEnum("T", 84); + LuaSetEnum("U", 85); + LuaSetEnum("V", 86); + LuaSetEnum("W", 87); + LuaSetEnum("X", 88); + LuaSetEnum("Y", 89); + LuaSetEnum("Z", 90); + LuaEndEnum("KEY"); + + LuaStartEnum(); + LuaSetEnum("LEFT_BUTTON", 0); + LuaSetEnum("RIGHT_BUTTON", 1); + LuaSetEnum("MIDDLE_BUTTON", 2); + LuaEndEnum("MOUSE"); + + LuaStartEnum(); + LuaSetEnum("PLAYER1", 0); + LuaSetEnum("PLAYER2", 1); + LuaSetEnum("PLAYER3", 2); + LuaSetEnum("PLAYER4", 3); + + LuaSetEnum("BUTTON_A", 2); + LuaSetEnum("BUTTON_B", 1); + LuaSetEnum("BUTTON_X", 3); + LuaSetEnum("BUTTON_Y", 4); + LuaSetEnum("BUTTON_R1", 7); + LuaSetEnum("BUTTON_R2", 5); + LuaSetEnum("BUTTON_L1", 6); + LuaSetEnum("BUTTON_L2", 8); + LuaSetEnum("BUTTON_SELECT", 9); + LuaSetEnum("BUTTON_START", 10); + LuaEndEnum("GAMEPAD"); + + LuaStartEnum(); + LuaSetEnum("PLAYER1", 0); + LuaSetEnum("PLAYER2", 1); + LuaSetEnum("PLAYER3", 2); + LuaSetEnum("PLAYER4", 3); + + LuaSetEnum("BUTTON_A", 2); + LuaSetEnum("BUTTON_B", 1); + LuaSetEnum("BUTTON_X", 3); + LuaSetEnum("BUTTON_Y", 4); + LuaSetEnum("BUTTON_R1", 7); + LuaSetEnum("BUTTON_R2", 5); + LuaSetEnum("BUTTON_L1", 6); + LuaSetEnum("BUTTON_L2", 8); + LuaSetEnum("BUTTON_SELECT", 9); + LuaSetEnum("BUTTON_START", 10); + LuaEndEnum("GAMEPAD"); + + // TODO: XBOX controller buttons enum + + lua_pushglobaltable(L); + LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY); + LuaSetEnumColor("GRAY", GRAY); + LuaSetEnumColor("DARKGRAY", DARKGRAY); + LuaSetEnumColor("YELLOW", YELLOW); + LuaSetEnumColor("GOLD", GOLD); + LuaSetEnumColor("ORANGE", ORANGE); + LuaSetEnumColor("PINK", PINK); + LuaSetEnumColor("RED", RED); + LuaSetEnumColor("MAROON", MAROON); + LuaSetEnumColor("GREEN", GREEN); + LuaSetEnumColor("LIME", LIME); + LuaSetEnumColor("DARKGREEN", DARKGREEN); + LuaSetEnumColor("SKYBLUE", SKYBLUE); + LuaSetEnumColor("BLUE", BLUE); + LuaSetEnumColor("DARKBLUE", DARKBLUE); + LuaSetEnumColor("PURPLE", PURPLE); + LuaSetEnumColor("VIOLET", VIOLET); + LuaSetEnumColor("DARKPURPLE", DARKPURPLE); + LuaSetEnumColor("BEIGE", BEIGE); + LuaSetEnumColor("BROWN", BROWN); + LuaSetEnumColor("DARKBROWN", DARKBROWN); + LuaSetEnumColor("WHITE", WHITE); + LuaSetEnumColor("BLACK", BLACK); + LuaSetEnumColor("BLANK", BLANK); + LuaSetEnumColor("MAGENTA", MAGENTA); + LuaSetEnumColor("RAYWHITE", RAYWHITE); + lua_pop(L, 1); + + LuaStartEnum(); + LuaSetEnum("UNCOMPRESSED_GRAYSCALE", UNCOMPRESSED_GRAYSCALE); + LuaSetEnum("UNCOMPRESSED_GRAY_ALPHA", UNCOMPRESSED_GRAY_ALPHA); + LuaSetEnum("UNCOMPRESSED_R5G6B5", UNCOMPRESSED_R5G6B5); + LuaSetEnum("UNCOMPRESSED_R8G8B8", UNCOMPRESSED_R8G8B8); + LuaSetEnum("UNCOMPRESSED_R5G5B5A1", UNCOMPRESSED_R5G5B5A1); + LuaSetEnum("UNCOMPRESSED_R4G4B4A4", UNCOMPRESSED_R4G4B4A4); + LuaSetEnum("UNCOMPRESSED_R8G8B8A8", UNCOMPRESSED_R8G8B8A8); + LuaSetEnum("COMPRESSED_DXT1_RGB", COMPRESSED_DXT1_RGB); + LuaSetEnum("COMPRESSED_DXT1_RGBA", COMPRESSED_DXT1_RGBA); + LuaSetEnum("COMPRESSED_DXT3_RGBA", COMPRESSED_DXT3_RGBA); + LuaSetEnum("COMPRESSED_DXT5_RGBA", COMPRESSED_DXT5_RGBA); + LuaSetEnum("COMPRESSED_ETC1_RGB", COMPRESSED_ETC1_RGB); + LuaSetEnum("COMPRESSED_ETC2_RGB", COMPRESSED_ETC2_RGB); + LuaSetEnum("COMPRESSED_ETC2_EAC_RGBA", COMPRESSED_ETC2_EAC_RGBA); + LuaSetEnum("COMPRESSED_PVRT_RGB", COMPRESSED_PVRT_RGB); + LuaSetEnum("COMPRESSED_PVRT_RGBA", COMPRESSED_PVRT_RGBA); + LuaSetEnum("COMPRESSED_ASTC_4x4_RGBA", COMPRESSED_ASTC_4x4_RGBA); + LuaSetEnum("COMPRESSED_ASTC_8x8_RGBA", COMPRESSED_ASTC_8x8_RGBA); + LuaEndEnum("TextureFormat"); + + LuaStartEnum(); + LuaSetEnum("ALPHA", BLEND_ALPHA); + LuaSetEnum("ADDITIVE", BLEND_ADDITIVE); + LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED); + LuaEndEnum("BlendMode"); + + LuaStartEnum(); + LuaSetEnum("NONE", GESTURE_NONE); + LuaSetEnum("TAP", GESTURE_TAP); + LuaSetEnum("DOUBLETAP", GESTURE_DOUBLETAP); + LuaSetEnum("HOLD", GESTURE_HOLD); + LuaSetEnum("DRAG", GESTURE_DRAG); + LuaSetEnum("SWIPE_RIGHT", GESTURE_SWIPE_RIGHT); + LuaSetEnum("SWIPE_LEFT", GESTURE_SWIPE_LEFT); + LuaSetEnum("SWIPE_UP", GESTURE_SWIPE_UP); + LuaSetEnum("SWIPE_DOWN", GESTURE_SWIPE_DOWN); + LuaSetEnum("PINCH_IN", GESTURE_PINCH_IN); + LuaSetEnum("PINCH_OUT", GESTURE_PINCH_OUT); + LuaEndEnum("Gestures"); + + LuaStartEnum(); + LuaSetEnum("CUSTOM", CAMERA_CUSTOM); + LuaSetEnum("FREE", CAMERA_FREE); + LuaSetEnum("ORBITAL", CAMERA_ORBITAL); + LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON); + LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON); + LuaEndEnum("CameraMode"); + + LuaStartEnum(); + LuaSetEnum("HMD_DEFAULT_DEVICE", HMD_DEFAULT_DEVICE); + LuaSetEnum("HMD_OCULUS_RIFT_DK2", HMD_OCULUS_RIFT_DK2); + LuaSetEnum("HMD_OCULUS_RIFT_CV1", HMD_OCULUS_RIFT_CV1); + LuaSetEnum("HMD_VALVE_HTC_VIVE", HMD_VALVE_HTC_VIVE); + LuaSetEnum("HMD_SAMSUNG_GEAR_VR", HMD_SAMSUNG_GEAR_VR); + LuaSetEnum("HMD_GOOGLE_CARDBOARD", HMD_GOOGLE_CARDBOARD); + LuaSetEnum("HMD_SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR); + LuaSetEnum("HMD_RAZER_OSVR", HMD_RAZER_OSVR); + LuaSetEnum("HMD_FOVE_VR", HMD_FOVE_VR); + LuaEndEnum("VrDevice"); + + lua_pushglobaltable(L); + LuaSetEnum("INFO", INFO); + LuaSetEnum("ERROR", ERROR); + LuaSetEnum("WARNING", WARNING); + LuaSetEnum("DEBUG", DEBUG); + LuaSetEnum("OTHER", OTHER); + lua_pop(L, 1); + + lua_pushboolean(L, true); +#if defined(PLATFORM_DESKTOP) + lua_setglobal(L, "PLATFORM_DESKTOP"); +#elif defined(PLATFORM_ANDROID) + lua_setglobal(L, "PLATFORM_ANDROID"); +#elif defined(PLATFORM_RPI) + lua_setglobal(L, "PLATFORM_RPI"); +#elif defined(PLATFORM_WEB) + lua_setglobal(L, "PLATFORM_WEB"); +#endif + + luaL_openlibs(L); + LuaBuildOpaqueMetatables(); + + LuaRegisterRayLib(0); +} + +// De-initialize Lua system +RLUADEF void CloseLuaDevice(void) +{ + if (mainLuaState) + { + lua_close(mainLuaState); + mainLuaState = 0; + L = 0; + } +} + +// Execute raylib Lua code +RLUADEF void ExecuteLuaCode(const char *code) +{ + if (!mainLuaState) + { + TraceLog(WARNING, "Lua device not initialized"); + return; + } + + int result = luaL_dostring(L, code); + + switch (result) + { + case LUA_OK: break; + case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1)); break; + case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1)); break; + default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1)); break; + } +} + +// Execute raylib Lua script +RLUADEF void ExecuteLuaFile(const char *filename) +{ + if (!mainLuaState) + { + TraceLog(WARNING, "Lua device not initialized"); + return; + } + + int result = luaL_dofile(L, filename); + + switch (result) + { + case LUA_OK: break; + case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1)); + case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1)); + default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1)); + } +} + +#endif // RLUA_IMPLEMENTATION -- cgit v1.2.3 From 5c30e079f4da0c042248f48e5cc39b48e948ab10 Mon Sep 17 00:00:00 2001 From: raysan5 Date: Wed, 3 Aug 2016 21:39:22 +0200 Subject: [rlua] new module: raylib Lua binding --- src/rlua.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index 6a909c43..d157002d 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -3628,4 +3628,4 @@ RLUADEF void ExecuteLuaFile(const char *filename) } } -#endif // RLUA_IMPLEMENTATION +#endif // RLUA_IMPLEMENTATION \ No newline at end of file -- cgit v1.2.3 From 70ec517fdaa927ff3dacb60ff0090a9312a22dca Mon Sep 17 00:00:00 2001 From: raysan5 Date: Wed, 3 Aug 2016 23:15:44 +0200 Subject: Updated some functions --- src/rlua.h | 179 ++++++++++++++++++++++++++++++++++++------------------------- 1 file changed, 105 insertions(+), 74 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index d157002d..df6eef1c 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -263,7 +263,7 @@ static int LuaIndexTexture2D(lua_State* L) return 1; } -// TODO: RenderTexture2D? +// TODO: Build opaque metatable for RenderTexture2D? static int LuaIndexSpriteFont(lua_State* L) { @@ -292,7 +292,7 @@ static void LuaBuildOpaqueMetatables(void) lua_setfield(L, -2, "__index"); lua_pop(L, 1); - // TODO? + // TODO: Build opaque metatable for RenderTexture2D? /* luaL_newmetatable(L, "RenderTexture2D"); lua_pushcfunction(L, &LuaIndexRenderTexture2D); @@ -403,13 +403,9 @@ static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) return result; } -// TODO: -//BoundingBox -//LightData, *Light -//MusicData *Music; -//AudioStream - -// TODO: Review Mesh, Shader +// TODO: LightData, *Light +// TODO: MusicData *Music; +// TODO: AudioStream static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) { @@ -699,7 +695,7 @@ int lua_InitWindow(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); int arg2 = LuaGetArgument_int(L, 2); - const char* arg3 = LuaGetArgument_string(L, 3); + const char * arg3 = LuaGetArgument_string(L, 3); InitWindow(arg1, arg2, arg3); return 0; } @@ -763,11 +759,17 @@ int lua_IsCursorHidden(lua_State* L) return 1; } -// TODO: -/* -void EnableCursor(void); // Enables cursor -void DisableCursor(void); // Disables cursor -*/ +int lua_EnableCursor(lua_State* L) +{ + EnableCursor(); + return 0; +} + +int lua_DisableCursor(lua_State* L) +{ + DisableCursor(); + return 0; +} int lua_ClearBackground(lua_State* L) { @@ -788,9 +790,18 @@ int lua_EndDrawing(lua_State* L) return 0; } -// TODO: -//void Begin2dMode(Camera2D camera); // Initialize 2D mode with custom camera -//void End2dMode(void); // Ends 2D mode custom camera usage +int lua_Begin2dMode(lua_State* L) +{ + Camera2D arg1 = LuaGetArgument_Camera2D(L, 1); + Begin2dMode(arg1); + return 0; +} + +int lua_End2dMode(lua_State* L) +{ + End2dMode(); + return 0; +} int lua_Begin3dMode(lua_State* L) { @@ -805,9 +816,18 @@ int lua_End3dMode(lua_State* L) return 0; } -// TODO: -//void BeginTextureMode(RenderTexture2D target); // Initializes render texture for drawing -//void EndTextureMode(void); // Ends drawing to render texture +int lua_BeginTextureMode(lua_State* L) +{ + RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); + BeginTextureMode(arg1); + return 0; +} + +int lua_EndTextureMode(lua_State* L) +{ + EndTextureMode(); + return 0; +} int lua_GetMouseRay(lua_State* L) { @@ -818,9 +838,22 @@ int lua_GetMouseRay(lua_State* L) return 1; } -// TODO: -//Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Returns the screen space position from a 3d world space position -//Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix) +int lua_GetWorldToScreen(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Camera arg2 = LuaGetArgument_Camera(L, 2); + Vector2 result = GetWorldToScreen(arg1, arg2); + LuaPush_Vector2(L, result); + return 1; +} + +int lua_GetCameraMatrix(lua_State* L) +{ + Camera arg1 = LuaGetArgument_Camera(L, 1); + Matrix result = GetCameraMatrix(arg1); + LuaPush_Matrix(L, &result); + return 1; +} #if defined(PLATFORM_WEB) @@ -1014,17 +1047,14 @@ int lua_IsGamepadAvailable(lua_State* L) return 1; } -// TODO: Review -// float GetGamepadAxisMovement(int gamepad, int axis); // Return axis movement value for a gamepad axis -/* -int lua_GetGamepadMovement(lua_State* L) +int GetGamepadAxisMovement(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); - Vector2 result = GetGamepadMovement(arg1); - LuaPush_Vector2(L, result); + int arg2 = LuaGetArgument_int(L, 2); + float result = GetGamepadAxisMovement(arg1, arg2); + LuaPush_float(L, result); return 1; } -*/ int lua_IsGamepadButtonPressed(lua_State* L) { @@ -1152,14 +1182,32 @@ int lua_GetTouchPosition(lua_State* L) return 1; } -// TODO: -/* + #if defined(PLATFORM_ANDROID) -bool IsButtonPressed(int button); // Detect if an android physic button has been pressed -bool IsButtonDown(int button); // Detect if an android physic button is being pressed -bool IsButtonReleased(int button); // Detect if an android physic button has been released +int lua_IsButtonPressed(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonPressed(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsButtonDown(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonDown(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_IsButtonReleased(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonReleased(arg1); + lua_pushboolean(L, result); + return 1; +} #endif -*/ //------------------------------------------------------------------------------------ // raylib [gestures] module functions - Gestures and Touch Handling @@ -1179,8 +1227,7 @@ int lua_IsGestureDetected(lua_State* L) return 1; } -// TODO: -///void ProcessGestureEvent(GestureEvent event); // Process gesture event and translate it into gestures +// TODO: void ProcessGestureEvent(GestureEvent event); int lua_UpdateGestures(lua_State* L) { @@ -1655,10 +1702,9 @@ int lua_LoadTexture(lua_State* L) return 1; } -// TODO: Texture2D LoadTextureEx(void *data, int width, int height, int textureFormat); int lua_LoadTextureEx(lua_State* L) { - void * arg1 = LuaGetArgument_string(L, 1); // TODO: How to get a void * ? + void * arg1 = LuaGetArgument_string(L, 1); // NOTE: getting argument as string int arg2 = LuaGetArgument_int(L, 2); int arg3 = LuaGetArgument_int(L, 3); int arg4 = LuaGetArgument_int(L, 4); @@ -1782,7 +1828,13 @@ int lua_GenTextureMipmaps(lua_State* L) return 0; } -// TODO: void UpdateTexture(Texture2D texture, void *pixels); // Update GPU texture with new data +int lua_UpdateTexture(lua_State* L) +{ + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + void * arg2 = LuaGetArgument_string(L, 2); // NOTE: Getting (void *) as string + UpdateTexture(arg1, arg2); + return 0; +} int lua_DrawTexture(lua_State* L) { @@ -1875,7 +1927,7 @@ int lua_DrawText(lua_State* L) int lua_DrawTextEx(lua_State* L) { SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); - const char* arg2 = LuaGetArgument_string(L, 2); + const char * arg2 = LuaGetArgument_string(L, 2); Vector2 arg3 = LuaGetArgument_Vector2(L, 3); int arg4 = LuaGetArgument_int(L, 4); int arg5 = LuaGetArgument_int(L, 5); @@ -1912,11 +1964,8 @@ int lua_DrawFPS(lua_State* L) return 0; } -// TODO: -/* -const char *FormatText(const char *text, ...); // Formatting of text with variables to 'embed' -const char *SubText(const char *text, int position, int length); // Get a piece of a text string -*/ +// TODO: const char *FormatText(const char *text, ...); +// TODO: const char *SubText(const char *text, int position, int length); int lua_DrawCube(lua_State* L) { @@ -2108,7 +2157,7 @@ int lua_UnloadModel(lua_State* L) return 0; } -// TODO: GenMesh*() +// TODO: GenMesh*() functionality (not ready yet on raylib 1.6) int lua_LoadMaterial(lua_State* L) { @@ -2211,7 +2260,7 @@ int lua_CalculateBoundingBox(lua_State* L) Mesh arg1 = LuaGetArgument_Mesh(L, 1); BoundingBox result = CalculateBoundingBox(arg1); LuaPush_BoundingBox(L, result); - return 0; + return 1; } int lua_CheckCollisionSpheres(lua_State* L) @@ -2269,8 +2318,8 @@ int lua_ResolveCollisionCubicmap(lua_State* L) //------------------------------------------------------------------------------------ int lua_LoadShader(lua_State* L) { - char * arg1 = (char*)LuaGetArgument_string(L, 1); - char * arg2 = (char*)LuaGetArgument_string(L, 2); + const char * arg1 = LuaGetArgument_string(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); Shader result = LoadShader(arg1, arg2); LuaPush_Shader(L, result); return 1; @@ -2401,7 +2450,7 @@ void ToggleVrMode(void); // Enable/Disable VR experience (dev */ //------------------------------------------------------------------------------------ -// raylib [audio] module functions +// raylib [audio] module functions - Audio Loading and Playing //------------------------------------------------------------------------------------ int lua_InitAudioDevice(lua_State* L) { @@ -2419,7 +2468,7 @@ int lua_IsAudioDeviceReady(lua_State* L) { bool result = IsAudioDeviceReady(); lua_pushboolean(L, result); - return 0; + return 1; } int lua_LoadSound(lua_State* L) @@ -2511,7 +2560,7 @@ int lua_LoadMusicStream(lua_State* L) const char * arg1 = LuaGetArgument_string(L, 1); Music result = LoadMusicStream((char *)arg1); LuaPush_Music(L, result); - return 0; + return 1; } int lua_UnloadMusicStream(lua_State* L) @@ -3442,24 +3491,6 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("BUTTON_START", 10); LuaEndEnum("GAMEPAD"); - LuaStartEnum(); - LuaSetEnum("PLAYER1", 0); - LuaSetEnum("PLAYER2", 1); - LuaSetEnum("PLAYER3", 2); - LuaSetEnum("PLAYER4", 3); - - LuaSetEnum("BUTTON_A", 2); - LuaSetEnum("BUTTON_B", 1); - LuaSetEnum("BUTTON_X", 3); - LuaSetEnum("BUTTON_Y", 4); - LuaSetEnum("BUTTON_R1", 7); - LuaSetEnum("BUTTON_R2", 5); - LuaSetEnum("BUTTON_L1", 6); - LuaSetEnum("BUTTON_L2", 8); - LuaSetEnum("BUTTON_SELECT", 9); - LuaSetEnum("BUTTON_START", 10); - LuaEndEnum("GAMEPAD"); - // TODO: XBOX controller buttons enum lua_pushglobaltable(L); @@ -3628,4 +3659,4 @@ RLUADEF void ExecuteLuaFile(const char *filename) } } -#endif // RLUA_IMPLEMENTATION \ No newline at end of file +#endif // RLUA_IMPLEMENTATION -- cgit v1.2.3 From 055d50134567474224f050dc014f6158d496026e Mon Sep 17 00:00:00 2001 From: raysan5 Date: Wed, 3 Aug 2016 23:25:39 +0200 Subject: Corrected bug --- src/rlua.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index df6eef1c..ae899945 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -1047,12 +1047,12 @@ int lua_IsGamepadAvailable(lua_State* L) return 1; } -int GetGamepadAxisMovement(lua_State* L) +int lua_GetGamepadAxisMovement(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); int arg2 = LuaGetArgument_int(L, 2); float result = GetGamepadAxisMovement(arg1, arg2); - LuaPush_float(L, result); + lua_pushnumber(L, result); return 1; } @@ -2318,8 +2318,8 @@ int lua_ResolveCollisionCubicmap(lua_State* L) //------------------------------------------------------------------------------------ int lua_LoadShader(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - const char * arg2 = LuaGetArgument_string(L, 2); + char * arg1 = (char *)LuaGetArgument_string(L, 1); + char * arg2 = (char *)LuaGetArgument_string(L, 2); Shader result = LoadShader(arg1, arg2); LuaPush_Shader(L, result); return 1; -- cgit v1.2.3 From 80789e6140fd86a8063ff13e4e8db9dccdff804d Mon Sep 17 00:00:00 2001 From: raysan5 Date: Thu, 4 Aug 2016 13:40:53 +0200 Subject: Updated Lua binding --- src/rlua.h | 692 ++++++++++++++++++++++++++++++++++++++++++++++++++----------- 1 file changed, 574 insertions(+), 118 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index ae899945..76a79c7c 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -15,7 +15,7 @@ * local x2 = rec.x + rec.width * * The following types: -* Image, Texture2D, SpriteFont +* Image, Texture2D, RenderTexture2D, SpriteFont * are immutable, and you can only read their non-pointer arguments (e.g. sprfnt.size). * * All other object types are opaque, that is, you cannot access or @@ -126,9 +126,11 @@ RLUADEF void CloseLuaDevice(void); // De-initialize Lua system #define LuaPush_SpriteFont(L, sf) LuaPushOpaqueTypeWithMetatable(L, sf, SpriteFont) #define LuaPush_Mesh(L, vd) LuaPushOpaqueType(L, vd) #define LuaPush_Shader(L, s) LuaPushOpaqueType(L, s) +#define LuaPush_Light(L, light) LuaPushOpaqueType(L, light) #define LuaPush_Sound(L, snd) LuaPushOpaqueType(L, snd) #define LuaPush_Wave(L, wav) LuaPushOpaqueType(L, wav) #define LuaPush_Music(L, mus) LuaPushOpaqueType(L, mus) +#define LuaPush_AudioStream(L, aud) LuaPushOpaqueType(L, aud) #define LuaGetArgument_string luaL_checkstring #define LuaGetArgument_int (int)luaL_checkinteger @@ -142,9 +144,11 @@ RLUADEF void CloseLuaDevice(void); // De-initialize Lua system #define LuaGetArgument_SpriteFont(L, sf) *(SpriteFont*)LuaGetArgumentOpaqueTypeWithMetatable(L, sf, "SpriteFont") #define LuaGetArgument_Mesh(L, vd) *(Mesh*)LuaGetArgumentOpaqueType(L, vd) #define LuaGetArgument_Shader(L, s) *(Shader*)LuaGetArgumentOpaqueType(L, s) +#define LuaGetArgument_Light(L, light) *(Light*)LuaGetArgumentOpaqueType(L, light) #define LuaGetArgument_Sound(L, snd) *(Sound*)LuaGetArgumentOpaqueType(L, snd) #define LuaGetArgument_Wave(L, wav) *(Wave*)LuaGetArgumentOpaqueType(L, wav) #define LuaGetArgument_Music(L, mus) *(Music*)LuaGetArgumentOpaqueType(L, mus) +#define LuaGetArgument_AudioStream(L, aud) *(AudioStream*)LuaGetArgumentOpaqueType(L, aud) #define LuaPushOpaqueType(L, str) LuaPushOpaque(L, &str, sizeof(str)) #define LuaPushOpaqueTypeWithMetatable(L, str, meta) LuaPushOpaqueWithMetatable(L, &str, sizeof(str), #meta) @@ -263,7 +267,18 @@ static int LuaIndexTexture2D(lua_State* L) return 1; } -// TODO: Build opaque metatable for RenderTexture2D? +static int LuaIndexRenderTexture2D(lua_State* L) +{ + RenderTexture2D img = LuaGetArgument_RenderTexture2D(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "texture")) + LuaPush_Texture2D(L, img.texture); + else if (!strcmp(key, "depth")) + LuaPush_Texture2D(L, img.depth); + else + return 0; + return 1; +} static int LuaIndexSpriteFont(lua_State* L) { @@ -292,13 +307,11 @@ static void LuaBuildOpaqueMetatables(void) lua_setfield(L, -2, "__index"); lua_pop(L, 1); - // TODO: Build opaque metatable for RenderTexture2D? - /* luaL_newmetatable(L, "RenderTexture2D"); lua_pushcfunction(L, &LuaIndexRenderTexture2D); lua_setfield(L, -2, "__index"); lua_pop(L, 1); - */ + luaL_newmetatable(L, "SpriteFont"); lua_pushcfunction(L, &LuaIndexSpriteFont); lua_setfield(L, -2, "__index"); @@ -403,10 +416,6 @@ static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) return result; } -// TODO: LightData, *Light -// TODO: MusicData *Music; -// TODO: AudioStream - static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) { BoundingBox result; @@ -649,6 +658,23 @@ static int lua_Vector3(lua_State* L) return 1; } +static int lua_Quaternion(lua_State* L) +{ + LuaPush_Quaternion(L, (Quaternion) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4) }); + return 1; +} + +/* +static int lua_Matrix(lua_State* L) +{ + LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4), + (float)luaL_checknumber(L, 5), (float)luaL_checknumber(L, 6), (float)luaL_checknumber(L, 7), (float)luaL_checknumber(L, 8), + (float)luaL_checknumber(L, 9), (float)luaL_checknumber(L, 10), (float)luaL_checknumber(L, 11), (float)luaL_checknumber(L, 12), + (float)luaL_checknumber(L, 13), (float)luaL_checknumber(L, 14), (float)luaL_checknumber(L, 15), (float)luaL_checknumber(L, 16) }); + return 1; +} +*/ + static int lua_Rectangle(lua_State* L) { LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) }); @@ -663,6 +689,14 @@ static int lua_Ray(lua_State* L) return 1; } +static int lua_BoundingBox(lua_State* L) +{ + Vector3 min = LuaGetArgument_Vector3(L, 1); + Vector3 max = LuaGetArgument_Vector3(L, 2); + LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } }); + return 1; +} + static int lua_Camera(lua_State* L) { Vector3 pos = LuaGetArgument_Vector3(L, 1); @@ -683,6 +717,22 @@ static int lua_Camera2D(lua_State* L) return 1; } +/* +// NOTE: does it make sense to have this constructor? Probably not... +static int lua_Material(lua_State* L) +{ + Shader sdr = LuaGetArgument_Shader(L, 1); + Texture2D td = LuaGetArgument_Texture2D(L, 2); + Texture2D tn = LuaGetArgument_Texture2D(L, 3); + Texture2D ts = LuaGetArgument_Texture2D(L, 4); + Color cd = LuaGetArgument_Color(L, 5); + Color ca = LuaGetArgument_Color(L, 6); + Color cs = LuaGetArgument_Color(L, 7); + float gloss = LuaGetArgument_float(L, 8); + LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss }); + return 1; +} +*/ /************************************************************************************* * raylib Lua Functions Bindings @@ -914,12 +964,47 @@ int lua_GetHexValue(lua_State* L) return 1; } -// TODO: -/* -float *ColorToFloat(Color color); // Converts Color to float array and normalizes -float *VectorToFloat(Vector3 vec); // Converts Vector3 to float array -float *MatrixToFloat(Matrix mat); // Converts Matrix to float array -*/ +int lua_ColorToFloat(lua_State* L) +{ + Color arg1 = LuaGetArgument_Color(L, 1); + float * result = ColorToFloat(arg1); + lua_createtable(L, 4, 0); + for (int i = 0; i < 4; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; +} + +int lua_VectorToFloat(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float * result = VectorToFloat(arg1); + lua_createtable(L, 3, 0); + for (int i = 0; i < 3; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; +} + +int lua_MatrixToFloat(lua_State* L) +{ + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float * result = MatrixToFloat(arg1); + lua_createtable(L, 16, 0); + for (int i = 0; i < 16; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; +} int lua_GetRandomValue(lua_State* L) { @@ -1227,8 +1312,6 @@ int lua_IsGestureDetected(lua_State* L) return 1; } -// TODO: void ProcessGestureEvent(GestureEvent event); - int lua_UpdateGestures(lua_State* L) { UpdateGestures(); @@ -1704,7 +1787,7 @@ int lua_LoadTexture(lua_State* L) int lua_LoadTextureEx(lua_State* L) { - void * arg1 = LuaGetArgument_string(L, 1); // NOTE: getting argument as string + void * arg1 = (char *)LuaGetArgument_string(L, 1); // NOTE: getting argument as string int arg2 = LuaGetArgument_int(L, 2); int arg3 = LuaGetArgument_int(L, 3); int arg4 = LuaGetArgument_int(L, 4); @@ -1800,26 +1883,172 @@ int lua_ImageFormat(lua_State* L) return 1; } -// TODO: -/* -void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) -Image ImageCopy(Image image); // Create an image duplicate (useful for transformations) -void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle -void ImageResize(Image *image, int newWidth, int newHeight); // Resize and image (bilinear filtering) -void ImageResizeNN(Image *image,int newWidth,int newHeight); // Resize and image (Nearest-Neighbor scaling algorithm) -Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font) -Image ImageTextEx(SpriteFont font, const char *text, int fontSize, int spacing, Color tint); // Create an image from text (custom sprite font) -void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec); // Draw a source image within a destination image -void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color); // Draw text (default font) within an image (destination) -void ImageDrawTextEx(Image *dst, Vector2 position, SpriteFont font, const char *text, int fontSize, int spacing, Color color); // Draw text (custom sprite font) within an image (destination) -void ImageFlipVertical(Image *image); // Flip image vertically -void ImageFlipHorizontal(Image *image); // Flip image horizontally -void ImageColorTint(Image *image, Color color); // Modify image color: tint -void ImageColorInvert(Image *image); // Modify image color: invert -void ImageColorGrayscale(Image *image); // Modify image color: grayscale -void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100) -void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255) -*/ +int lua_ImageDither(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + ImageDither(&arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageCopy(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Image result = ImageCopy(arg1); + LuaPush_Image(L, result); + return 1; +} + +int lua_ImageCrop(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + ImageCrop(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageResize(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + ImageResize(&arg1, arg2, arg3); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageResizeNN(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + ImageResizeNN(&arg1, arg2, arg3); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageText(lua_State* L) +{ + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + Image result = ImageText(arg1, arg2, arg3); + LuaPush_Image(L, result); + return 1; +} + +int lua_ImageTextEx(lua_State* L) +{ + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Image result = ImageTextEx(arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, result); + return 1; +} + +int lua_ImageDraw(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Image arg2 = LuaGetArgument_Image(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Rectangle arg4 = LuaGetArgument_Rectangle(L, 4); + ImageDraw(&arg1, arg2, arg3, arg4); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageDrawText(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + const char * arg3 = LuaGetArgument_string(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + ImageDrawText(&arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageDrawTextEx(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3); + const char * arg4 = LuaGetArgument_string(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + int arg6 = LuaGetArgument_int(L, 6); + Color arg7 = LuaGetArgument_Color(L, 7); + ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageFlipVertical(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + ImageFlipVertical(&arg1); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageFlipHorizontal(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + ImageFlipHorizontal(&arg1); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageColorTint(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + ImageColorTint(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageColorInvert(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + ImageColorInvert(&arg1); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageColorGrayscale(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + ImageColorGrayscale(&arg1); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageColorContrast(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + ImageColorContrast(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} + +int lua_ImageColorBrightness(lua_State* L) +{ + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + ImageColorBrightness(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; +} int lua_GenTextureMipmaps(lua_State* L) { @@ -1831,7 +2060,7 @@ int lua_GenTextureMipmaps(lua_State* L) int lua_UpdateTexture(lua_State* L) { Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - void * arg2 = LuaGetArgument_string(L, 2); // NOTE: Getting (void *) as string + void * arg2 = (char *)LuaGetArgument_string(L, 2); // NOTE: Getting (void *) as string? UpdateTexture(arg1, arg2); return 0; } @@ -2097,12 +2326,27 @@ int lua_DrawGizmo(lua_State* L) return 0; } -// TODO: -/* -void DrawLight(Light light); // Draw light in 3D world -void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space -void Draw3DCircle(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color); // Draw a circle in 3D world space -*/ +// TODO: DrawLight(Light light); + +int lua_Draw3DLine(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + Draw3DLine(arg1, arg2, arg3); + return 0; +} + +int lua_Draw3DCircle(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Draw3DCircle(arg1, arg2, arg3, arg4, arg5); + return 0; +} //------------------------------------------------------------------------------------ // raylib [models] module functions @@ -2287,19 +2531,42 @@ int lua_CheckCollisionBoxSphere(lua_State* L) { BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 4); + float arg3 = LuaGetArgument_float(L, 3); bool result = CheckCollisionBoxSphere(arg1, arg2, arg3); lua_pushboolean(L, result); return 1; } -// TODO: -/* -bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius); // Detect collision between ray and sphere -bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint); // Detect collision between ray and sphere with extended parameters and collision point detection -bool CheckCollisionRayBox(Ray ray, BoundingBox box); // Detect collision between ray and box -Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *playerPosition, float radius); // Detect collision of player radius with cubicmap -*/ +int lua_CheckCollisionRaySphere(lua_State* L) +{ + Ray arg1 = LuaGetArgument_Ray(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + bool result = CheckCollisionRaySphere(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; +} + +int lua_CheckCollisionRaySphereEx(lua_State* L) +{ + Ray arg1 = LuaGetArgument_Ray(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + bool result = CheckCollisionRaySphereEx(arg1, arg2, arg3, &arg4); + lua_pushboolean(L, result); + LuaPush_Vector3(L, arg4); + return 2; +} + +int lua_CheckCollisionRayBox(lua_State* L) +{ + Ray arg1 = LuaGetArgument_Ray(L, 1); + BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); + bool result = CheckCollisionRayBox(arg1, arg2); + lua_pushboolean(L, result); + return 1; +} int lua_ResolveCollisionCubicmap(lua_State* L) { @@ -2431,23 +2698,55 @@ int lua_EndBlendMode(lua_State* L) return 0; } -// TODO: -//Light CreateLight(int type, Vector3 position, Color diffuse); // Create a new light, initialize it and add to pool -//void DestroyLight(Light light); // Destroy a light and take it out of the list +// TODO: Light CreateLight(int type, Vector3 position, Color diffuse); +// TODO: void DestroyLight(Light light); -// TODO: -/* //------------------------------------------------------------------------------------ // raylib [rlgl] module functions - VR experience //------------------------------------------------------------------------------------ -void InitVrDevice(int vdDevice); // Init VR device -void CloseVrDevice(void); // Close VR device -void UpdateVrTracking(void); // Update VR tracking (position and orientation) -void BeginVrDrawing(void); // Begin VR drawing configuration -void EndVrDrawing(void); // End VR drawing process (and desktop mirror) -bool IsVrDeviceReady(void); // Detect if VR device (or simulator) is ready -void ToggleVrMode(void); // Enable/Disable VR experience (device or simulator) -*/ +int lua_InitVrDevice(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + InitVrDevice(arg1); + return 0; +} + +int lua_CloseVrDevice(lua_State* L) +{ + CloseVrDevice(); + return 0; +} + +int lua_UpdateVrTracking(lua_State* L) +{ + UpdateVrTracking(); + return 0; +} + +int lua_BeginVrDrawing(lua_State* L) +{ + BeginVrDrawing(); + return 0; +} + +int lua_EndVrDrawing(lua_State* L) +{ + EndVrDrawing(); + return 0; +} + +int lua_IsVrDeviceReady(lua_State* L) +{ + bool result = IsVrDeviceReady(); + lua_pushboolean(L, result); + return 1; +} + +int lua_ToggleVrMode(lua_State* L) +{ + ToggleVrMode(); + return 0; +} //------------------------------------------------------------------------------------ // raylib [audio] module functions - Audio Loading and Playing @@ -2570,20 +2869,21 @@ int lua_UnloadMusicStream(lua_State* L) return 0; } -int lua_PlayMusicStream(lua_State* L) +int lua_UpdateMusicStream(lua_State* L) { - Music arg1 = LuaGetArgument_Music(L, 1); - PlayMusicStream(arg1); + Music arg1 = LuaGetArgument_Music(L, 1); + UpdateMusicStream(arg1); return 0; } -int lua_UpdateMusicStream(lua_State* L) +int lua_PlayMusicStream(lua_State* L) { - Music arg1 = LuaGetArgument_Music(L, 1); - UpdateMusicStream(arg1); + Music arg1 = LuaGetArgument_Music(L, 1); + PlayMusicStream(arg1); return 0; } + int lua_StopMusicStream(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); @@ -2621,6 +2921,14 @@ int lua_SetMusicVolume(lua_State* L) return 0; } +int lua_SetMusicPitch(lua_State* L) +{ + Music arg1 = LuaGetArgument_Music(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetMusicPitch(arg1, arg2); + return 0; +} + int lua_GetMusicTimeLength(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); @@ -2637,19 +2945,68 @@ int lua_GetMusicTimePlayed(lua_State* L) return 1; } -// TODO: -/* -AudioStream InitAudioStream(unsigned int sampleRate, - unsigned int sampleSize, - unsigned int channels); // Init audio stream (to stream audio pcm data) -void UpdateAudioStream(AudioStream stream, void *data, int numSamples); // Update audio stream buffers with data -void CloseAudioStream(AudioStream stream); // Close audio stream and free memory -bool IsAudioBufferProcessed(AudioStream stream); // Check if any audio stream buffers requires refill -void PlayAudioStream(AudioStream stream); // Play audio stream -void PauseAudioStream(AudioStream stream); // Pause audio stream -void ResumeAudioStream(AudioStream stream); // Resume audio stream -void StopAudioStream(AudioStream stream); // Stop audio stream -*/ +int lua_InitAudioStream(lua_State* L) +{ + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + AudioStream result = InitAudioStream(arg1, arg2, arg3); + LuaPush_AudioStream(L, result); + return 1; +} + +int lua_CloseAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + CloseAudioStream(arg1); + return 0; +} + +int lua_UpdateAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + void * arg2 = (char *)LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + UpdateAudioStream(arg1, arg2, arg3); + return 0; +} + +int lua_IsAudioBufferProcessed(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + bool result = IsAudioBufferProcessed(arg1); + lua_pushboolean(L, result); + return 1; +} + +int lua_PlayAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + PlayAudioStream(arg1); + return 0; +} + + +int lua_StopAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + StopAudioStream(arg1); + return 0; +} + +int lua_PauseAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + PauseAudioStream(arg1); + return 0; +} + +int lua_ResumeAudioStream(lua_State* L) +{ + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + ResumeAudioStream(arg1); + return 0; +} //---------------------------------------------------------------------------------- // raylib [utils] module functions @@ -3114,29 +3471,49 @@ int lua_QuaternionTransform(lua_State* L) // raylib Functions (and data types) list static luaL_Reg raylib_functions[] = { - REG(Color) + + // Register non-opaque data types + REG(Color) REG(Vector2) REG(Vector3) + //REG(Matrix) + REG(Quaternion) REG(Rectangle) REG(Ray) REG(Camera) - // TODO: Additional structs + REG(Camera2D) + REG(BoundingBox) + //REG(Material) - // TODO: Review registered functions + // Register functions REG(InitWindow) REG(CloseWindow) REG(WindowShouldClose) REG(IsWindowMinimized) REG(ToggleFullscreen) - REG(GetScreenWidth) REG(GetScreenHeight) + + REG(ShowCursor) + REG(HideCursor) + REG(IsCursorHidden) + REG(EnableCursor) + REG(DisableCursor) + REG(ClearBackground) REG(BeginDrawing) REG(EndDrawing) + REG(Begin2dMode) + REG(End2dMode) REG(Begin3dMode) REG(End3dMode) + REG(BeginTextureMode) + REG(EndTextureMode) + REG(GetMouseRay) + REG(GetWorldToScreen) + REG(GetCameraMatrix) + #if defined(PLATFORM_WEB) REG(SetDrawingLoop) #else @@ -3144,21 +3521,39 @@ static luaL_Reg raylib_functions[] = { #endif REG(GetFPS) REG(GetFrameTime) + REG(GetColor) REG(GetHexValue) + REG(ColorToFloat) + REG(VectorToFloat) + REG(MatrixToFloat) REG(GetRandomValue) REG(Fade) REG(SetConfigFlags) REG(ShowLogo) + REG(IsFileDropped) //REG(*GetDroppedFiles) REG(ClearDroppedFiles) + REG(StorageSaveValue) + REG(StorageLoadValue) + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) REG(IsKeyPressed) REG(IsKeyDown) REG(IsKeyReleased) REG(IsKeyUp) REG(GetKeyPressed) + REG(SetExitKey) + + REG(IsGamepadAvailable) + REG(GetGamepadAxisMovement) + REG(IsGamepadButtonPressed) + REG(IsGamepadButtonDown) + REG(IsGamepadButtonReleased) + REG(IsGamepadButtonUp) +#endif + REG(IsMouseButtonPressed) REG(IsMouseButtonDown) REG(IsMouseButtonReleased) @@ -3168,50 +3563,41 @@ static luaL_Reg raylib_functions[] = { REG(GetMousePosition) REG(SetMousePosition) REG(GetMouseWheelMove) - REG(ShowCursor) - REG(HideCursor) - REG(IsCursorHidden) -#endif - -#if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) - REG(IsGamepadAvailable) - - REG(IsGamepadButtonPressed) - REG(IsGamepadButtonDown) - REG(IsGamepadButtonReleased) - REG(IsGamepadButtonUp) -#endif - -#if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) REG(GetTouchX) REG(GetTouchY) REG(GetTouchPosition) -#if defined(PLATFORM_WEB) - REG(InitGesturesSystem) -#elif defined(PLATFORM_ANDROID) - //REG(InitGesturesSystem) + +#if defined(PLATFORM_ANDROID) + REG(IsButtonPressed) + REG(IsButtonDown) + REG(IsButtonReleased) #endif - REG(UpdateGestures) - REG(IsGestureDetected) - REG(GetGestureType) + REG(SetGesturesEnabled) - REG(GetGestureDragIntensity) - REG(GetGestureDragAngle) - REG(GetGestureDragVector) + REG(IsGestureDetected) + //REG(ProcessGestureEvent) + REG(UpdateGestures) + REG(GetTouchPointsCount) + REG(GetGestureDetected) REG(GetGestureHoldDuration) - REG(GetGesturePinchDelta) + REG(GetGestureDragVector) + REG(GetGestureDragAngle) + REG(GetGesturePinchVector) REG(GetGesturePinchAngle) -#endif + REG(SetCameraMode) REG(UpdateCamera) REG(UpdateCameraPlayer) REG(SetCameraPosition) REG(SetCameraTarget) + REG(SetCameraFovy) + REG(SetCameraPanControl) REG(SetCameraAltControl) REG(SetCameraSmoothZoomControl) REG(SetCameraMoveControls) REG(SetCameraMouseSensitivity) + REG(DrawPixel) REG(DrawPixelV) REG(DrawLine) @@ -3230,6 +3616,7 @@ static luaL_Reg raylib_functions[] = { REG(DrawPoly) REG(DrawPolyEx) REG(DrawPolyExLines) + REG(CheckCollisionRecs) REG(CheckCollisionCircles) REG(CheckCollisionCircleRec) @@ -3237,25 +3624,48 @@ static luaL_Reg raylib_functions[] = { REG(CheckCollisionPointRec) REG(CheckCollisionPointCircle) REG(CheckCollisionPointTriangle) + REG(LoadImage) REG(LoadImageEx) REG(LoadImageRaw) REG(LoadImageFromRES) REG(LoadTexture) + REG(LoadTextureEx) REG(LoadTextureFromRES) REG(LoadTextureFromImage) + REG(LoadRenderTexture) REG(UnloadImage) REG(UnloadTexture) REG(GetImageData) REG(GetTextureData) REG(ImageToPOT) REG(ImageFormat) + REG(ImageDither) + REG(ImageCopy) + REG(ImageCrop) + REG(ImageResize) + REG(ImageResizeNN) + REG(ImageText) + REG(ImageTextEx) + REG(ImageDraw) + REG(ImageDrawText) + REG(ImageDrawTextEx) + REG(ImageFlipVertical) + REG(ImageFlipHorizontal) + REG(ImageColorTint) + REG(ImageColorInvert) + REG(ImageColorGrayscale) + REG(ImageColorContrast) + REG(ImageColorBrightness) REG(GenTextureMipmaps) + REG(UpdateTexture) + REG(DrawTexture) REG(DrawTextureV) REG(DrawTextureEx) REG(DrawTextureRec) REG(DrawTexturePro) + REG(GetDefaultFont) REG(LoadSpriteFont) REG(UnloadSpriteFont) @@ -3264,6 +3674,9 @@ static luaL_Reg raylib_functions[] = { REG(MeasureText) REG(MeasureTextEx) REG(DrawFPS) + //REG(FormatText) + //REG(SubText) + REG(DrawCube) REG(DrawCubeV) REG(DrawCubeWires) @@ -3277,49 +3690,92 @@ static luaL_Reg raylib_functions[] = { REG(DrawRay) REG(DrawGrid) REG(DrawGizmo) + REG(LoadModel) REG(LoadModelEx) + REG(LoadModelFromRES) REG(LoadHeightmap) REG(LoadCubicmap) REG(UnloadModel) + //REG(GenMesh*) // Not ready yet... + REG(DrawModel) REG(DrawModelEx) REG(DrawModelWires) + REG(DrawModelWiresEx) REG(DrawBillboard) REG(DrawBillboardRec) + REG(CalculateBoundingBox) REG(CheckCollisionSpheres) REG(CheckCollisionBoxes) REG(CheckCollisionBoxSphere) + REG(CheckCollisionRaySphere) + REG(CheckCollisionRaySphereEx) + REG(CheckCollisionRayBox) REG(ResolveCollisionCubicmap) + REG(LoadShader) REG(UnloadShader) + REG(GetDefaultShader) + REG(GetStandardShader) + REG(GetDefaultTexture) REG(GetShaderLocation) REG(SetShaderValue) REG(SetShaderValuei) - + REG(SetShaderValueMatrix) + REG(SetMatrixProjection) + REG(SetMatrixModelview) + REG(BeginShaderMode) + REG(EndShaderMode) REG(BeginBlendMode) REG(EndBlendMode) + //REG(CreateLight) + //REG(DestroyLight) + + REG(InitVrDevice) + REG(CloseVrDevice) + REG(UpdateVrTracking) + REG(BeginVrDrawing) + REG(EndVrDrawing) + REG(IsVrDeviceReady) + REG(ToggleVrMode) + REG(InitAudioDevice) REG(CloseAudioDevice) + REG(IsAudioDeviceReady) REG(LoadSound) REG(LoadSoundFromWave) REG(LoadSoundFromRES) REG(UnloadSound) REG(PlaySound) REG(PauseSound) + REG(ResumeSound) REG(StopSound) REG(IsSoundPlaying) REG(SetSoundVolume) REG(SetSoundPitch) - REG(PlayMusicStream) + + REG(LoadMusicStream) + REG(UnloadMusicStream) REG(UpdateMusicStream) + REG(PlayMusicStream) REG(StopMusicStream) REG(PauseMusicStream) REG(ResumeMusicStream) REG(IsMusicPlaying) REG(SetMusicVolume) + REG(SetMusicPitch) REG(GetMusicTimeLength) REG(GetMusicTimePlayed) + + REG(InitAudioStream) + REG(UpdateAudioStream) + REG(CloseAudioStream) + REG(IsAudioBufferProcessed) + REG(PlayAudioStream) + REG(PauseAudioStream) + REG(ResumeAudioStream) + REG(StopAudioStream) /// Math and util REG(DecompressData) -- cgit v1.2.3 From 5f1b4e94745303ab9df87421cdd9ffb9448fee01 Mon Sep 17 00:00:00 2001 From: raysan5 Date: Sat, 6 Aug 2016 11:30:34 +0200 Subject: Updated Lua module --- src/rlua.h | 55 ++++++++++++++++++++++++++++++++++++++++--------------- 1 file changed, 40 insertions(+), 15 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index 76a79c7c..675edbfc 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -4,7 +4,7 @@ * * NOTE 01: * The following types: -* Color, Vector2, Vector3, Rectangle, Ray, Camera +* Color, Vector2, Vector3, Rectangle, Ray, Camera, Camera2D * are treated as objects with named fields, same as in C. * * Lua defines utility functions for creating those objects. @@ -178,6 +178,7 @@ static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index); static Color LuaGetArgument_Color(lua_State* L, int index); static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index); static Camera LuaGetArgument_Camera(lua_State* L, int index); +static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index); static Ray LuaGetArgument_Ray(lua_State* L, int index); static Matrix LuaGetArgument_Matrix(lua_State* L, int index); static Model LuaGetArgument_Model(lua_State* L, int index); @@ -594,7 +595,7 @@ static void LuaPush_Camera(lua_State* L, Camera cam) static void LuaPush_Camera2D(lua_State* L, Camera2D cam) { - lua_createtable(L, 0, 3); + lua_createtable(L, 0, 4); LuaPush_Vector2(L, cam.offset); lua_setfield(L, -2, "offset"); LuaPush_Vector2(L, cam.target); @@ -702,8 +703,8 @@ static int lua_Camera(lua_State* L) Vector3 pos = LuaGetArgument_Vector3(L, 1); Vector3 tar = LuaGetArgument_Vector3(L, 2); Vector3 up = LuaGetArgument_Vector3(L, 3); - float fovy = LuaGetArgument_float(L, 4); - LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, fovy }); + //float fovy = LuaGetArgument_float(L, 4); // ??? + LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) }); return 1; } @@ -3945,9 +3946,33 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("BUTTON_L2", 8); LuaSetEnum("BUTTON_SELECT", 9); LuaSetEnum("BUTTON_START", 10); - LuaEndEnum("GAMEPAD"); - // TODO: XBOX controller buttons enum + LuaSetEnum("XBOX_BUTTON_A", 0); + LuaSetEnum("XBOX_BUTTON_B", 1); + LuaSetEnum("XBOX_BUTTON_X", 2); + LuaSetEnum("XBOX_BUTTON_Y", 3); + LuaSetEnum("XBOX_BUTTON_LB", 4); + LuaSetEnum("XBOX_BUTTON_RB", 5); + LuaSetEnum("XBOX_BUTTON_SELECT", 6); + LuaSetEnum("XBOX_BUTTON_START", 7); + +#if defined(PLATFORM_RPI) + LuaSetEnum("XBOX_AXIS_DPAD_X", 7); + LuaSetEnum("XBOX_AXIS_DPAD_Y", 6); + LuaSetEnum("XBOX_AXIS_RIGHT_X", 3); + LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4); + LuaSetEnum("XBOX_AXIS_LT", 2); + LuaSetEnum("XBOX_AXIS_RT", 5); +#else + LuaSetEnum("XBOX_BUTTON_UP", 10); + LuaSetEnum("XBOX_BUTTON_DOWN", 12); + LuaSetEnum("XBOX_BUTTON_LEFT", 13); + LuaSetEnum("XBOX_BUTTON_RIGHT", 11); + LuaSetEnum("XBOX_AXIS_RIGHT_X", 4); + LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3); + LuaSetEnum("XBOX_AXIS_LT_RT", 2); +#endif + LuaEndEnum("GAMEPAD"); lua_pushglobaltable(L); LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY); @@ -4028,15 +4053,15 @@ RLUADEF void InitLuaDevice(void) LuaEndEnum("CameraMode"); LuaStartEnum(); - LuaSetEnum("HMD_DEFAULT_DEVICE", HMD_DEFAULT_DEVICE); - LuaSetEnum("HMD_OCULUS_RIFT_DK2", HMD_OCULUS_RIFT_DK2); - LuaSetEnum("HMD_OCULUS_RIFT_CV1", HMD_OCULUS_RIFT_CV1); - LuaSetEnum("HMD_VALVE_HTC_VIVE", HMD_VALVE_HTC_VIVE); - LuaSetEnum("HMD_SAMSUNG_GEAR_VR", HMD_SAMSUNG_GEAR_VR); - LuaSetEnum("HMD_GOOGLE_CARDBOARD", HMD_GOOGLE_CARDBOARD); - LuaSetEnum("HMD_SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR); - LuaSetEnum("HMD_RAZER_OSVR", HMD_RAZER_OSVR); - LuaSetEnum("HMD_FOVE_VR", HMD_FOVE_VR); + LuaSetEnum("DEFAULT_DEVICE", HMD_DEFAULT_DEVICE); + LuaSetEnum("OCULUS_RIFT_DK2", HMD_OCULUS_RIFT_DK2); + LuaSetEnum("OCULUS_RIFT_CV1", HMD_OCULUS_RIFT_CV1); + LuaSetEnum("VALVE_HTC_VIVE", HMD_VALVE_HTC_VIVE); + LuaSetEnum("SAMSUNG_GEAR_VR", HMD_SAMSUNG_GEAR_VR); + LuaSetEnum("GOOGLE_CARDBOARD", HMD_GOOGLE_CARDBOARD); + LuaSetEnum("SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR); + LuaSetEnum("RAZER_OSVR", HMD_RAZER_OSVR); + LuaSetEnum("FOVE_VR", HMD_FOVE_VR); LuaEndEnum("VrDevice"); lua_pushglobaltable(L); -- cgit v1.2.3 From 3b80e2c1e03e0f87d50ca8876b50a11c7df1f56f Mon Sep 17 00:00:00 2001 From: raysan5 Date: Sat, 6 Aug 2016 16:32:46 +0200 Subject: Redesigned gestures module to header-only --- src/Makefile | 6 +- src/core.c | 16 +- src/gestures.c | 423 -------------------------------------------------- src/gestures.h | 480 +++++++++++++++++++++++++++++++++++++++++++++++++++++---- src/raylib.h | 17 +- src/rlua.h | 10 +- 6 files changed, 458 insertions(+), 494 deletions(-) delete mode 100644 src/gestures.c (limited to 'src/rlua.h') diff --git a/src/Makefile b/src/Makefile index 1360a920..e82c2861 100644 --- a/src/Makefile +++ b/src/Makefile @@ -168,7 +168,7 @@ endif # compile all modules with their prerequisites # compile core module -core.o : core.c raylib.h rlgl.h utils.h raymath.h +core.o : core.c raylib.h rlgl.h utils.h raymath.h gestures.h $(CC) -c $< $(CFLAGS) $(INCLUDES) -D$(PLATFORM) # compile rlgl module @@ -207,10 +207,6 @@ utils.o : utils.c utils.h camera.o : camera.c raylib.h $(CC) -c $< $(CFLAGS) $(INCLUDES) -#compile gestures module -gestures.o : gestures.c raylib.h - $(CC) -c $< $(CFLAGS) $(INCLUDES) - # It installs generated and needed files to compile projects using raylib. # The installation works manually. # TODO: add other platforms. diff --git a/src/core.c b/src/core.c index 47463a23..4cb34b0a 100644 --- a/src/core.c +++ b/src/core.c @@ -39,13 +39,15 @@ #include "raylib.h" // raylib main header #include "rlgl.h" // raylib OpenGL abstraction layer to OpenGL 1.1, 3.3+ or ES2 -#include "utils.h" // TraceLog() function - // NOTE: Includes Android fopen map, InitAssetManager() - +#include "utils.h" // Includes Android fopen map, InitAssetManager(), TraceLog() + #define RAYMATH_IMPLEMENTATION // Use raymath as a header-only library (includes implementation) #define RAYMATH_EXTERN_INLINE // Compile raymath functions as static inline (remember, it's a compiler hint) #include "raymath.h" // Required for Vector3 and Matrix functions +#define GESTURES_IMPLEMENTATION +#include "gestures.h" // Gestures detection functionality + #include // Standard input / output lib #include // Declares malloc() and free() for memory management, rand(), atexit() #include // Required for typedef unsigned long long int uint64_t, used by hi-res timer @@ -234,6 +236,9 @@ static bool showLogo = false; // Track if showing logo at init is extern void LoadDefaultFont(void); // [Module: text] Loads default font on InitWindow() extern void UnloadDefaultFont(void); // [Module: text] Unloads default font from GPU memory +extern void ProcessGestureEvent(GestureEvent event); // [Module: gestures] Process gesture event and translate it into gestures +extern void UpdateGestures(void); // [Module: gestures] Update gestures detected (called in PollInputEvents()) + //---------------------------------------------------------------------------------- // Module specific Functions Declaration //---------------------------------------------------------------------------------- @@ -2052,10 +2057,7 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i // NOTE: Before closing window, while loop must be left! } #if defined(PLATFORM_DESKTOP) - else if (key == GLFW_KEY_F12 && action == GLFW_PRESS) - { - TakeScreenshot(); - } + else if (key == GLFW_KEY_F12 && action == GLFW_PRESS) TakeScreenshot(); #endif else { diff --git a/src/gestures.c b/src/gestures.c deleted file mode 100644 index 57b96bd2..00000000 --- a/src/gestures.c +++ /dev/null @@ -1,423 +0,0 @@ -/********************************************************************************************** -* -* raylib Gestures System - Gestures Processing based on input gesture events (touch/mouse) -* -* Initial design by Marc Palau -* Redesigned by Albert Martos and Ian Eito -* Reviewed by Ramon Santamaria (@raysan5) -* -* This software is provided "as-is", without any express or implied warranty. In no event -* will the authors be held liable for any damages arising from the use of this software. -* -* Permission is granted to anyone to use this software for any purpose, including commercial -* applications, and to alter it and redistribute it freely, subject to the following restrictions: -* -* 1. The origin of this software must not be misrepresented; you must not claim that you -* wrote the original software. If you use this software in a product, an acknowledgment -* in the product documentation would be appreciated but is not required. -* -* 2. Altered source versions must be plainly marked as such, and must not be misrepresented -* as being the original software. -* -* 3. This notice may not be removed or altered from any source distribution. -* -**********************************************************************************************/ - -//#define GESTURES_STANDALONE // NOTE: To use the gestures module as standalone lib, just uncomment this line - -#if defined(GESTURES_STANDALONE) - #include "gestures.h" -#else - #include "raylib.h" // Required for: Vector2, Gestures -#endif - -#include // Required for: atan2(), sqrt() -#include // Required for: uint64_t - -#if defined(_WIN32) - // Functions required to query time on Windows - int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount); - int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency); -#elif defined(__linux) - #include // Required for: timespec - #include // Required for: clock_gettime() -#endif - -//---------------------------------------------------------------------------------- -// Defines and Macros -//---------------------------------------------------------------------------------- -#define FORCE_TO_SWIPE 0.0005f // Measured in normalized screen units/time -#define MINIMUM_DRAG 0.015f // Measured in normalized screen units (0.0f to 1.0f) -#define MINIMUM_PINCH 0.005f // Measured in normalized screen units (0.0f to 1.0f) -#define TAP_TIMEOUT 300 // Time in milliseconds -#define PINCH_TIMEOUT 300 // Time in milliseconds -#define DOUBLETAP_RANGE 0.03f // Measured in normalized screen units (0.0f to 1.0f) - -//---------------------------------------------------------------------------------- -// Types and Structures Definition -//---------------------------------------------------------------------------------- -// ... - -//---------------------------------------------------------------------------------- -// Global Variables Definition -//---------------------------------------------------------------------------------- - -// Touch gesture variables -static Vector2 touchDownPosition = { 0.0f, 0.0f }; -static Vector2 touchDownPosition2 = { 0.0f, 0.0f }; -static Vector2 touchDownDragPosition = { 0.0f, 0.0f }; -static Vector2 touchUpPosition = { 0.0f, 0.0f }; -static Vector2 moveDownPosition = { 0.0f, 0.0f }; -static Vector2 moveDownPosition2 = { 0.0f, 0.0f }; -static int numTap = 0; - -static int pointCount = 0; -static int firstTouchId = -1; - -static double eventTime = 0.0; -static double swipeTime = 0.0; - -// Hold gesture variables -static int numHold = 0; -static float timeHold = 0.0f; - -// Drag gesture variables -static Vector2 dragVector = { 0.0f , 0.0f }; // DRAG vector (between initial and current position) -static float dragAngle = 0.0f; // DRAG angle (relative to x-axis) -static float dragDistance = 0.0f; // DRAG distance (from initial touch point to final) (normalized [0..1]) -static float dragIntensity = 0.0f; // DRAG intensity, how far why did the DRAG (pixels per frame) -static bool startMoving = false; // SWIPE used to define when start measuring swipeTime - -// Pinch gesture variables -static Vector2 pinchVector = { 0.0f , 0.0f }; // PINCH vector (between first and second touch points) -static float pinchAngle = 0.0f; // PINCH angle (relative to x-axis) -static float pinchDistance = 0.0f; // PINCH displacement distance (normalized [0..1]) - -// Detected gestures -static int previousGesture = GESTURE_NONE; -static int currentGesture = GESTURE_NONE; - -// Enabled gestures flags, all gestures enabled by default -static unsigned int enabledGestures = 0b0000001111111111; - -//---------------------------------------------------------------------------------- -// Module specific Functions Declaration -//---------------------------------------------------------------------------------- -static float Vector2Angle(Vector2 initialPosition, Vector2 finalPosition); -static float Vector2Distance(Vector2 v1, Vector2 v2); -static double GetCurrentTime(void); - -//---------------------------------------------------------------------------------- -// Module Functions Definition -//---------------------------------------------------------------------------------- - -// Enable only desired getures to be detected -void SetGesturesEnabled(unsigned int gestureFlags) -{ - enabledGestures = gestureFlags; -} - -// Check if a gesture have been detected -bool IsGestureDetected(int gesture) -{ - if ((enabledGestures & currentGesture) == gesture) return true; - else return false; -} - -// Process gesture event and translate it into gestures -void ProcessGestureEvent(GestureEvent event) -{ - // Reset required variables - previousGesture = currentGesture; - - pointCount = event.pointCount; // Required on UpdateGestures() - - if (pointCount < 2) - { - if (event.touchAction == TOUCH_DOWN) - { - numTap++; // Tap counter - - // Detect GESTURE_DOUBLE_TAP - if ((currentGesture == GESTURE_NONE) && (numTap >= 2) && ((GetCurrentTime() - eventTime) < TAP_TIMEOUT) && (Vector2Distance(touchDownPosition, event.position[0]) < DOUBLETAP_RANGE)) - { - currentGesture = GESTURE_DOUBLETAP; - numTap = 0; - } - else // Detect GESTURE_TAP - { - numTap = 1; - currentGesture = GESTURE_TAP; - } - - touchDownPosition = event.position[0]; - touchDownDragPosition = event.position[0]; - - touchUpPosition = touchDownPosition; - eventTime = GetCurrentTime(); - - firstTouchId = event.pointerId[0]; - - dragVector = (Vector2){ 0.0f, 0.0f }; - } - else if (event.touchAction == TOUCH_UP) - { - if (currentGesture == GESTURE_DRAG) touchUpPosition = event.position[0]; - - // NOTE: dragIntensity dependend on the resolution of the screen - dragDistance = Vector2Distance(touchDownPosition, touchUpPosition); - dragIntensity = dragDistance/(float)((GetCurrentTime() - swipeTime)); - - startMoving = false; - - // Detect GESTURE_SWIPE - if ((dragIntensity > FORCE_TO_SWIPE) && firstTouchId == event.pointerId[0]) - { - // NOTE: Angle should be inverted in Y - dragAngle = 360.0f - Vector2Angle(touchDownPosition, touchUpPosition); - - if ((dragAngle < 30) || (dragAngle > 330)) currentGesture = GESTURE_SWIPE_RIGHT; // Right - else if ((dragAngle > 30) && (dragAngle < 120)) currentGesture = GESTURE_SWIPE_UP; // Up - else if ((dragAngle > 120) && (dragAngle < 210)) currentGesture = GESTURE_SWIPE_LEFT; // Left - else if ((dragAngle > 210) && (dragAngle < 300)) currentGesture = GESTURE_SWIPE_DOWN; // Down - else currentGesture = GESTURE_NONE; - } - else - { - dragDistance = 0.0f; - dragIntensity = 0.0f; - dragAngle = 0.0f; - - currentGesture = GESTURE_NONE; - } - - touchDownDragPosition = (Vector2){ 0.0f, 0.0f }; - pointCount = 0; - } - else if (event.touchAction == TOUCH_MOVE) - { - if (currentGesture == GESTURE_DRAG) eventTime = GetCurrentTime(); - - if (!startMoving) - { - swipeTime = GetCurrentTime(); - startMoving = true; - } - - moveDownPosition = event.position[0]; - - if (currentGesture == GESTURE_HOLD) - { - if (numHold == 1) touchDownPosition = event.position[0]; - - numHold = 2; - - // Detect GESTURE_DRAG - if (Vector2Distance(touchDownPosition, moveDownPosition) >= MINIMUM_DRAG) - { - eventTime = GetCurrentTime(); - currentGesture = GESTURE_DRAG; - } - } - - dragVector.x = moveDownPosition.x - touchDownDragPosition.x; - dragVector.y = moveDownPosition.y - touchDownDragPosition.y; - } - } - else // Two touch points - { - if (event.touchAction == TOUCH_DOWN) - { - touchDownPosition = event.position[0]; - touchDownPosition2 = event.position[1]; - - //pinchDistance = Vector2Distance(touchDownPosition, touchDownPosition2); - - pinchVector.x = touchDownPosition2.x - touchDownPosition.x; - pinchVector.y = touchDownPosition2.y - touchDownPosition.y; - - currentGesture = GESTURE_HOLD; - timeHold = GetCurrentTime(); - } - else if (event.touchAction == TOUCH_MOVE) - { - pinchDistance = Vector2Distance(moveDownPosition, moveDownPosition2); - - touchDownPosition = moveDownPosition; - touchDownPosition2 = moveDownPosition2; - - moveDownPosition = event.position[0]; - moveDownPosition2 = event.position[1]; - - pinchVector.x = moveDownPosition2.x - moveDownPosition.x; - pinchVector.y = moveDownPosition2.y - moveDownPosition.y; - - if ((Vector2Distance(touchDownPosition, moveDownPosition) >= MINIMUM_PINCH) || (Vector2Distance(touchDownPosition2, moveDownPosition2) >= MINIMUM_PINCH)) - { - if ((Vector2Distance(moveDownPosition, moveDownPosition2) - pinchDistance) < 0) currentGesture = GESTURE_PINCH_IN; - else currentGesture = GESTURE_PINCH_OUT; - } - else - { - currentGesture = GESTURE_HOLD; - timeHold = GetCurrentTime(); - } - - // NOTE: Angle should be inverted in Y - pinchAngle = 360.0f - Vector2Angle(moveDownPosition, moveDownPosition2); - } - else if (event.touchAction == TOUCH_UP) - { - pinchDistance = 0.0f; - pinchAngle = 0.0f; - pinchVector = (Vector2){ 0.0f, 0.0f }; - pointCount = 0; - - currentGesture = GESTURE_NONE; - } - } -} - -// Update gestures detected (must be called every frame) -void UpdateGestures(void) -{ - // NOTE: Gestures are processed through system callbacks on touch events - - // Detect GESTURE_HOLD - if (((currentGesture == GESTURE_TAP) || (currentGesture == GESTURE_DOUBLETAP)) && (pointCount < 2)) - { - currentGesture = GESTURE_HOLD; - timeHold = GetCurrentTime(); - } - - if (((GetCurrentTime() - eventTime) > TAP_TIMEOUT) && (currentGesture == GESTURE_DRAG) && (pointCount < 2)) - { - currentGesture = GESTURE_HOLD; - timeHold = GetCurrentTime(); - numHold = 1; - } - - // Detect GESTURE_NONE - if ((currentGesture == GESTURE_SWIPE_RIGHT) || (currentGesture == GESTURE_SWIPE_UP) || (currentGesture == GESTURE_SWIPE_LEFT) || (currentGesture == GESTURE_SWIPE_DOWN)) - { - currentGesture = GESTURE_NONE; - } -} - -// Get number of touch points -int GetTouchPointsCount(void) -{ - // NOTE: point count is calculated when ProcessGestureEvent(GestureEvent event) is called - - return pointCount; -} - -// Get latest detected gesture -int GetGestureDetected(void) -{ - // Get current gesture only if enabled - return (enabledGestures & currentGesture); -} - -// Hold time measured in ms -float GetGestureHoldDuration(void) -{ - // NOTE: time is calculated on current gesture HOLD - - float time = 0.0f; - - if (currentGesture == GESTURE_HOLD) time = (float)GetCurrentTime() - timeHold; - - return time; -} - -// Get drag vector (between initial touch point to current) -Vector2 GetGestureDragVector(void) -{ - // NOTE: drag vector is calculated on one touch points TOUCH_MOVE - - return dragVector; -} - -// Get drag angle -// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise -float GetGestureDragAngle(void) -{ - // NOTE: drag angle is calculated on one touch points TOUCH_UP - - return dragAngle; -} - -// Get distance between two pinch points -Vector2 GetGesturePinchVector(void) -{ - // NOTE: The position values used for pinchDistance are not modified like the position values of [core.c]-->GetTouchPosition(int index) - // NOTE: pinch distance is calculated on two touch points TOUCH_MOVE - - return pinchVector; -} - -// Get angle beween two pinch points -// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise -float GetGesturePinchAngle(void) -{ - // NOTE: pinch angle is calculated on two touch points TOUCH_MOVE - - return pinchAngle; -} - -//---------------------------------------------------------------------------------- -// Module specific Functions Definition -//---------------------------------------------------------------------------------- - -// Returns angle from two-points vector with X-axis -static float Vector2Angle(Vector2 initialPosition, Vector2 finalPosition) -{ - float angle; - - angle = atan2(finalPosition.y - initialPosition.y, finalPosition.x - initialPosition.x); - angle *= RAD2DEG; - - if (angle < 0) angle += 360.0f; - - return angle; -} - -// Calculate distance between two Vector2 -static float Vector2Distance(Vector2 v1, Vector2 v2) -{ - float result; - - float dx = v2.x - v1.x; - float dy = v2.y - v1.y; - - result = sqrt(dx*dx + dy*dy); - - return result; -} - -// Time measure returned are milliseconds -static double GetCurrentTime(void) -{ - double time = 0; - -#if defined(_WIN32) - unsigned long long int clockFrequency, currentTime; - - QueryPerformanceFrequency(&clockFrequency); - QueryPerformanceCounter(¤tTime); - - time = (double)currentTime/clockFrequency*1000.0f; // Time in miliseconds -#endif - -#if defined(__linux) - // NOTE: Only for Linux-based systems - struct timespec now; - clock_gettime(CLOCK_MONOTONIC, &now); - uint64_t nowTime = (uint64_t)now.tv_sec*1000000000LLU + (uint64_t)now.tv_nsec; // Time in nanoseconds - - time = ((double)nowTime/1000000.0); // Time in miliseconds -#endif - - return time; -} diff --git a/src/gestures.h b/src/gestures.h index 912d0b92..4c59ee39 100644 --- a/src/gestures.h +++ b/src/gestures.h @@ -1,8 +1,21 @@ /********************************************************************************************** * -* raylib Gestures System - Gestures Detection and Usage Functions (Android and HTML5) +* raylib Gestures System - Gestures Processing based on input gesture events (touch/mouse) * -* Copyright (c) 2015 Marc Palau and Ramon Santamaria +* #define GESTURES_IMPLEMENTATION +* Generates the implementation of the library into the included file. +* If not defined, the library is in header only mode and can be included in other headers +* or source files without problems. But only ONE file should hold the implementation. +* +* #define GESTURES_STANDALONE +* If defined, the library can be used as standalone to process gesture events with +* no external dependencies. +* +* NOTE: Memory footprint of this library is aproximately 128 bytes +* +* Initial design by Marc Palau +* Redesigned by Albert Martos and Ian Eito +* Reviewed by Ramon Santamaria (@raysan5) * * This software is provided "as-is", without any express or implied warranty. In no event * will the authors be held liable for any damages arising from the use of this software. @@ -28,9 +41,6 @@ #define PI 3.14159265358979323846 #endif -#define DEG2RAD (PI / 180.0f) -#define RAD2DEG (180.0f / PI) - //---------------------------------------------------------------------------------- // Defines and Macros //---------------------------------------------------------------------------------- @@ -40,32 +50,34 @@ // Types and Structures Definition // NOTE: Below types are required for GESTURES_STANDALONE usage //---------------------------------------------------------------------------------- -#ifndef __cplusplus - // Boolean type - typedef enum { false, true } bool; -#endif +#if defined(GESTURES_STANDALONE) + #ifndef __cplusplus + // Boolean type + typedef enum { false, true } bool; + #endif + + // Vector2 type + typedef struct Vector2 { + float x; + float y; + } Vector2; -// Vector2 type -typedef struct Vector2 { - float x; - float y; -} Vector2; - -// Gestures type -// NOTE: It could be used as flags to enable only some gestures -typedef enum { - GESTURE_NONE = 1, - GESTURE_TAP = 2, - GESTURE_DOUBLETAP = 4, - GESTURE_HOLD = 8, - GESTURE_DRAG = 16, - GESTURE_SWIPE_RIGHT = 32, - GESTURE_SWIPE_LEFT = 64, - GESTURE_SWIPE_UP = 128, - GESTURE_SWIPE_DOWN = 256, - GESTURE_PINCH_IN = 512, - GESTURE_PINCH_OUT = 1024 -} Gestures; + // Gestures type + // NOTE: It could be used as flags to enable only some gestures + typedef enum { + GESTURE_NONE = 1, + GESTURE_TAP = 2, + GESTURE_DOUBLETAP = 4, + GESTURE_HOLD = 8, + GESTURE_DRAG = 16, + GESTURE_SWIPE_RIGHT = 32, + GESTURE_SWIPE_LEFT = 64, + GESTURE_SWIPE_UP = 128, + GESTURE_SWIPE_DOWN = 256, + GESTURE_PINCH_IN = 512, + GESTURE_PINCH_OUT = 1024 + } Gestures; +#endif typedef enum { TOUCH_UP, TOUCH_DOWN, TOUCH_MOVE } TouchAction; @@ -90,22 +102,422 @@ extern "C" { // Prevents name mangling of functions //---------------------------------------------------------------------------------- // Module Functions Declaration //---------------------------------------------------------------------------------- -void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags -bool IsGestureDetected(int gesture); // Check if a gesture have been detected void ProcessGestureEvent(GestureEvent event); // Process gesture event and translate it into gestures void UpdateGestures(void); // Update gestures detected (must be called every frame) -int GetTouchPointsCount(void); // Get touch points count +#if defined(GESTURES_STANDALONE) +void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags +bool IsGestureDetected(int gesture); // Check if a gesture have been detected int GetGestureDetected(void); // Get latest detected gesture +int GetTouchPointsCount(void); // Get touch points count float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds Vector2 GetGestureDragVector(void); // Get gesture drag vector float GetGestureDragAngle(void); // Get gesture drag angle Vector2 GetGesturePinchVector(void); // Get gesture pinch delta float GetGesturePinchAngle(void); // Get gesture pinch angle - +#endif #ifdef __cplusplus } #endif #endif // GESTURES_H + +/*********************************************************************************** +* +* GESTURES IMPLEMENTATION +* +************************************************************************************/ + +#if defined(GESTURES_IMPLEMENTATION) + +#include // Required for: atan2(), sqrt() +#include // Required for: uint64_t + +#if defined(_WIN32) + // Functions required to query time on Windows + int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount); + int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency); +#elif defined(__linux) + #include // Required for: timespec + #include // Required for: clock_gettime() +#endif + +//---------------------------------------------------------------------------------- +// Defines and Macros +//---------------------------------------------------------------------------------- +#define FORCE_TO_SWIPE 0.0005f // Measured in normalized screen units/time +#define MINIMUM_DRAG 0.015f // Measured in normalized screen units (0.0f to 1.0f) +#define MINIMUM_PINCH 0.005f // Measured in normalized screen units (0.0f to 1.0f) +#define TAP_TIMEOUT 300 // Time in milliseconds +#define PINCH_TIMEOUT 300 // Time in milliseconds +#define DOUBLETAP_RANGE 0.03f // Measured in normalized screen units (0.0f to 1.0f) + +//---------------------------------------------------------------------------------- +// Types and Structures Definition +//---------------------------------------------------------------------------------- +// ... + +//---------------------------------------------------------------------------------- +// Global Variables Definition +//---------------------------------------------------------------------------------- + +// Touch gesture variables +static Vector2 touchDownPosition = { 0.0f, 0.0f }; +static Vector2 touchDownPosition2 = { 0.0f, 0.0f }; +static Vector2 touchDownDragPosition = { 0.0f, 0.0f }; +static Vector2 touchUpPosition = { 0.0f, 0.0f }; +static Vector2 moveDownPosition = { 0.0f, 0.0f }; +static Vector2 moveDownPosition2 = { 0.0f, 0.0f }; + +static int pointCount = 0; // Touch points counter +static int firstTouchId = -1; // Touch id for first touch point +static double eventTime = 0.0; // Time stamp when an event happened + +// Tap gesture variables +static int tapCounter = 0; // TAP counter (one tap implies TOUCH_DOWN and TOUCH_UP actions) + +// Hold gesture variables +static bool resetHold = false; // HOLD reset to get first touch point again +static float timeHold = 0.0f; // HOLD duration in milliseconds + +// Drag gesture variables +static Vector2 dragVector = { 0.0f , 0.0f }; // DRAG vector (between initial and current position) +static float dragAngle = 0.0f; // DRAG angle (relative to x-axis) +static float dragDistance = 0.0f; // DRAG distance (from initial touch point to final) (normalized [0..1]) +static float dragIntensity = 0.0f; // DRAG intensity, how far why did the DRAG (pixels per frame) + +// Swipe gestures variables +static bool startMoving = false; // SWIPE used to define when start measuring swipeTime +static double swipeTime = 0.0; // SWIPE time to calculate drag intensity + +// Pinch gesture variables +static Vector2 pinchVector = { 0.0f , 0.0f }; // PINCH vector (between first and second touch points) +static float pinchAngle = 0.0f; // PINCH angle (relative to x-axis) +static float pinchDistance = 0.0f; // PINCH displacement distance (normalized [0..1]) + +static int currentGesture = GESTURE_NONE; // Current detected gesture + +// Enabled gestures flags, all gestures enabled by default +static unsigned int enabledGestures = 0b0000001111111111; + +//---------------------------------------------------------------------------------- +// Module specific Functions Declaration +//---------------------------------------------------------------------------------- +static float Vector2Angle(Vector2 initialPosition, Vector2 finalPosition); +static float Vector2Distance(Vector2 v1, Vector2 v2); +static double GetCurrentTime(void); + +//---------------------------------------------------------------------------------- +// Module Functions Definition +//---------------------------------------------------------------------------------- + +// Enable only desired getures to be detected +void SetGesturesEnabled(unsigned int gestureFlags) +{ + enabledGestures = gestureFlags; +} + +// Check if a gesture have been detected +bool IsGestureDetected(int gesture) +{ + if ((enabledGestures & currentGesture) == gesture) return true; + else return false; +} + +// Process gesture event and translate it into gestures +void ProcessGestureEvent(GestureEvent event) +{ + // Reset required variables + pointCount = event.pointCount; // Required on UpdateGestures() + + if (pointCount < 2) + { + if (event.touchAction == TOUCH_DOWN) + { + tapCounter++; // Tap counter + + // Detect GESTURE_DOUBLE_TAP + if ((currentGesture == GESTURE_NONE) && (tapCounter >= 2) && ((GetCurrentTime() - eventTime) < TAP_TIMEOUT) && (Vector2Distance(touchDownPosition, event.position[0]) < DOUBLETAP_RANGE)) + { + currentGesture = GESTURE_DOUBLETAP; + tapCounter = 0; + } + else // Detect GESTURE_TAP + { + tapCounter = 1; + currentGesture = GESTURE_TAP; + } + + touchDownPosition = event.position[0]; + touchDownDragPosition = event.position[0]; + + touchUpPosition = touchDownPosition; + eventTime = GetCurrentTime(); + + firstTouchId = event.pointerId[0]; + + dragVector = (Vector2){ 0.0f, 0.0f }; + } + else if (event.touchAction == TOUCH_UP) + { + if (currentGesture == GESTURE_DRAG) touchUpPosition = event.position[0]; + + // NOTE: dragIntensity dependend on the resolution of the screen + dragDistance = Vector2Distance(touchDownPosition, touchUpPosition); + dragIntensity = dragDistance/(float)((GetCurrentTime() - swipeTime)); + + startMoving = false; + + // Detect GESTURE_SWIPE + if ((dragIntensity > FORCE_TO_SWIPE) && (firstTouchId == event.pointerId[0])) + { + // NOTE: Angle should be inverted in Y + dragAngle = 360.0f - Vector2Angle(touchDownPosition, touchUpPosition); + + if ((dragAngle < 30) || (dragAngle > 330)) currentGesture = GESTURE_SWIPE_RIGHT; // Right + else if ((dragAngle > 30) && (dragAngle < 120)) currentGesture = GESTURE_SWIPE_UP; // Up + else if ((dragAngle > 120) && (dragAngle < 210)) currentGesture = GESTURE_SWIPE_LEFT; // Left + else if ((dragAngle > 210) && (dragAngle < 300)) currentGesture = GESTURE_SWIPE_DOWN; // Down + else currentGesture = GESTURE_NONE; + } + else + { + dragDistance = 0.0f; + dragIntensity = 0.0f; + dragAngle = 0.0f; + + currentGesture = GESTURE_NONE; + } + + touchDownDragPosition = (Vector2){ 0.0f, 0.0f }; + pointCount = 0; + } + else if (event.touchAction == TOUCH_MOVE) + { + if (currentGesture == GESTURE_DRAG) eventTime = GetCurrentTime(); + + if (!startMoving) + { + swipeTime = GetCurrentTime(); + startMoving = true; + } + + moveDownPosition = event.position[0]; + + if (currentGesture == GESTURE_HOLD) + { + if (resetHold) touchDownPosition = event.position[0]; + + resetHold = false; + + // Detect GESTURE_DRAG + if (Vector2Distance(touchDownPosition, moveDownPosition) >= MINIMUM_DRAG) + { + eventTime = GetCurrentTime(); + currentGesture = GESTURE_DRAG; + } + } + + dragVector.x = moveDownPosition.x - touchDownDragPosition.x; + dragVector.y = moveDownPosition.y - touchDownDragPosition.y; + } + } + else // Two touch points + { + if (event.touchAction == TOUCH_DOWN) + { + touchDownPosition = event.position[0]; + touchDownPosition2 = event.position[1]; + + //pinchDistance = Vector2Distance(touchDownPosition, touchDownPosition2); + + pinchVector.x = touchDownPosition2.x - touchDownPosition.x; + pinchVector.y = touchDownPosition2.y - touchDownPosition.y; + + currentGesture = GESTURE_HOLD; + timeHold = GetCurrentTime(); + } + else if (event.touchAction == TOUCH_MOVE) + { + pinchDistance = Vector2Distance(moveDownPosition, moveDownPosition2); + + touchDownPosition = moveDownPosition; + touchDownPosition2 = moveDownPosition2; + + moveDownPosition = event.position[0]; + moveDownPosition2 = event.position[1]; + + pinchVector.x = moveDownPosition2.x - moveDownPosition.x; + pinchVector.y = moveDownPosition2.y - moveDownPosition.y; + + if ((Vector2Distance(touchDownPosition, moveDownPosition) >= MINIMUM_PINCH) || (Vector2Distance(touchDownPosition2, moveDownPosition2) >= MINIMUM_PINCH)) + { + if ((Vector2Distance(moveDownPosition, moveDownPosition2) - pinchDistance) < 0) currentGesture = GESTURE_PINCH_IN; + else currentGesture = GESTURE_PINCH_OUT; + } + else + { + currentGesture = GESTURE_HOLD; + timeHold = GetCurrentTime(); + } + + // NOTE: Angle should be inverted in Y + pinchAngle = 360.0f - Vector2Angle(moveDownPosition, moveDownPosition2); + } + else if (event.touchAction == TOUCH_UP) + { + pinchDistance = 0.0f; + pinchAngle = 0.0f; + pinchVector = (Vector2){ 0.0f, 0.0f }; + pointCount = 0; + + currentGesture = GESTURE_NONE; + } + } +} + +// Update gestures detected (must be called every frame) +void UpdateGestures(void) +{ + // NOTE: Gestures are processed through system callbacks on touch events + + // Detect GESTURE_HOLD + if (((currentGesture == GESTURE_TAP) || (currentGesture == GESTURE_DOUBLETAP)) && (pointCount < 2)) + { + currentGesture = GESTURE_HOLD; + timeHold = GetCurrentTime(); + } + + if (((GetCurrentTime() - eventTime) > TAP_TIMEOUT) && (currentGesture == GESTURE_DRAG) && (pointCount < 2)) + { + currentGesture = GESTURE_HOLD; + timeHold = GetCurrentTime(); + resetHold = true; + } + + // Detect GESTURE_NONE + if ((currentGesture == GESTURE_SWIPE_RIGHT) || (currentGesture == GESTURE_SWIPE_UP) || (currentGesture == GESTURE_SWIPE_LEFT) || (currentGesture == GESTURE_SWIPE_DOWN)) + { + currentGesture = GESTURE_NONE; + } +} + +// Get number of touch points +int GetTouchPointsCount(void) +{ + // NOTE: point count is calculated when ProcessGestureEvent(GestureEvent event) is called + + return pointCount; +} + +// Get latest detected gesture +int GetGestureDetected(void) +{ + // Get current gesture only if enabled + return (enabledGestures & currentGesture); +} + +// Hold time measured in ms +float GetGestureHoldDuration(void) +{ + // NOTE: time is calculated on current gesture HOLD + + float time = 0.0f; + + if (currentGesture == GESTURE_HOLD) time = (float)GetCurrentTime() - timeHold; + + return time; +} + +// Get drag vector (between initial touch point to current) +Vector2 GetGestureDragVector(void) +{ + // NOTE: drag vector is calculated on one touch points TOUCH_MOVE + + return dragVector; +} + +// Get drag angle +// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise +float GetGestureDragAngle(void) +{ + // NOTE: drag angle is calculated on one touch points TOUCH_UP + + return dragAngle; +} + +// Get distance between two pinch points +Vector2 GetGesturePinchVector(void) +{ + // NOTE: The position values used for pinchDistance are not modified like the position values of [core.c]-->GetTouchPosition(int index) + // NOTE: pinch distance is calculated on two touch points TOUCH_MOVE + + return pinchVector; +} + +// Get angle beween two pinch points +// NOTE: Angle in degrees, horizontal-right is 0, counterclock-wise +float GetGesturePinchAngle(void) +{ + // NOTE: pinch angle is calculated on two touch points TOUCH_MOVE + + return pinchAngle; +} + +//---------------------------------------------------------------------------------- +// Module specific Functions Definition +//---------------------------------------------------------------------------------- + +// Returns angle from two-points vector with X-axis +static float Vector2Angle(Vector2 initialPosition, Vector2 finalPosition) +{ + float angle; + + angle = atan2(finalPosition.y - initialPosition.y, finalPosition.x - initialPosition.x)*(180.0f/PI); + + if (angle < 0) angle += 360.0f; + + return angle; +} + +// Calculate distance between two Vector2 +static float Vector2Distance(Vector2 v1, Vector2 v2) +{ + float result; + + float dx = v2.x - v1.x; + float dy = v2.y - v1.y; + + result = sqrt(dx*dx + dy*dy); + + return result; +} + +// Time measure returned are milliseconds +static double GetCurrentTime(void) +{ + double time = 0; + +#if defined(_WIN32) + unsigned long long int clockFrequency, currentTime; + + QueryPerformanceFrequency(&clockFrequency); + QueryPerformanceCounter(¤tTime); + + time = (double)currentTime/clockFrequency*1000.0f; // Time in miliseconds +#endif + +#if defined(__linux) + // NOTE: Only for Linux-based systems + struct timespec now; + clock_gettime(CLOCK_MONOTONIC, &now); + uint64_t nowTime = (uint64_t)now.tv_sec*1000000000LLU + (uint64_t)now.tv_nsec; // Time in nanoseconds + + time = ((double)nowTime/1000000.0); // Time in miliseconds +#endif + + return time; +} + +#endif // GESTURES_IMPLEMENTATION diff --git a/src/raylib.h b/src/raylib.h index 104d5677..1489546a 100644 --- a/src/raylib.h +++ b/src/raylib.h @@ -570,18 +570,6 @@ typedef enum { GESTURE_PINCH_OUT = 512 } Gestures; -// Touch action (fingers or mouse) -typedef enum { TOUCH_UP, TOUCH_DOWN, TOUCH_MOVE } TouchAction; - -// Gesture events -// NOTE: MAX_TOUCH_POINTS fixed to 2 -typedef struct GestureEvent { - int touchAction; - int pointCount; - int pointerId[MAX_TOUCH_POINTS]; - Vector2 position[MAX_TOUCH_POINTS]; -} GestureEvent; - // Camera system modes typedef enum { CAMERA_CUSTOM = 0, CAMERA_FREE, CAMERA_ORBITAL, CAMERA_FIRST_PERSON, CAMERA_THIRD_PERSON } CameraMode; @@ -711,11 +699,8 @@ bool IsButtonReleased(int button); // Detect if an android //------------------------------------------------------------------------------------ void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags bool IsGestureDetected(int gesture); // Check if a gesture have been detected -void ProcessGestureEvent(GestureEvent event); // Process gesture event and translate it into gestures -void UpdateGestures(void); // Update gestures detected (called automatically in PollInputEvents()) - -int GetTouchPointsCount(void); // Get touch points count int GetGestureDetected(void); // Get latest detected gesture +int GetTouchPointsCount(void); // Get touch points count float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds Vector2 GetGestureDragVector(void); // Get gesture drag vector float GetGestureDragAngle(void); // Get gesture drag angle diff --git a/src/rlua.h b/src/rlua.h index 675edbfc..acd0d037 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -1313,12 +1313,6 @@ int lua_IsGestureDetected(lua_State* L) return 1; } -int lua_UpdateGestures(lua_State* L) -{ - UpdateGestures(); - return 0; -} - int lua_GetTouchPointsCount(lua_State* L) { int result = GetTouchPointsCount(); @@ -3576,10 +3570,8 @@ static luaL_Reg raylib_functions[] = { REG(SetGesturesEnabled) REG(IsGestureDetected) - //REG(ProcessGestureEvent) - REG(UpdateGestures) - REG(GetTouchPointsCount) REG(GetGestureDetected) + REG(GetTouchPointsCount) REG(GetGestureHoldDuration) REG(GetGestureDragVector) REG(GetGestureDragAngle) -- cgit v1.2.3 From 4960e6b6d7b4cba6125cfb8bb2fef043db8e5ba5 Mon Sep 17 00:00:00 2001 From: ghassanpl Date: Sat, 6 Aug 2016 16:58:48 +0200 Subject: Fixes for some Lua bugs --- examples/audio_module_playing.lua | 17 +- examples/core_3d_picking.lua | 4 +- examples/core_input_gamepad.lua | 2 +- examples/models_billboard.lua | 8 +- examples/models_box_collisions.lua | 8 +- examples/models_cubicmap.lua | 6 +- examples/models_heightmap.lua | 6 +- examples/models_obj_loading.lua | 4 +- examples/rlua_execute_file.c | 42 ++-- examples/shaders_custom_uniform.lua | 6 +- examples/shaders_model_shader.lua | 6 +- examples/shaders_postprocessing.lua | 8 +- examples/shaders_shapes_textures.lua | 2 +- examples/shaders_standard_lighting.lua | 38 ++-- examples/text_font_select.lua | 2 +- examples/text_rbmf_fonts.lua | 2 +- examples/text_writing_anim.lua | 2 +- examples/textures_particles_trail_blending.lua | 18 +- games/arkanoid.lua | 297 +++++++++++++++++++++++++ src/rlua.h | 38 +++- 20 files changed, 413 insertions(+), 103 deletions(-) create mode 100644 games/arkanoid.lua (limited to 'src/rlua.h') diff --git a/examples/audio_module_playing.lua b/examples/audio_module_playing.lua index c309c253..38cf9afe 100644 --- a/examples/audio_module_playing.lua +++ b/examples/audio_module_playing.lua @@ -11,6 +11,7 @@ MAX_CIRCLES = 64 +--[[ typedef struct { -- TODO: Find a Lua alternative: TABLES? Vector2 position float radius @@ -18,6 +19,7 @@ typedef struct { -- TODO: Find a Lua alternative: TABLES? float speed Color color } CircleWave +--]] -- Initialization ------------------------------------------------------------------------------------------- @@ -35,11 +37,13 @@ local colors = { ORANGE, RED, GOLD, LIME, BLUE, VIOLET, BROWN, LIGHTGRAY, PINK, local circles = {} for i = MAX_CIRCLES, 1, -1 do + circles[i] = {} circles[i].alpha = 0.0 circles[i].radius = GetRandomValue(10, 40) + circles[i].position = Vector2(0, 0) circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius) circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius) - circles[i].speed = (float)GetRandomValue(1, 100)/20000.0 + circles[i].speed = GetRandomValue(1, 100)/20000.0 circles[i].color = colors[GetRandomValue(1, 14)] end @@ -64,8 +68,8 @@ while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- for i = MAX_CIRCLES, 1, -1 do - circles[i].alpha += circles[i].speed - circles[i].radius += circles[i].speed*10.0 + circles[i].alpha = circles[i].alpha + circles[i].speed + circles[i].radius = circles[i].radius + circles[i].speed*10.0 if (circles[i].alpha > 1.0) then circles[i].speed = circles[i].speed*-1 end @@ -75,7 +79,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key circles[i].position.x = GetRandomValue(circles[i].radius, screenWidth - circles[i].radius) circles[i].position.y = GetRandomValue(circles[i].radius, screenHeight - circles[i].radius) circles[i].color = colors[GetRandomValue(0, 13)] - circles[i].speed = (float)GetRandomValue(1, 100)/20000.0 + circles[i].speed = GetRandomValue(1, 100)/20000.0 end end @@ -108,7 +112,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key -- Draw time bar DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, LIGHTGRAY) - DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, MAROON) + DrawRectangle(20, screenHeight - 20 - 12, timePlayed, 12, MAROON) DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, WHITE) EndDrawing() @@ -126,6 +130,3 @@ CloseAudioDevice() -- Close audio device (music streaming is automatically s CloseWindow() -- Close window and OpenGL context ------------------------------------------------------------------------------------------- - -return 0 -} \ No newline at end of file diff --git a/examples/core_3d_picking.lua b/examples/core_3d_picking.lua index f3f28530..2e1dc7c4 100644 --- a/examples/core_3d_picking.lua +++ b/examples/core_3d_picking.lua @@ -49,8 +49,8 @@ while not WindowShouldClose() do -- Detect window close button or ESC -- Check collision between ray and box collision = CheckCollisionRayBox(ray, - (BoundingBox){(Vector3){ cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2 }, - (Vector3){ cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2 }}) + (BoundingBox)((Vector3)(cubePosition.x - cubeSize.x/2, cubePosition.y - cubeSize.y/2, cubePosition.z - cubeSize.z/2), + (Vector3)(cubePosition.x + cubeSize.x/2, cubePosition.y + cubeSize.y/2, cubePosition.z + cubeSize.z/2))) end --------------------------------------------------------------------------------------- diff --git a/examples/core_input_gamepad.lua b/examples/core_input_gamepad.lua index eea2532c..78d9b84e 100644 --- a/examples/core_input_gamepad.lua +++ b/examples/core_input_gamepad.lua @@ -36,7 +36,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key ballPosition.x = ballPosition.x + gamepadMovement.x ballPosition.y = ballPosition.y - gamepadMovement.y - if (IsGamepadButtonPressed(GAMEPAD_PLAYER1, GAMEPAD_BUTTON_A)) then + if (IsGamepadButtonPressed(GAMEPAD.PLAYER1, GAMEPAD.BUTTON_A)) then ballPosition.x = screenWidth/2 ballPosition.y = screenHeight/2 end diff --git a/examples/models_billboard.lua b/examples/models_billboard.lua index 22f3a6c3..25b00510 100644 --- a/examples/models_billboard.lua +++ b/examples/models_billboard.lua @@ -22,7 +22,7 @@ local camera = Camera(Vector3(5.0, 4.0, 5.0), Vector3(0.0, 2.0, 0.0), Vector3(0. local bill = LoadTexture("resources/billboard.png") -- Our texture billboard local billPosition = Vector3(0.0, 2.0, 0.0) -- Position where draw billboard -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our camera position SetCameraTarget(camera.target) -- Set internal camera target to match our camera target SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y @@ -34,7 +34,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-per-secon while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw @@ -45,9 +45,9 @@ while not WindowShouldClose() do -- Detect window close button or ESC Begin3dMode(camera) - DrawBillboard(camera, bill, billPosition, 2.0f, WHITE) + DrawBillboard(camera, bill, billPosition, 2.0, WHITE) - DrawGrid(10, 1.0f) -- Draw a grid + DrawGrid(10, 1.0) -- Draw a grid End3dMode() diff --git a/examples/models_box_collisions.lua b/examples/models_box_collisions.lua index f2cbb154..d8b2e4b5 100644 --- a/examples/models_box_collisions.lua +++ b/examples/models_box_collisions.lua @@ -40,10 +40,10 @@ while not WindowShouldClose() do -- Detect window close button or ESC --------------------------------------------------------------------------------------- -- Move player - if (IsKeyDown(KEY.RIGHT)) then playerPosition.x = playerPosition.x + 0.2f end - elseif (IsKeyDown(KEY.LEFT)) then playerPosition.x = playerPosition.x - 0.2f end - elseif (IsKeyDown(KEY.DOWN)) then playerPosition.z = playerPosition.z + 0.2f end - elseif (IsKeyDown(KEY.UP)) then playerPosition.z = playerPosition.z - 0.2f end + if (IsKeyDown(KEY.RIGHT)) then playerPosition.x = playerPosition.x + 0.2 + elseif (IsKeyDown(KEY.LEFT)) then playerPosition.x = playerPosition.x - 0.2 + elseif (IsKeyDown(KEY.DOWN)) then playerPosition.z = playerPosition.z + 0.2 + elseif (IsKeyDown(KEY.UP)) then playerPosition.z = playerPosition.z - 0.2 end collision = false diff --git a/examples/models_cubicmap.lua b/examples/models_cubicmap.lua index 293f1b3a..53cb2c12 100644 --- a/examples/models_cubicmap.lua +++ b/examples/models_cubicmap.lua @@ -31,7 +31,7 @@ local mapPosition = Vector3(-16.0, 0.0, -8.0) -- Set model position UnloadImage(image) -- Unload cubesmap image from RAM, already uploaded to VRAM -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position SetCameraFovy(camera.fovy) -- Set internal camera field-of-view Y @@ -42,7 +42,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-per-secon while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw @@ -57,7 +57,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC End3dMode() - DrawTextureEx(cubicmap, (Vector2){ screenWidth - cubicmap.width*4 - 20, 20 }, 0.0, 4.0, WHITE) + DrawTextureEx(cubicmap, (Vector2)(screenWidth - cubicmap.width*4 - 20, 20), 0.0, 4.0, WHITE) DrawRectangleLines(screenWidth - cubicmap.width*4 - 20, 20, cubicmap.width*4, cubicmap.height*4, GREEN) DrawText("cubicmap image used to", 658, 90, 10, GRAY) diff --git a/examples/models_heightmap.lua b/examples/models_heightmap.lua index f78e3af5..6d7f6f3f 100644 --- a/examples/models_heightmap.lua +++ b/examples/models_heightmap.lua @@ -21,13 +21,13 @@ local camera = Camera(Vector3(18.0, 16.0, 18.0), Vector3(0.0, 0.0, 0.0), Vector3 local image = LoadImage("resources/heightmap.png") -- Load heightmap image (RAM) local texture = LoadTextureFromImage(image) -- Convert image to texture (VRAM) -local map = LoadHeightmap(image, Vector3(16, 8, 16) -- Load heightmap model with defined size +local map = LoadHeightmap(image, Vector3(16, 8, 16)) -- Load heightmap model with defined size map.material.texDiffuse = texture -- Set map diffuse texture local mapPosition = Vector3(-8.0, 0.0, -8.0) -- Set model position (depends on model scaling!) UnloadImage(image) -- Unload heightmap image from RAM, already uploaded to VRAM -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our custom camera position SetTargetFPS(60) -- Set our game to run at 60 frames-per-second @@ -37,7 +37,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-per-secon while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw diff --git a/examples/models_obj_loading.lua b/examples/models_obj_loading.lua index c534ecae..7e5c7c4b 100644 --- a/examples/models_obj_loading.lua +++ b/examples/models_obj_loading.lua @@ -42,9 +42,9 @@ while not WindowShouldClose() do -- Detect window close button or ESC Begin3dMode(camera) - DrawModel(dwarf, position, 2.0f, WHITE) -- Draw 3d model with texture + DrawModel(dwarf, position, 2.0, WHITE) -- Draw 3d model with texture - DrawGrid(10, 1.0f) -- Draw a grid + DrawGrid(10, 1.0) -- Draw a grid DrawGizmo(position) -- Draw gizmo diff --git a/examples/rlua_execute_file.c b/examples/rlua_execute_file.c index 762159f3..5c2d8654 100644 --- a/examples/rlua_execute_file.c +++ b/examples/rlua_execute_file.c @@ -29,8 +29,8 @@ int main() //-------------------------------------------------------------------------------------- // ExecuteLuaFile("core_basic_window.lua"); // OK! - // ExecuteLuaFile("core_input_keys.lua"); // OK! - // ExecuteLuaFile("core_input_mouse.lua"); // OK! + // ExecuteLuaFile("core_input_keys.lua"); // OK! + // ExecuteLuaFile("core_input_mouse.lua"); // OK! // ExecuteLuaFile("core_mouse_wheel.lua"); // OK! // ExecuteLuaFile("core_input_gamepad.lua"); // OK! // ExecuteLuaFile("core_random_values.lua"); // OK! @@ -55,31 +55,31 @@ int main() // ExecuteLuaFile("textures_srcrec_dstrec.lua"); // OK! // ExecuteLuaFile("textures_to_image.lua"); // OK! // ExecuteLuaFile("textures_raw_data.lua"); // ERROR: Lua Error: attempt to index a number value - // ExecuteLuaFile("textures_formats_loading.lua"); // ISSUE: texture.id not exposed to be checked - // ExecuteLuaFile("textures_particles_trail_blending.lua"); // ERROR: Using struct - // ExecuteLuaFile("textures_image_processing.lua"); // ERROR: GetImageData() --> UpdateTexture() - // ExecuteLuaFile("textures_image_drawing.lua"); // OK! - // ExecuteLuaFile("text_sprite_fonts.lua"); // OK! - // ExecuteLuaFile("text_bmfont_ttf.lua"); // OK! - // ExecuteLuaFile("text_rbmf_fonts.lua"); // ERROR: Lua Error: attempt to index a nil value - // ExecuteLuaFile("text_format_text.lua"); // OK! NOTE: Use lua string.format() instead of raylib FormatText() - // ExecuteLuaFile("text_font_select.lua"); // OK! - // ExecuteLuaFile("text_writing_anim.lua"); // ERROR: SubText() - // ExecuteLuaFile("models_geometric_shapes.lua"); // ERROR: Lua Error: attempt to index a number value - Begin3dMode(camera) - // ExecuteLuaFile("models_box_collisions.lua"); // - // ExecuteLuaFile("models_billboard.lua"); // - // ExecuteLuaFile("models_obj_loading.lua"); // - // ExecuteLuaFile("models_heightmap.lua"); // + // ExecuteLuaFile("textures_formats_loading.lua"); // ISSUE: texture.id not exposed to be checked + // ExecuteLuaFile("textures_particles_trail_blending.lua"); // ERROR: Using struct + // ExecuteLuaFile("textures_image_processing.lua"); // ERROR: GetImageData() --> UpdateTexture() + // ExecuteLuaFile("textures_image_drawing.lua"); // OK! + // ExecuteLuaFile("text_sprite_fonts.lua"); // OK! + // ExecuteLuaFile("text_bmfont_ttf.lua"); // OK! + // ExecuteLuaFile("text_rbmf_fonts.lua"); // ERROR: Lua Error: attempt to index a nil value + // ExecuteLuaFile("text_format_text.lua"); // OK! NOTE: Use lua string.format() instead of raylib FormatText() + // ExecuteLuaFile("text_font_select.lua"); // OK! + // ExecuteLuaFile("text_writing_anim.lua"); // ERROR: SubText() + // ExecuteLuaFile("models_geometric_shapes.lua"); // ERROR: Lua Error: attempt to index a number value - Begin3dMode(camera) + // ExecuteLuaFile("models_box_collisions.lua"); // + // ExecuteLuaFile("models_billboard.lua"); // + // ExecuteLuaFile("models_obj_loading.lua"); // + // ExecuteLuaFile("models_heightmap.lua"); // // ExecuteLuaFile("models_cubicmap.lua"); // - // ExecuteLuaFile("shaders_model_shader.lua"); // - // ExecuteLuaFile("shaders_shapes_textures.lua"); // + // ExecuteLuaFile("shaders_model_shader.lua"); // + // ExecuteLuaFile("shaders_shapes_textures.lua"); // // ExecuteLuaFile("shaders_custom_uniform.lua"); // // ExecuteLuaFile("shaders_postprocessing.lua"); // // ExecuteLuaFile("shaders_standard_lighting.lua"); // // ExecuteLuaFile("audio_sound_loading.lua"); // OK! // ExecuteLuaFile("audio_music_stream.lua"); // OK! - // ExecuteLuaFile("audio_module_playing.lua"); // ERROR: Using struct - // ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream() + ExecuteLuaFile("audio_module_playing.lua"); // ERROR: Using struct + ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream() // De-Initialization //-------------------------------------------------------------------------------------- diff --git a/examples/shaders_custom_uniform.lua b/examples/shaders_custom_uniform.lua index dbb672e6..b4e4d483 100644 --- a/examples/shaders_custom_uniform.lua +++ b/examples/shaders_custom_uniform.lua @@ -26,7 +26,7 @@ SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x InitWindow(screenWidth, screenHeight, "raylib [shaders] example - custom uniform variable") -- Define the camera to look into our 3d world -local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map) @@ -47,7 +47,7 @@ local swirlCenter = { screenWidth/2, screenHeight/2 } local target = LoadRenderTexture(screenWidth, screenHeight) -- Setup orbital camera -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our camera position SetCameraTarget(camera.target) -- Set internal camera target to match our camera target @@ -66,7 +66,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key -- Send new value to the shader to be used on drawing SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2) - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw diff --git a/examples/shaders_model_shader.lua b/examples/shaders_model_shader.lua index deaca11c..b31c8609 100644 --- a/examples/shaders_model_shader.lua +++ b/examples/shaders_model_shader.lua @@ -26,7 +26,7 @@ SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader") -- Define the camera to look into our 3d world -local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture @@ -39,7 +39,7 @@ dwarf.material.texDiffuse = texture -- Bind texture to model local position = Vector3(0.0, 0.0, 0.0) -- Set model position -- Setup orbital camera -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our camera position SetCameraTarget(camera.target) -- Set internal camera target to match our camera target @@ -50,7 +50,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-pe while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw diff --git a/examples/shaders_postprocessing.lua b/examples/shaders_postprocessing.lua index 9e4dfa00..0913fbbd 100644 --- a/examples/shaders_postprocessing.lua +++ b/examples/shaders_postprocessing.lua @@ -26,7 +26,7 @@ SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x InitWindow(screenWidth, screenHeight, "raylib [shaders] example - postprocessing shader") -- Define the camera to look into our 3d world -local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) +local camera = Camera(Vector3(3.0, 3.0, 3.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model local texture = LoadTexture("resources/model/dwarf_diffuse.png") -- Load model texture (diffuse map) @@ -41,7 +41,7 @@ local shader = LoadShader("resources/shaders/glsl330/base.vs", local target = LoadRenderTexture(screenWidth, screenHeight) -- Setup orbital camera -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our camera position SetCameraTarget(camera.target) -- Set internal camera target to match our camera target @@ -52,7 +52,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-per-s while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw @@ -88,7 +88,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key EndDrawing() --------------------------------------------------------------------------------------- -} +end -- De-Initialization ------------------------------------------------------------------------------------------- diff --git a/examples/shaders_shapes_textures.lua b/examples/shaders_shapes_textures.lua index 0adbefd2..caaeba1a 100644 --- a/examples/shaders_shapes_textures.lua +++ b/examples/shaders_shapes_textures.lua @@ -90,7 +90,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key EndDrawing() --------------------------------------------------------------------------------------- -} +end -- De-Initialization ------------------------------------------------------------------------------------------- diff --git a/examples/shaders_standard_lighting.lua b/examples/shaders_standard_lighting.lua index e8171a5f..7c354d54 100644 --- a/examples/shaders_standard_lighting.lua +++ b/examples/shaders_standard_lighting.lua @@ -26,7 +26,7 @@ SetConfigFlags(FLAG.MSAA_4X_HINT) -- Enable Multi Sampling Anti Aliasing 4x InitWindow(screenWidth, screenHeight, "raylib [shaders] example - model shader") -- Define the camera to look into our 3d world -local camera = Camera(Vector3(4.0, 4.0, 4.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0)) +local camera = Camera(Vector3(4.0, 4.0, 4.0), Vector3(0.0, 1.5, 0.0), Vector3(0.0, 1.0, 0.0), 45.0) local position = Vector3(0.0, 0.0, 0.0) -- Set model position local dwarf = LoadModel("resources/model/dwarf.obj") -- Load OBJ model @@ -37,30 +37,30 @@ material.texDiffuse = LoadTexture("resources/model/dwarf_diffuse.png") -- Load material.texNormal = LoadTexture("resources/model/dwarf_normal.png") -- Load model normal texture material.texSpecular = LoadTexture("resources/model/dwarf_specular.png") -- Load model specular texture material.colDiffuse = WHITE -material.colAmbient = (Color){0, 0, 10, 255} +material.colAmbient = (Color)(0, 0, 10, 255) material.colSpecular = WHITE -material.glossiness = 50.0f +material.glossiness = 50.0 dwarf.material = material -- Apply material to model -local spotLight = CreateLight(LIGHT_SPOT, (Vector3){3.0f, 5.0f, 2.0f}, (Color){255, 255, 255, 255}) -spotLight->target = (Vector3){0.0f, 0.0f, 0.0f} -spotLight->intensity = 2.0f -spotLight->diffuse = (Color){255, 100, 100, 255} -spotLight->coneAngle = 60.0f +local spotLight = CreateLight(LIGHT_SPOT, (Vector3)(3.0, 5.0, 2.0), (Color)(255, 255, 255, 255)) +spotLight.target = (Vector3)(0.0, 0.0, 0.0) +spotLight.intensity = 2.0 +spotLight.diffuse = (Color)(255, 100, 100, 255) +spotLight.coneAngle = 60.0 -local dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3){0.0f, -3.0f, -3.0f}, (Color){255, 255, 255, 255}) -dirLight->target = (Vector3){1.0f, -2.0f, -2.0f} -dirLight->intensity = 2.0f -dirLight->diffuse = (Color){100, 255, 100, 255} +local dirLight = CreateLight(LIGHT_DIRECTIONAL, (Vector3)(0.0, -3.0, -3.0), (Color)(255, 255, 255, 255)) +dirLight.target = (Vector3)(1.0, -2.0, -2.0) +dirLight.intensity = 2.0 +dirLight.diffuse = (Color)(100, 255, 100, 255) -local pointLight = CreateLight(LIGHT_POINT, (Vector3){0.0f, 4.0f, 5.0f}, (Color){255, 255, 255, 255}) -pointLight->intensity = 2.0f -pointLight->diffuse = (Color){100, 100, 255, 255} -pointLight->radius = 3.0f +local pointLight = CreateLight(LIGHT_POINT, (Vector3)(0.0, 4.0, 5.0), (Color)(255, 255, 255, 255)) +pointLight.intensity = 2.0 +pointLight.diffuse = (Color)(100, 100, 255, 255) +pointLight.radius = 3.0 -- Setup orbital camera -SetCameraMode(CAMERA.ORBITAL) -- Set an orbital camera mode +SetCameraMode(CameraMode.ORBITAL) -- Set an orbital camera mode SetCameraPosition(camera.position) -- Set internal camera position to match our camera position SetCameraTarget(camera.target) -- Set internal camera target to match our camera target @@ -71,7 +71,7 @@ SetTargetFPS(60) -- Set our game to run at 60 frames-per-s while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - UpdateCamera(&camera) -- Update internal camera and our camera + UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- -- Draw @@ -98,7 +98,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC key EndDrawing() --------------------------------------------------------------------------------------- -} +end -- De-Initialization ------------------------------------------------------------------------------------------- diff --git a/examples/text_font_select.lua b/examples/text_font_select.lua index e04f6024..f6cea881 100644 --- a/examples/text_font_select.lua +++ b/examples/text_font_select.lua @@ -87,7 +87,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC btnNextInColor = PURPLE end - if (IsMouseButtonDown(MOUSE_LEFT_BUTTON)) then + if (IsMouseButtonDown(MOUSE.LEFT_BUTTON)) then framesCounter = 20 -- Frames button is 'active' btnNextOutColor = MAROON btnNextInColor = RED diff --git a/examples/text_rbmf_fonts.lua b/examples/text_rbmf_fonts.lua index d89e4071..0e0e4142 100644 --- a/examples/text_rbmf_fonts.lua +++ b/examples/text_rbmf_fonts.lua @@ -50,7 +50,7 @@ for i = 1, 8 do positions[i].y = 60 + fonts[i].size + 50*i end -local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD } +local colors = { MAROON, ORANGE, DARKGREEN, DARKBLUE, DARKPURPLE, LIME, GOLD, BLACK } SetTargetFPS(60) -- Set target frames-per-second ------------------------------------------------------------------------------------------- diff --git a/examples/text_writing_anim.lua b/examples/text_writing_anim.lua index 37f1efba..05195dc4 100644 --- a/examples/text_writing_anim.lua +++ b/examples/text_writing_anim.lua @@ -38,7 +38,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC ClearBackground(RAYWHITE) - DrawText(SubText(message, 0, framesCounter/10), 210, 160, 20, MAROON) + DrawText(string.sub(message, 0, framesCounter/10), 210, 160, 20, MAROON) DrawText("PRESS [ENTER] to RESTART!", 240, 280, 20, LIGHTGRAY) diff --git a/examples/textures_particles_trail_blending.lua b/examples/textures_particles_trail_blending.lua index d5ba7841..38036bcf 100644 --- a/examples/textures_particles_trail_blending.lua +++ b/examples/textures_particles_trail_blending.lua @@ -12,15 +12,6 @@ MAX_PARTICLES = 200 -- Particle structure with basic data -struct.Particle { - position, - color, - alpha, - size, - rotation, - active -- NOTE: Use it to activate/deactive particle -} - -- Initialization ------------------------------------------------------------------------------------------- local screenWidth = 800 @@ -33,6 +24,7 @@ local mouseTail = {} -- Initialize particles for i = 1, MAX_PARTICLES do + mouseTail[i] = {} mouseTail[i].position = Vector2(0, 0) mouseTail[i].color = Color(GetRandomValue(0, 255), GetRandomValue(0, 255), GetRandomValue(0, 255), 255) mouseTail[i].alpha = 1.0 @@ -45,7 +37,7 @@ local gravity = 3.0 local smoke = LoadTexture("resources/smoke.png") -local blending = BLEND.ALPHA +local blending = BlendMode.ALPHA SetTargetFPS(60) ------------------------------------------------------------------------------------------- @@ -80,8 +72,8 @@ while not WindowShouldClose() do -- Detect window close button or ESC end if (IsKeyPressed(KEY.SPACE)) then - if (blending == BLEND.ALPHA) then blending = BLEND_ADDITIVE - else blending = BLEND.ALPHA end + if (blending == BlendMode.ALPHA) then blending = BlendMode.ADDITIVE + else blending = BlendMode.ALPHA end end --------------------------------------------------------------------------------------- @@ -107,7 +99,7 @@ while not WindowShouldClose() do -- Detect window close button or ESC DrawText("PRESS SPACE to CHANGE BLENDING MODE", 180, 20, 20, BLACK) - if (blending == BLEND_ALPHA) then DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK) + if (blending == BlendMode.ALPHA) then DrawText("ALPHA BLENDING", 290, screenHeight - 40, 20, BLACK) else DrawText("ADDITIVE BLENDING", 280, screenHeight - 40, 20, RAYWHITE) end EndDrawing() diff --git a/games/arkanoid.lua b/games/arkanoid.lua new file mode 100644 index 00000000..2dc59247 --- /dev/null +++ b/games/arkanoid.lua @@ -0,0 +1,297 @@ +--[[ + + raylib - sample game: arkanoid + + Sample game Marc Palau and Ramon Santamaria + + This game has been created using raylib v1.3 (www.raylib.com) + raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details) + + Copyright (c) 2015 Ramon Santamaria (@raysan5) + + Translated to Lua by Ghassan Al-Mashareqa (ghassan@ghassan.pl) + +--]] + +------------------------------------------------------------------------------------ +-- Some Defines +------------------------------------------------------------------------------------ +PLAYER_MAX_LIFE = 5 +LINES_OF_BRICKS = 5 +BRICKS_PER_LINE = 20 + +------------------------------------------------------------------------------------ +-- Types and Structures Definition +------------------------------------------------------------------------------------ + +GameScreen = { LOGO = 0, TITLE = 1, GAMEPLAY = 2, ENDING = 3 } + +function Player() + return { position = Vector2(0,0), size = Vector2(0,0), life = 0 } +end + +function Ball() + return { position = Vector2(0,0), speed = Vector2(0,0), radius = 0, active = false } +end + +function Brick() + return { position = Vector2(0,0), active = false } +end + +-------------------------------------------------------------------------------------- +-- Global Variables Declaration +-------------------------------------------------------------------------------------- +screenWidth = 800; +screenHeight = 450; + +framesCounter = 0; +gameOver = false; +pause = false; + +player = Player() +ball = Ball() +brick = {}--[LINES_OF_BRICKS][BRICKS_PER_LINE]; +for i = 0, LINES_OF_BRICKS-1 do + brick[i] = {} + for j = 0, BRICKS_PER_LINE-1 do + brick[i][j] = Brick() + end +end +brickSize = Vector2(0,0) + + +-------------------------------------------------------------------------------------- +-- Module Functions Definitions (local) +-------------------------------------------------------------------------------------- + +-- Initialize game variables +function InitGame() + + brickSize = Vector2(GetScreenWidth()/BRICKS_PER_LINE, 40) + + -- Initialize player + player.position = Vector2(screenWidth/2, screenHeight*7/8) + player.size = Vector2(screenWidth/10, 20) + player.life = PLAYER_MAX_LIFE; + + -- Initialize ball + ball.position = Vector2(screenWidth/2, screenHeight*7/8 - 30) + ball.speed = Vector2(0, 0) + ball.radius = 7; + ball.active = false; + + -- Initialize bricks + local initialDownPosition = 50; + + for i = 0, LINES_OF_BRICKS-1 do + for j = 0, BRICKS_PER_LINE-1 do + brick[i][j].position = Vector2(j*brickSize.x + brickSize.x/2, i*brickSize.y + initialDownPosition) + brick[i][j].active = true; + end + end +end + +-- Update game (one frame) +function UpdateGame() + + if (not gameOver) then + if (IsKeyPressed(KEY.P)) then pause = not pause; end + + if (not pause) then + -- Player movement + if (IsKeyDown(KEY.LEFT)) then player.position.x = player.position.x - 5; end + if ((player.position.x - player.size.x/2) <= 0) then player.position.x = player.size.x/2; end + if (IsKeyDown(KEY.RIGHT)) then player.position.x = player.position.x + 5; end + if ((player.position.x + player.size.x/2) >= screenWidth) then player.position.x = screenWidth - player.size.x/2; end + + -- Launch ball + if (not ball.active) then + if (IsKeyPressed(KEY.SPACE)) then + ball.active = true; + ball.speed = Vector2(0, -5) + end + end + + UpdateBall(); + + -- Game over logic + if (player.life <= 0) then + gameOver = true; + else + gameOver = true; + + for i = 0, LINES_OF_BRICKS-1 do + for j = 0, BRICKS_PER_LINE-1 do + if (brick[i][j].active) then gameOver = false; end + end + end + end + end + else + if (IsKeyPressed(KEY.ENTER)) then + InitGame(); + gameOver = false; + end + end + +end + +-- Draw game (one frame) +function DrawGame() + + BeginDrawing(); + + ClearBackground(RAYWHITE); + + if (not gameOver) then + -- Draw player bar + DrawRectangle(player.position.x - player.size.x/2, player.position.y - player.size.y/2, player.size.x, player.size.y, BLACK); + + -- Draw player lives + for i = 0, player.life-1 do + DrawRectangle(20 + 40*i, screenHeight - 30, 35, 10, LIGHTGRAY); + end + + -- Draw ball + DrawCircleV(ball.position, ball.radius, MAROON); + + -- Draw bricks + for i = 0, LINES_OF_BRICKS-1 do + for j = 0, BRICKS_PER_LINE-1 do + if (brick[i][j].active) then + if ((i + j) % 2 == 0) then + DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, GRAY); + else + DrawRectangle(brick[i][j].position.x - brickSize.x/2, brick[i][j].position.y - brickSize.y/2, brickSize.x, brickSize.y, DARKGRAY); + end + end + end + end + + if (pause) then + DrawText("GAME PAUSED", screenWidth/2 - MeasureText("GAME PAUSED", 40)/2, screenHeight/2 - 40, 40, GRAY); + end + else + DrawText("PRESS [ENTER] TO PLAY AGAIN", GetScreenWidth()/2 - MeasureText("PRESS [ENTER] TO PLAY AGAIN", 20)/2, GetScreenHeight()/2 - 50, 20, GRAY); + end + + EndDrawing(); +end + +-- Unload game variables +function UnloadGame() + -- TODO: Unload all dynamic loaded data (textures, sounds, models...) +end + +-- Update and Draw (one frame) +function UpdateDrawFrame() + UpdateGame(); + DrawGame(); +end + +---------------------------------------------------------------------------------------- +-- Additional module functions +---------------------------------------------------------------------------------------- +function UpdateBall() + -- Update position + if (ball.active) then + ball.position.x = ball.position.x + ball.speed.x; + ball.position.y = ball.position.y + ball.speed.y; + else + ball.position = Vector2(player.position.x, screenHeight*7/8 - 30); + end + + -- Bounce in x + if (((ball.position.x + ball.radius) >= screenWidth) or ((ball.position.x - ball.radius) <= 0)) + then + ball.speed.x = ball.speed.x * -1; + end + + -- Bounce in y + if ((ball.position.y - ball.radius) <= 0) then + ball.speed.y = ball.speed.y * -1; + end + + -- Ball reaches bottom of the screen + if ((ball.position.y + ball.radius) >= screenHeight) then + ball.speed = Vector2(0, 0); + ball.active = false; + + player.life = player.life - 1; + end + + -- Collision logic: ball vs player + if CheckCollisionCircleRec(ball.position, ball.radius, + Rectangle( + player.position.x - player.size.x/2, + player.position.y - player.size.y/2, + player.size.x, + player.size.y)) then + if (ball.speed.y > 0) then + ball.speed.y = ball.speed.y * -1; + ball.speed.x = (ball.position.x - player.position.x)/(player.size.x/2)*5; + end + end + + -- Collision logic: ball vs bricks + for i = 0,LINES_OF_BRICKS-1 do + for j = 0,BRICKS_PER_LINE-1 do + if (brick[i][j].active) then + -- Hit below + if (((ball.position.y - ball.radius) <= (brick[i][j].position.y + brickSize.y/2)) and + ((ball.position.y - ball.radius) > (brick[i][j].position.y + brickSize.y/2 + ball.speed.y)) and + ((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y < 0)) + then + brick[i][j].active = false; + ball.speed.y = ball.speed.y * -1; + -- Hit above + elseif (((ball.position.y + ball.radius) >= (brick[i][j].position.y - brickSize.y/2)) and + ((ball.position.y + ball.radius) < (brick[i][j].position.y - brickSize.y/2 + ball.speed.y)) and + ((math.abs(ball.position.x - brick[i][j].position.x)) < (brickSize.x/2 + ball.radius*2/3)) and (ball.speed.y > 0)) + then + brick[i][j].active = false; + ball.speed.y = ball.speed.y * -1; + -- Hit left + elseif (((ball.position.x + ball.radius) >= (brick[i][j].position.x - brickSize.x/2)) and + ((ball.position.x + ball.radius) < (brick[i][j].position.x - brickSize.x/2 + ball.speed.x)) and + ((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x > 0)) + then + brick[i][j].active = false; + ball.speed.x = ball.speed.x * -1; + -- Hit right + elseif (((ball.position.x - ball.radius) <= (brick[i][j].position.x + brickSize.x/2)) and + ((ball.position.x - ball.radius) > (brick[i][j].position.x + brickSize.x/2 + ball.speed.x)) and + ((math.abs(ball.position.y - brick[i][j].position.y)) < (brickSize.y/2 + ball.radius*2/3)) and (ball.speed.x < 0)) + then + brick[i][j].active = false; + ball.speed.x = ball.speed.x * -1; + end + end + end + end +end + +InitWindow(screenWidth, screenHeight, "sample game: arkanoid"); + +InitGame(); + +SetTargetFPS(60); +---------------------------------------------------------------------------------------- + +-- Main game loop +while (not WindowShouldClose()) -- Detect window close button or ESC key +do + -- Update + ------------------------------------------------------------------------------------ + UpdateGame(); + ------------------------------------------------------------------------------------ + + -- Draw + ------------------------------------------------------------------------------------ + DrawGame(); + ------------------------------------------------------------------------------------ +end + +UnloadGame(); -- Unload loaded data (textures, sounds, models...) + +CloseWindow(); -- Close window and OpenGL context diff --git a/src/rlua.h b/src/rlua.h index 675edbfc..ee7766ab 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -325,6 +325,7 @@ static void LuaBuildOpaqueMetatables(void) static Vector2 LuaGetArgument_Vector2(lua_State* L, int index) { + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2"); float x = (float)lua_tonumber(L, -1); luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2"); @@ -335,6 +336,7 @@ static Vector2 LuaGetArgument_Vector2(lua_State* L, int index) static Vector3 LuaGetArgument_Vector3(lua_State* L, int index) { + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3"); float x = (float)lua_tonumber(L, -1); luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3"); @@ -347,6 +349,7 @@ static Vector3 LuaGetArgument_Vector3(lua_State* L, int index) static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index) { + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion"); float x = (float)lua_tonumber(L, -1); luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion"); @@ -361,6 +364,7 @@ static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index) static Color LuaGetArgument_Color(lua_State* L, int index) { + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color"); unsigned char r = (unsigned char)lua_tointeger(L, -1); luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color"); @@ -375,6 +379,7 @@ static Color LuaGetArgument_Color(lua_State* L, int index) static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index) { + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle"); int x = (int)lua_tointeger(L, -1); luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle"); @@ -390,13 +395,14 @@ static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index) static Camera LuaGetArgument_Camera(lua_State* L, int index) { Camera result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera"); result.position = LuaGetArgument_Vector3(L, -1); luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera"); result.target = LuaGetArgument_Vector3(L, -1); luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera"); result.up = LuaGetArgument_Vector3(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "fovy") == LUA_TTABLE, index, "Expected Camera"); + luaL_argcheck(L, lua_getfield(L, index, "fovy") == LUA_TNUMBER, index, "Expected Camera"); result.fovy = LuaGetArgument_float(L, -1); lua_pop(L, 4); return result; @@ -405,13 +411,14 @@ static Camera LuaGetArgument_Camera(lua_State* L, int index) static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) { Camera2D result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D"); result.offset = LuaGetArgument_Vector2(L, -1); luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D"); result.target = LuaGetArgument_Vector2(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TTABLE, index, "Expected Camera2D"); + luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TNUMBER, index, "Expected Camera2D"); result.rotation = LuaGetArgument_float(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TTABLE, index, "Expected Camera2D"); + luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TNUMBER, index, "Expected Camera2D"); result.zoom = LuaGetArgument_float(L, -1); lua_pop(L, 4); return result; @@ -420,6 +427,7 @@ static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) { BoundingBox result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox"); result.min = LuaGetArgument_Vector3(L, -1); luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox"); @@ -431,6 +439,7 @@ static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) static Ray LuaGetArgument_Ray(lua_State* L, int index) { Ray result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray"); result.position = LuaGetArgument_Vector3(L, -1); luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray"); @@ -443,10 +452,12 @@ static Matrix LuaGetArgument_Matrix(lua_State* L, int index) { Matrix result = { 0 }; float* ptr = &result.m0; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + for (int i = 0; i < 16; i++) { - lua_geti(L, -1, i+1); - ptr[i] = luaL_checkinteger(L, -1); + lua_geti(L, index, i+1); + ptr[i] = luaL_checknumber(L, -1); } lua_pop(L, 16); return result; @@ -455,6 +466,7 @@ static Matrix LuaGetArgument_Matrix(lua_State* L, int index) static Material LuaGetArgument_Material(lua_State* L, int index) { Material result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "shader") == LUA_TUSERDATA, index, "Expected Material"); result.shader = LuaGetArgument_Shader(L, -1); luaL_argcheck(L, lua_getfield(L, index, "texDiffuse") == LUA_TUSERDATA, index, "Expected Material"); @@ -463,13 +475,13 @@ static Material LuaGetArgument_Material(lua_State* L, int index) result.texNormal = LuaGetArgument_Texture2D(L, -1); luaL_argcheck(L, lua_getfield(L, index, "texSpecular") == LUA_TUSERDATA, index, "Expected Material"); result.texSpecular = LuaGetArgument_Texture2D(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TUSERDATA, index, "Expected Material"); + luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TTABLE, index, "Expected Material"); result.colDiffuse = LuaGetArgument_Color(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TUSERDATA, index, "Expected Material"); + luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TTABLE, index, "Expected Material"); result.colAmbient = LuaGetArgument_Color(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TUSERDATA, index, "Expected Material"); + luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TTABLE, index, "Expected Material"); result.colSpecular = LuaGetArgument_Color(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TUSERDATA, index, "Expected Material"); + luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TNUMBER, index, "Expected Material"); result.glossiness = LuaGetArgument_float(L, -1); lua_pop(L, 8); return result; @@ -478,6 +490,7 @@ static Material LuaGetArgument_Material(lua_State* L, int index) static Model LuaGetArgument_Model(lua_State* L, int index) { Model result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model"); result.mesh = LuaGetArgument_Mesh(L, -1); luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model"); @@ -3637,6 +3650,7 @@ static luaL_Reg raylib_functions[] = { REG(LoadRenderTexture) REG(UnloadImage) REG(UnloadTexture) + REG(UnloadRenderTexture) REG(GetImageData) REG(GetTextureData) REG(ImageToPOT) @@ -3698,6 +3712,10 @@ static luaL_Reg raylib_functions[] = { REG(LoadHeightmap) REG(LoadCubicmap) REG(UnloadModel) + REG(LoadMaterial) + REG(LoadDefaultMaterial) + REG(LoadStandardMaterial) + REG(UnloadMaterial) //REG(GenMesh*) // Not ready yet... REG(DrawModel) @@ -3972,6 +3990,8 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3); LuaSetEnum("XBOX_AXIS_LT_RT", 2); #endif + LuaSetEnum("XBOX_AXIS_LEFT_X", 0); + LuaSetEnum("XBOX_AXIS_LEFT_Y", 1); LuaEndEnum("GAMEPAD"); lua_pushglobaltable(L); -- cgit v1.2.3 From 58c762baa3738b3e8e326d2f51c96f8b241fcb04 Mon Sep 17 00:00:00 2001 From: raysan5 Date: Sat, 6 Aug 2016 19:30:13 +0200 Subject: Replaced tabs by spaces --- src/rlua.h | 4481 ++++++++++++++++++++++++++++++------------------------------ 1 file changed, 2243 insertions(+), 2238 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlua.h b/src/rlua.h index 77a51ed5..08ffbca0 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -188,47 +188,47 @@ static Model LuaGetArgument_Model(lua_State* L, int index); //---------------------------------------------------------------------------------- static void LuaStartEnum(void) { - lua_newtable(L); + lua_newtable(L); } static void LuaSetEnum(const char *name, int value) { - lua_pushinteger(L, value); - lua_setfield(L, -2, name); + lua_pushinteger(L, value); + lua_setfield(L, -2, name); } static void LuaSetEnumColor(const char *name, Color color) { - LuaPush_Color(L, color); - lua_setfield(L, -2, name); + LuaPush_Color(L, color); + lua_setfield(L, -2, name); } static void LuaEndEnum(const char *name) { - lua_setglobal(L, name); + lua_setglobal(L, name); } static void LuaPushOpaque(lua_State* L, void *ptr, size_t size) { - void *ud = lua_newuserdata(L, size); - memcpy(ud, ptr, size); + void *ud = lua_newuserdata(L, size); + memcpy(ud, ptr, size); } static void LuaPushOpaqueWithMetatable(lua_State* L, void *ptr, size_t size, const char *metatable_name) { - void *ud = lua_newuserdata(L, size); - memcpy(ud, ptr, size); - luaL_setmetatable(L, metatable_name); + void *ud = lua_newuserdata(L, size); + memcpy(ud, ptr, size); + luaL_setmetatable(L, metatable_name); } static void* LuaGetArgumentOpaqueType(lua_State* L, int index) { - return lua_touserdata(L, index); + return lua_touserdata(L, index); } static void* LuaGetArgumentOpaqueTypeWithMetatable(lua_State* L, int index, const char *metatable_name) { - return luaL_checkudata(L, index, metatable_name); + return luaL_checkudata(L, index, metatable_name); } //---------------------------------------------------------------------------------- @@ -236,87 +236,87 @@ static void* LuaGetArgumentOpaqueTypeWithMetatable(lua_State* L, int index, cons //---------------------------------------------------------------------------------- static int LuaIndexImage(lua_State* L) { - Image img = LuaGetArgument_Image(L, 1); - const char *key = luaL_checkstring(L, 2); - if (!strcmp(key, "width")) - lua_pushinteger(L, img.width); - else if (!strcmp(key, "height")) - lua_pushinteger(L, img.height); - else if (!strcmp(key, "mipmaps")) - lua_pushinteger(L, img.mipmaps); - else if (!strcmp(key, "format")) - lua_pushinteger(L, img.format); - else - return 0; - return 1; + Image img = LuaGetArgument_Image(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "width")) + lua_pushinteger(L, img.width); + else if (!strcmp(key, "height")) + lua_pushinteger(L, img.height); + else if (!strcmp(key, "mipmaps")) + lua_pushinteger(L, img.mipmaps); + else if (!strcmp(key, "format")) + lua_pushinteger(L, img.format); + else + return 0; + return 1; } static int LuaIndexTexture2D(lua_State* L) { - Texture2D img = LuaGetArgument_Texture2D(L, 1); - const char *key = luaL_checkstring(L, 2); - if (!strcmp(key, "width")) - lua_pushinteger(L, img.width); - else if (!strcmp(key, "height")) - lua_pushinteger(L, img.height); - else if (!strcmp(key, "mipmaps")) - lua_pushinteger(L, img.mipmaps); - else if (!strcmp(key, "format")) - lua_pushinteger(L, img.format); - else - return 0; - return 1; + Texture2D img = LuaGetArgument_Texture2D(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "width")) + lua_pushinteger(L, img.width); + else if (!strcmp(key, "height")) + lua_pushinteger(L, img.height); + else if (!strcmp(key, "mipmaps")) + lua_pushinteger(L, img.mipmaps); + else if (!strcmp(key, "format")) + lua_pushinteger(L, img.format); + else + return 0; + return 1; } static int LuaIndexRenderTexture2D(lua_State* L) { - RenderTexture2D img = LuaGetArgument_RenderTexture2D(L, 1); - const char *key = luaL_checkstring(L, 2); - if (!strcmp(key, "texture")) - LuaPush_Texture2D(L, img.texture); - else if (!strcmp(key, "depth")) - LuaPush_Texture2D(L, img.depth); - else - return 0; - return 1; + RenderTexture2D img = LuaGetArgument_RenderTexture2D(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "texture")) + LuaPush_Texture2D(L, img.texture); + else if (!strcmp(key, "depth")) + LuaPush_Texture2D(L, img.depth); + else + return 0; + return 1; } static int LuaIndexSpriteFont(lua_State* L) { - SpriteFont img = LuaGetArgument_SpriteFont(L, 1); - const char *key = luaL_checkstring(L, 2); - if (!strcmp(key, "size")) - lua_pushinteger(L, img.size); - else if (!strcmp(key, "texture")) - LuaPush_Texture2D(L, img.texture); - else if (!strcmp(key, "numChars")) - lua_pushinteger(L, img.numChars); - else - return 0; - return 1; + SpriteFont img = LuaGetArgument_SpriteFont(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "size")) + lua_pushinteger(L, img.size); + else if (!strcmp(key, "texture")) + LuaPush_Texture2D(L, img.texture); + else if (!strcmp(key, "numChars")) + lua_pushinteger(L, img.numChars); + else + return 0; + return 1; } static void LuaBuildOpaqueMetatables(void) { - luaL_newmetatable(L, "Image"); - lua_pushcfunction(L, &LuaIndexImage); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + luaL_newmetatable(L, "Image"); + lua_pushcfunction(L, &LuaIndexImage); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); - luaL_newmetatable(L, "Texture2D"); - lua_pushcfunction(L, &LuaIndexTexture2D); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + luaL_newmetatable(L, "Texture2D"); + lua_pushcfunction(L, &LuaIndexTexture2D); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); luaL_newmetatable(L, "RenderTexture2D"); - lua_pushcfunction(L, &LuaIndexRenderTexture2D); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + lua_pushcfunction(L, &LuaIndexRenderTexture2D); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); - luaL_newmetatable(L, "SpriteFont"); - lua_pushcfunction(L, &LuaIndexSpriteFont); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + luaL_newmetatable(L, "SpriteFont"); + lua_pushcfunction(L, &LuaIndexSpriteFont); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); } //---------------------------------------------------------------------------------- @@ -325,180 +325,180 @@ static void LuaBuildOpaqueMetatables(void) static Vector2 LuaGetArgument_Vector2(lua_State* L, int index) { - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2"); - float x = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2"); - float y = (float)lua_tonumber(L, -1); - lua_pop(L, 2); - return (Vector2) { x, y }; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector2"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector2"); + float y = (float)lua_tonumber(L, -1); + lua_pop(L, 2); + return (Vector2) { x, y }; } static Vector3 LuaGetArgument_Vector3(lua_State* L, int index) { - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3"); - float x = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3"); - float y = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Vector3"); - float z = (float)lua_tonumber(L, -1); - lua_pop(L, 3); - return (Vector3) { x, y, z }; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Vector3"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Vector3"); + float y = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Vector3"); + float z = (float)lua_tonumber(L, -1); + lua_pop(L, 3); + return (Vector3) { x, y, z }; } static Quaternion LuaGetArgument_Quaternion(lua_State* L, int index) { - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion"); - float x = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion"); - float y = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Quaternion"); - float z = (float)lua_tonumber(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "w") == LUA_TNUMBER, index, "Expected Quaternion"); - float w = (float)lua_tonumber(L, -1); - lua_pop(L, 4); - return (Quaternion) { x, y, z, w }; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Quaternion"); + float x = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Quaternion"); + float y = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "z") == LUA_TNUMBER, index, "Expected Quaternion"); + float z = (float)lua_tonumber(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "w") == LUA_TNUMBER, index, "Expected Quaternion"); + float w = (float)lua_tonumber(L, -1); + lua_pop(L, 4); + return (Quaternion) { x, y, z, w }; } static Color LuaGetArgument_Color(lua_State* L, int index) { - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color"); - unsigned char r = (unsigned char)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color"); - unsigned char g = (unsigned char)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "b") == LUA_TNUMBER, index, "Expected Color"); - unsigned char b = (unsigned char)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "a") == LUA_TNUMBER, index, "Expected Color"); - unsigned char a = (unsigned char)lua_tointeger(L, -1); - lua_pop(L, 4); - return (Color) { r, g, b, a }; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "r") == LUA_TNUMBER, index, "Expected Color"); + unsigned char r = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "g") == LUA_TNUMBER, index, "Expected Color"); + unsigned char g = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "b") == LUA_TNUMBER, index, "Expected Color"); + unsigned char b = (unsigned char)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "a") == LUA_TNUMBER, index, "Expected Color"); + unsigned char a = (unsigned char)lua_tointeger(L, -1); + lua_pop(L, 4); + return (Color) { r, g, b, a }; } static Rectangle LuaGetArgument_Rectangle(lua_State* L, int index) { - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle"); - int x = (int)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle"); - int y = (int)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "width") == LUA_TNUMBER, index, "Expected Rectangle"); - int w = (int)lua_tointeger(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "height") == LUA_TNUMBER, index, "Expected Rectangle"); - int h = (int)lua_tointeger(L, -1); - lua_pop(L, 4); - return (Rectangle) { x, y, w, h }; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "x") == LUA_TNUMBER, index, "Expected Rectangle"); + int x = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "y") == LUA_TNUMBER, index, "Expected Rectangle"); + int y = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "width") == LUA_TNUMBER, index, "Expected Rectangle"); + int w = (int)lua_tointeger(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "height") == LUA_TNUMBER, index, "Expected Rectangle"); + int h = (int)lua_tointeger(L, -1); + lua_pop(L, 4); + return (Rectangle) { x, y, w, h }; } static Camera LuaGetArgument_Camera(lua_State* L, int index) { - Camera result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera"); - result.position = LuaGetArgument_Vector3(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera"); - result.target = LuaGetArgument_Vector3(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera"); - result.up = LuaGetArgument_Vector3(L, -1); + Camera result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Camera"); + result.position = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera"); + result.target = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "up") == LUA_TTABLE, index, "Expected Camera"); + result.up = LuaGetArgument_Vector3(L, -1); luaL_argcheck(L, lua_getfield(L, index, "fovy") == LUA_TNUMBER, index, "Expected Camera"); - result.fovy = LuaGetArgument_float(L, -1); - lua_pop(L, 4); - return result; + result.fovy = LuaGetArgument_float(L, -1); + lua_pop(L, 4); + return result; } static Camera2D LuaGetArgument_Camera2D(lua_State* L, int index) { - Camera2D result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D"); - result.offset = LuaGetArgument_Vector2(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D"); - result.target = LuaGetArgument_Vector2(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TNUMBER, index, "Expected Camera2D"); - result.rotation = LuaGetArgument_float(L, -1); + Camera2D result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "offset") == LUA_TTABLE, index, "Expected Camera2D"); + result.offset = LuaGetArgument_Vector2(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "target") == LUA_TTABLE, index, "Expected Camera2D"); + result.target = LuaGetArgument_Vector2(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "rotation") == LUA_TNUMBER, index, "Expected Camera2D"); + result.rotation = LuaGetArgument_float(L, -1); luaL_argcheck(L, lua_getfield(L, index, "zoom") == LUA_TNUMBER, index, "Expected Camera2D"); - result.zoom = LuaGetArgument_float(L, -1); - lua_pop(L, 4); - return result; + result.zoom = LuaGetArgument_float(L, -1); + lua_pop(L, 4); + return result; } static BoundingBox LuaGetArgument_BoundingBox(lua_State* L, int index) { - BoundingBox result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox"); - result.min = LuaGetArgument_Vector3(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox"); - result.max = LuaGetArgument_Vector3(L, -1); - lua_pop(L, 2); - return result; + BoundingBox result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "min") == LUA_TTABLE, index, "Expected BoundingBox"); + result.min = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "max") == LUA_TTABLE, index, "Expected BoundingBox"); + result.max = LuaGetArgument_Vector3(L, -1); + lua_pop(L, 2); + return result; } static Ray LuaGetArgument_Ray(lua_State* L, int index) { - Ray result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray"); - result.position = LuaGetArgument_Vector3(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray"); - result.direction = LuaGetArgument_Vector3(L, -1); - lua_pop(L, 2); - return result; + Ray result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "position") == LUA_TTABLE, index, "Expected Ray"); + result.position = LuaGetArgument_Vector3(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "direction") == LUA_TTABLE, index, "Expected Ray"); + result.direction = LuaGetArgument_Vector3(L, -1); + lua_pop(L, 2); + return result; } static Matrix LuaGetArgument_Matrix(lua_State* L, int index) { - Matrix result = { 0 }; - float* ptr = &result.m0; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + Matrix result = { 0 }; + float* ptr = &result.m0; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - for (int i = 0; i < 16; i++) - { - lua_geti(L, index, i+1); - ptr[i] = luaL_checknumber(L, -1); - } - lua_pop(L, 16); - return result; + for (int i = 0; i < 16; i++) + { + lua_geti(L, index, i+1); + ptr[i] = luaL_checknumber(L, -1); + } + lua_pop(L, 16); + return result; } static Material LuaGetArgument_Material(lua_State* L, int index) { Material result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values luaL_argcheck(L, lua_getfield(L, index, "shader") == LUA_TUSERDATA, index, "Expected Material"); - result.shader = LuaGetArgument_Shader(L, -1); + result.shader = LuaGetArgument_Shader(L, -1); luaL_argcheck(L, lua_getfield(L, index, "texDiffuse") == LUA_TUSERDATA, index, "Expected Material"); - result.texDiffuse = LuaGetArgument_Texture2D(L, -1); + result.texDiffuse = LuaGetArgument_Texture2D(L, -1); luaL_argcheck(L, lua_getfield(L, index, "texNormal") == LUA_TUSERDATA, index, "Expected Material"); - result.texNormal = LuaGetArgument_Texture2D(L, -1); + result.texNormal = LuaGetArgument_Texture2D(L, -1); luaL_argcheck(L, lua_getfield(L, index, "texSpecular") == LUA_TUSERDATA, index, "Expected Material"); - result.texSpecular = LuaGetArgument_Texture2D(L, -1); + result.texSpecular = LuaGetArgument_Texture2D(L, -1); luaL_argcheck(L, lua_getfield(L, index, "colDiffuse") == LUA_TTABLE, index, "Expected Material"); - result.colDiffuse = LuaGetArgument_Color(L, -1); + result.colDiffuse = LuaGetArgument_Color(L, -1); luaL_argcheck(L, lua_getfield(L, index, "colAmbient") == LUA_TTABLE, index, "Expected Material"); - result.colAmbient = LuaGetArgument_Color(L, -1); + result.colAmbient = LuaGetArgument_Color(L, -1); luaL_argcheck(L, lua_getfield(L, index, "colSpecular") == LUA_TTABLE, index, "Expected Material"); - result.colSpecular = LuaGetArgument_Color(L, -1); + result.colSpecular = LuaGetArgument_Color(L, -1); luaL_argcheck(L, lua_getfield(L, index, "glossiness") == LUA_TNUMBER, index, "Expected Material"); - result.glossiness = LuaGetArgument_float(L, -1); + result.glossiness = LuaGetArgument_float(L, -1); lua_pop(L, 8); return result; } static Model LuaGetArgument_Model(lua_State* L, int index) { - Model result; - index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values - luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model"); - result.mesh = LuaGetArgument_Mesh(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model"); - result.transform = LuaGetArgument_Matrix(L, -1); - luaL_argcheck(L, lua_getfield(L, index, "material") == LUA_TTABLE, index, "Expected Model"); - result.material = LuaGetArgument_Material(L, -1); - lua_pop(L, 3); - return result; + Model result; + index = lua_absindex(L, index); // Makes sure we use absolute indices because we push multiple values + luaL_argcheck(L, lua_getfield(L, index, "mesh") == LUA_TUSERDATA, index, "Expected Model"); + result.mesh = LuaGetArgument_Mesh(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "transform") == LUA_TTABLE, index, "Expected Model"); + result.transform = LuaGetArgument_Matrix(L, -1); + luaL_argcheck(L, lua_getfield(L, index, "material") == LUA_TTABLE, index, "Expected Model"); + result.material = LuaGetArgument_Material(L, -1); + lua_pop(L, 3); + return result; } //---------------------------------------------------------------------------------- @@ -506,149 +506,149 @@ static Model LuaGetArgument_Model(lua_State* L, int index) //---------------------------------------------------------------------------------- static void LuaPush_Color(lua_State* L, Color color) { - lua_createtable(L, 0, 4); - lua_pushinteger(L, color.r); - lua_setfield(L, -2, "r"); - lua_pushinteger(L, color.g); - lua_setfield(L, -2, "g"); - lua_pushinteger(L, color.b); - lua_setfield(L, -2, "b"); - lua_pushinteger(L, color.a); - lua_setfield(L, -2, "a"); + lua_createtable(L, 0, 4); + lua_pushinteger(L, color.r); + lua_setfield(L, -2, "r"); + lua_pushinteger(L, color.g); + lua_setfield(L, -2, "g"); + lua_pushinteger(L, color.b); + lua_setfield(L, -2, "b"); + lua_pushinteger(L, color.a); + lua_setfield(L, -2, "a"); } static void LuaPush_Vector2(lua_State* L, Vector2 vec) { - lua_createtable(L, 0, 2); - lua_pushnumber(L, vec.x); - lua_setfield(L, -2, "x"); - lua_pushnumber(L, vec.y); - lua_setfield(L, -2, "y"); + lua_createtable(L, 0, 2); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); } static void LuaPush_Vector3(lua_State* L, Vector3 vec) { - lua_createtable(L, 0, 3); - lua_pushnumber(L, vec.x); - lua_setfield(L, -2, "x"); - lua_pushnumber(L, vec.y); - lua_setfield(L, -2, "y"); - lua_pushnumber(L, vec.z); - lua_setfield(L, -2, "z"); + lua_createtable(L, 0, 3); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); + lua_pushnumber(L, vec.z); + lua_setfield(L, -2, "z"); } static void LuaPush_Quaternion(lua_State* L, Quaternion vec) { - lua_createtable(L, 0, 4); - lua_pushnumber(L, vec.x); - lua_setfield(L, -2, "x"); - lua_pushnumber(L, vec.y); - lua_setfield(L, -2, "y"); - lua_pushnumber(L, vec.z); - lua_setfield(L, -2, "z"); - lua_pushnumber(L, vec.w); - lua_setfield(L, -2, "w"); + lua_createtable(L, 0, 4); + lua_pushnumber(L, vec.x); + lua_setfield(L, -2, "x"); + lua_pushnumber(L, vec.y); + lua_setfield(L, -2, "y"); + lua_pushnumber(L, vec.z); + lua_setfield(L, -2, "z"); + lua_pushnumber(L, vec.w); + lua_setfield(L, -2, "w"); } static void LuaPush_Matrix(lua_State* L, Matrix *matrix) { - int i; - lua_createtable(L, 16, 0); - float* num = (&matrix->m0); - for (i = 0; i < 16; i++) - { - lua_pushnumber(L, num[i]); - lua_rawseti(L, -2, i + 1); - } + int i; + lua_createtable(L, 16, 0); + float* num = (&matrix->m0); + for (i = 0; i < 16; i++) + { + lua_pushnumber(L, num[i]); + lua_rawseti(L, -2, i + 1); + } } static void LuaPush_Rectangle(lua_State* L, Rectangle rect) { - lua_createtable(L, 0, 4); - lua_pushinteger(L, rect.x); - lua_setfield(L, -2, "x"); - lua_pushinteger(L, rect.y); - lua_setfield(L, -2, "y"); - lua_pushinteger(L, rect.width); - lua_setfield(L, -2, "width"); - lua_pushinteger(L, rect.height); - lua_setfield(L, -2, "height"); + lua_createtable(L, 0, 4); + lua_pushinteger(L, rect.x); + lua_setfield(L, -2, "x"); + lua_pushinteger(L, rect.y); + lua_setfield(L, -2, "y"); + lua_pushinteger(L, rect.width); + lua_setfield(L, -2, "width"); + lua_pushinteger(L, rect.height); + lua_setfield(L, -2, "height"); } static void LuaPush_Ray(lua_State* L, Ray ray) { - lua_createtable(L, 0, 2); - LuaPush_Vector3(L, ray.position); - lua_setfield(L, -2, "position"); - LuaPush_Vector3(L, ray.direction); - lua_setfield(L, -2, "direction"); + lua_createtable(L, 0, 2); + LuaPush_Vector3(L, ray.position); + lua_setfield(L, -2, "position"); + LuaPush_Vector3(L, ray.direction); + lua_setfield(L, -2, "direction"); } static void LuaPush_BoundingBox(lua_State* L, BoundingBox bb) { - lua_createtable(L, 0, 2); - LuaPush_Vector3(L, bb.min); - lua_setfield(L, -2, "min"); - LuaPush_Vector3(L, bb.max); - lua_setfield(L, -2, "max"); + lua_createtable(L, 0, 2); + LuaPush_Vector3(L, bb.min); + lua_setfield(L, -2, "min"); + LuaPush_Vector3(L, bb.max); + lua_setfield(L, -2, "max"); } static void LuaPush_Camera(lua_State* L, Camera cam) { - lua_createtable(L, 0, 4); - LuaPush_Vector3(L, cam.position); - lua_setfield(L, -2, "position"); - LuaPush_Vector3(L, cam.target); - lua_setfield(L, -2, "target"); - LuaPush_Vector3(L, cam.up); - lua_setfield(L, -2, "up"); + lua_createtable(L, 0, 4); + LuaPush_Vector3(L, cam.position); + lua_setfield(L, -2, "position"); + LuaPush_Vector3(L, cam.target); + lua_setfield(L, -2, "target"); + LuaPush_Vector3(L, cam.up); + lua_setfield(L, -2, "up"); lua_pushnumber(L, cam.fovy); - lua_setfield(L, -2, "fovy"); + lua_setfield(L, -2, "fovy"); } static void LuaPush_Camera2D(lua_State* L, Camera2D cam) { - lua_createtable(L, 0, 4); - LuaPush_Vector2(L, cam.offset); - lua_setfield(L, -2, "offset"); - LuaPush_Vector2(L, cam.target); - lua_setfield(L, -2, "target"); - lua_pushnumber(L, cam.rotation); - lua_setfield(L, -2, "rotation"); + lua_createtable(L, 0, 4); + LuaPush_Vector2(L, cam.offset); + lua_setfield(L, -2, "offset"); + LuaPush_Vector2(L, cam.target); + lua_setfield(L, -2, "target"); + lua_pushnumber(L, cam.rotation); + lua_setfield(L, -2, "rotation"); lua_pushnumber(L, cam.zoom); - lua_setfield(L, -2, "zoom"); + lua_setfield(L, -2, "zoom"); } static void LuaPush_Material(lua_State* L, Material mat) { - lua_createtable(L, 0, 8); - LuaPush_Shader(L, mat.shader); - lua_setfield(L, -2, "shader"); - LuaPush_Texture2D(L, mat.texDiffuse); - lua_setfield(L, -2, "texDiffuse"); - LuaPush_Texture2D(L, mat.texNormal); - lua_setfield(L, -2, "texNormal"); + lua_createtable(L, 0, 8); + LuaPush_Shader(L, mat.shader); + lua_setfield(L, -2, "shader"); + LuaPush_Texture2D(L, mat.texDiffuse); + lua_setfield(L, -2, "texDiffuse"); + LuaPush_Texture2D(L, mat.texNormal); + lua_setfield(L, -2, "texNormal"); LuaPush_Texture2D(L, mat.texSpecular); - lua_setfield(L, -2, "texSpecular"); + lua_setfield(L, -2, "texSpecular"); LuaPush_Color(L, mat.colDiffuse); - lua_setfield(L, -2, "colDiffuse"); + lua_setfield(L, -2, "colDiffuse"); LuaPush_Color(L, mat.colAmbient); - lua_setfield(L, -2, "colAmbient"); + lua_setfield(L, -2, "colAmbient"); LuaPush_Color(L, mat.colSpecular); - lua_setfield(L, -2, "colSpecular"); + lua_setfield(L, -2, "colSpecular"); lua_pushnumber(L, mat.glossiness); - lua_setfield(L, -2, "glossiness"); + lua_setfield(L, -2, "glossiness"); } static void LuaPush_Model(lua_State* L, Model mdl) { - lua_createtable(L, 0, 4); - LuaPush_Mesh(L, mdl.mesh); - lua_setfield(L, -2, "mesh"); - LuaPush_Matrix(L, &mdl.transform); - lua_setfield(L, -2, "transform"); - LuaPush_Material(L, mdl.material); - lua_setfield(L, -2, "material"); + lua_createtable(L, 0, 4); + LuaPush_Mesh(L, mdl.mesh); + lua_setfield(L, -2, "mesh"); + LuaPush_Matrix(L, &mdl.transform); + lua_setfield(L, -2, "transform"); + LuaPush_Material(L, mdl.material); + lua_setfield(L, -2, "material"); } //---------------------------------------------------------------------------------- @@ -656,95 +656,95 @@ static void LuaPush_Model(lua_State* L, Model mdl) //---------------------------------------------------------------------------------- static int lua_Color(lua_State* L) { - LuaPush_Color(L, (Color) { (unsigned char)luaL_checkinteger(L, 1), (unsigned char)luaL_checkinteger(L, 2), (unsigned char)luaL_checkinteger(L, 3), (unsigned char)luaL_checkinteger(L, 4) }); - return 1; + LuaPush_Color(L, (Color) { (unsigned char)luaL_checkinteger(L, 1), (unsigned char)luaL_checkinteger(L, 2), (unsigned char)luaL_checkinteger(L, 3), (unsigned char)luaL_checkinteger(L, 4) }); + return 1; } static int lua_Vector2(lua_State* L) { - LuaPush_Vector2(L, (Vector2) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2) }); - return 1; + LuaPush_Vector2(L, (Vector2) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2) }); + return 1; } static int lua_Vector3(lua_State* L) { - LuaPush_Vector3(L, (Vector3) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3) }); - return 1; + LuaPush_Vector3(L, (Vector3) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3) }); + return 1; } static int lua_Quaternion(lua_State* L) { - LuaPush_Quaternion(L, (Quaternion) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4) }); - return 1; + LuaPush_Quaternion(L, (Quaternion) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4) }); + return 1; } /* static int lua_Matrix(lua_State* L) { - LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4), + LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4), (float)luaL_checknumber(L, 5), (float)luaL_checknumber(L, 6), (float)luaL_checknumber(L, 7), (float)luaL_checknumber(L, 8), (float)luaL_checknumber(L, 9), (float)luaL_checknumber(L, 10), (float)luaL_checknumber(L, 11), (float)luaL_checknumber(L, 12), (float)luaL_checknumber(L, 13), (float)luaL_checknumber(L, 14), (float)luaL_checknumber(L, 15), (float)luaL_checknumber(L, 16) }); - return 1; + return 1; } */ static int lua_Rectangle(lua_State* L) { - LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) }); - return 1; + LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) }); + return 1; } static int lua_Ray(lua_State* L) { - Vector2 pos = LuaGetArgument_Vector2(L, 1); - Vector2 dir = LuaGetArgument_Vector2(L, 2); - LuaPush_Ray(L, (Ray) { { pos.x, pos.y }, { dir.x, dir.y } }); - return 1; + Vector2 pos = LuaGetArgument_Vector2(L, 1); + Vector2 dir = LuaGetArgument_Vector2(L, 2); + LuaPush_Ray(L, (Ray) { { pos.x, pos.y }, { dir.x, dir.y } }); + return 1; } static int lua_BoundingBox(lua_State* L) { - Vector3 min = LuaGetArgument_Vector3(L, 1); - Vector3 max = LuaGetArgument_Vector3(L, 2); - LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } }); - return 1; + Vector3 min = LuaGetArgument_Vector3(L, 1); + Vector3 max = LuaGetArgument_Vector3(L, 2); + LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } }); + return 1; } static int lua_Camera(lua_State* L) { - Vector3 pos = LuaGetArgument_Vector3(L, 1); - Vector3 tar = LuaGetArgument_Vector3(L, 2); - Vector3 up = LuaGetArgument_Vector3(L, 3); + Vector3 pos = LuaGetArgument_Vector3(L, 1); + Vector3 tar = LuaGetArgument_Vector3(L, 2); + Vector3 up = LuaGetArgument_Vector3(L, 3); //float fovy = LuaGetArgument_float(L, 4); // ??? - LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) }); - return 1; + LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) }); + return 1; } static int lua_Camera2D(lua_State* L) { - Vector2 off = LuaGetArgument_Vector2(L, 1); - Vector2 tar = LuaGetArgument_Vector2(L, 2); - float rot = LuaGetArgument_float(L, 3); + Vector2 off = LuaGetArgument_Vector2(L, 1); + Vector2 tar = LuaGetArgument_Vector2(L, 2); + float rot = LuaGetArgument_float(L, 3); float zoom = LuaGetArgument_float(L, 4); - LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom }); - return 1; + LuaPush_Camera2D(L, (Camera2D) { { off.x, off.y }, { tar.x, tar.y }, rot, zoom }); + return 1; } /* // NOTE: does it make sense to have this constructor? Probably not... static int lua_Material(lua_State* L) { - Shader sdr = LuaGetArgument_Shader(L, 1); - Texture2D td = LuaGetArgument_Texture2D(L, 2); - Texture2D tn = LuaGetArgument_Texture2D(L, 3); - Texture2D ts = LuaGetArgument_Texture2D(L, 4); - Color cd = LuaGetArgument_Color(L, 5); - Color ca = LuaGetArgument_Color(L, 6); - Color cs = LuaGetArgument_Color(L, 7); + Shader sdr = LuaGetArgument_Shader(L, 1); + Texture2D td = LuaGetArgument_Texture2D(L, 2); + Texture2D tn = LuaGetArgument_Texture2D(L, 3); + Texture2D ts = LuaGetArgument_Texture2D(L, 4); + Color cd = LuaGetArgument_Color(L, 5); + Color ca = LuaGetArgument_Color(L, 6); + Color cs = LuaGetArgument_Color(L, 7); float gloss = LuaGetArgument_float(L, 8); - LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss }); - return 1; + LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss }); + return 1; } */ @@ -757,166 +757,166 @@ static int lua_Material(lua_State* L) //------------------------------------------------------------------------------------ int lua_InitWindow(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - const char * arg3 = LuaGetArgument_string(L, 3); - InitWindow(arg1, arg2, arg3); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + const char * arg3 = LuaGetArgument_string(L, 3); + InitWindow(arg1, arg2, arg3); + return 0; } int lua_CloseWindow(lua_State* L) { - CloseWindow(); - return 0; + CloseWindow(); + return 0; } int lua_WindowShouldClose(lua_State* L) { - bool result = WindowShouldClose(); - lua_pushboolean(L, result); - return 1; + bool result = WindowShouldClose(); + lua_pushboolean(L, result); + return 1; } int lua_IsWindowMinimized(lua_State* L) { - bool result = IsWindowMinimized(); - lua_pushboolean(L, result); - return 1; + bool result = IsWindowMinimized(); + lua_pushboolean(L, result); + return 1; } int lua_ToggleFullscreen(lua_State* L) { - ToggleFullscreen(); - return 0; + ToggleFullscreen(); + return 0; } int lua_GetScreenWidth(lua_State* L) { - int result = GetScreenWidth(); - lua_pushinteger(L, result); - return 1; + int result = GetScreenWidth(); + lua_pushinteger(L, result); + return 1; } int lua_GetScreenHeight(lua_State* L) { - int result = GetScreenHeight(); - lua_pushinteger(L, result); - return 1; + int result = GetScreenHeight(); + lua_pushinteger(L, result); + return 1; } int lua_ShowCursor(lua_State* L) { - ShowCursor(); - return 0; + ShowCursor(); + return 0; } int lua_HideCursor(lua_State* L) { - HideCursor(); - return 0; + HideCursor(); + return 0; } int lua_IsCursorHidden(lua_State* L) { - bool result = IsCursorHidden(); - lua_pushboolean(L, result); - return 1; + bool result = IsCursorHidden(); + lua_pushboolean(L, result); + return 1; } int lua_EnableCursor(lua_State* L) { - EnableCursor(); - return 0; + EnableCursor(); + return 0; } int lua_DisableCursor(lua_State* L) { - DisableCursor(); - return 0; + DisableCursor(); + return 0; } int lua_ClearBackground(lua_State* L) { - Color arg1 = LuaGetArgument_Color(L, 1); - ClearBackground(arg1); - return 0; + Color arg1 = LuaGetArgument_Color(L, 1); + ClearBackground(arg1); + return 0; } int lua_BeginDrawing(lua_State* L) { - BeginDrawing(); - return 0; + BeginDrawing(); + return 0; } int lua_EndDrawing(lua_State* L) { - EndDrawing(); - return 0; + EndDrawing(); + return 0; } int lua_Begin2dMode(lua_State* L) { - Camera2D arg1 = LuaGetArgument_Camera2D(L, 1); - Begin2dMode(arg1); - return 0; + Camera2D arg1 = LuaGetArgument_Camera2D(L, 1); + Begin2dMode(arg1); + return 0; } int lua_End2dMode(lua_State* L) { - End2dMode(); - return 0; + End2dMode(); + return 0; } int lua_Begin3dMode(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - Begin3dMode(arg1); - return 0; + Camera arg1 = LuaGetArgument_Camera(L, 1); + Begin3dMode(arg1); + return 0; } int lua_End3dMode(lua_State* L) { - End3dMode(); - return 0; + End3dMode(); + return 0; } int lua_BeginTextureMode(lua_State* L) { - RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); - BeginTextureMode(arg1); - return 0; + RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); + BeginTextureMode(arg1); + return 0; } int lua_EndTextureMode(lua_State* L) { - EndTextureMode(); - return 0; + EndTextureMode(); + return 0; } int lua_GetMouseRay(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Camera arg2 = LuaGetArgument_Camera(L, 2); - Ray result = GetMouseRay(arg1, arg2); - LuaPush_Ray(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Camera arg2 = LuaGetArgument_Camera(L, 2); + Ray result = GetMouseRay(arg1, arg2); + LuaPush_Ray(L, result); + return 1; } int lua_GetWorldToScreen(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Camera arg2 = LuaGetArgument_Camera(L, 2); - Vector2 result = GetWorldToScreen(arg1, arg2); - LuaPush_Vector2(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Camera arg2 = LuaGetArgument_Camera(L, 2); + Vector2 result = GetWorldToScreen(arg1, arg2); + LuaPush_Vector2(L, result); + return 1; } int lua_GetCameraMatrix(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - Matrix result = GetCameraMatrix(arg1); - LuaPush_Matrix(L, &result); - return 1; + Camera arg1 = LuaGetArgument_Camera(L, 1); + Matrix result = GetCameraMatrix(arg1); + LuaPush_Matrix(L, &result); + return 1; } #if defined(PLATFORM_WEB) @@ -925,167 +925,167 @@ static int LuaDrawLoopFunc; static void LuaDrawLoop() { - lua_rawgeti(L, LUA_REGISTRYINDEX, LuaDrawLoopFunc); - lua_call(L, 0, 0); + lua_rawgeti(L, LUA_REGISTRYINDEX, LuaDrawLoopFunc); + lua_call(L, 0, 0); } int lua_SetDrawingLoop(lua_State* L) { - luaL_argcheck(L, lua_isfunction(L, 1), 1, "Loop function expected"); - lua_pushvalue(L, 1); - LuaDrawLoopFunc = luaL_ref(L, LUA_REGISTRYINDEX); - SetDrawingLoop(&LuaDrawLoop); - return 0; + luaL_argcheck(L, lua_isfunction(L, 1), 1, "Loop function expected"); + lua_pushvalue(L, 1); + LuaDrawLoopFunc = luaL_ref(L, LUA_REGISTRYINDEX); + SetDrawingLoop(&LuaDrawLoop); + return 0; } #else int lua_SetTargetFPS(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetTargetFPS(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetTargetFPS(arg1); + return 0; } #endif int lua_GetFPS(lua_State* L) { - float result = GetFPS(); - lua_pushnumber(L, result); - return 1; + float result = GetFPS(); + lua_pushnumber(L, result); + return 1; } int lua_GetFrameTime(lua_State* L) { - float result = GetFrameTime(); - lua_pushnumber(L, result); - return 1; + float result = GetFrameTime(); + lua_pushnumber(L, result); + return 1; } int lua_GetColor(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - Color result = GetColor(arg1); - LuaPush_Color(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + Color result = GetColor(arg1); + LuaPush_Color(L, result); + return 1; } int lua_GetHexValue(lua_State* L) { - Color arg1 = LuaGetArgument_Color(L, 1); - int result = GetHexValue(arg1); - lua_pushinteger(L, result); - return 1; + Color arg1 = LuaGetArgument_Color(L, 1); + int result = GetHexValue(arg1); + lua_pushinteger(L, result); + return 1; } int lua_ColorToFloat(lua_State* L) { - Color arg1 = LuaGetArgument_Color(L, 1); - float * result = ColorToFloat(arg1); - lua_createtable(L, 4, 0); - for (int i = 0; i < 4; i++) - { - lua_pushnumber(L, result[i]); - lua_rawseti(L, -2, i + 1); - } - free(result); - return 1; + Color arg1 = LuaGetArgument_Color(L, 1); + float * result = ColorToFloat(arg1); + lua_createtable(L, 4, 0); + for (int i = 0; i < 4; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; } int lua_VectorToFloat(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float * result = VectorToFloat(arg1); - lua_createtable(L, 3, 0); - for (int i = 0; i < 3; i++) - { - lua_pushnumber(L, result[i]); - lua_rawseti(L, -2, i + 1); - } - free(result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float * result = VectorToFloat(arg1); + lua_createtable(L, 3, 0); + for (int i = 0; i < 3; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; } int lua_MatrixToFloat(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - float * result = MatrixToFloat(arg1); - lua_createtable(L, 16, 0); - for (int i = 0; i < 16; i++) - { - lua_pushnumber(L, result[i]); - lua_rawseti(L, -2, i + 1); - } - free(result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float * result = MatrixToFloat(arg1); + lua_createtable(L, 16, 0); + for (int i = 0; i < 16; i++) + { + lua_pushnumber(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; } int lua_GetRandomValue(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int result = GetRandomValue(arg1, arg2); - lua_pushinteger(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int result = GetRandomValue(arg1, arg2); + lua_pushinteger(L, result); + return 1; } int lua_Fade(lua_State* L) { - Color arg1 = LuaGetArgument_Color(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Color result = Fade(arg1, arg2); - LuaPush_Color(L, result); - return 1; + Color arg1 = LuaGetArgument_Color(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color result = Fade(arg1, arg2); + LuaPush_Color(L, result); + return 1; } int lua_SetConfigFlags(lua_State* L) { - char arg1 = LuaGetArgument_char(L, 1); - SetConfigFlags(arg1); - return 0; + char arg1 = LuaGetArgument_char(L, 1); + SetConfigFlags(arg1); + return 0; } int lua_ShowLogo(lua_State* L) { - ShowLogo(); - return 0; + ShowLogo(); + return 0; } int lua_IsFileDropped(lua_State* L) { - bool result = IsFileDropped(); - lua_pushboolean(L, result); - return 1; + bool result = IsFileDropped(); + lua_pushboolean(L, result); + return 1; } /* int lua_*GetDroppedFiles(lua_State* L) { - int * arg1 = LuaGetArgument_int *(L, 1); - //char * result = *GetDroppedFiles(arg1); - LuaPush_//char *(L, result); - return 1; + int * arg1 = LuaGetArgument_int *(L, 1); + //char * result = *GetDroppedFiles(arg1); + LuaPush_//char *(L, result); + return 1; } */ int lua_ClearDroppedFiles(lua_State* L) { - ClearDroppedFiles(); - return 0; + ClearDroppedFiles(); + return 0; } int lua_StorageSaveValue(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - StorageSaveValue(arg1, arg2); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + StorageSaveValue(arg1, arg2); + return 0; } int lua_StorageLoadValue(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); - int result = StorageLoadValue(arg1); - lua_pushinteger(L, result); - return 1; + int result = StorageLoadValue(arg1); + lua_pushinteger(L, result); + return 1; } //------------------------------------------------------------------------------------ @@ -1094,217 +1094,217 @@ int lua_StorageLoadValue(lua_State* L) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) int lua_IsKeyPressed(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsKeyPressed(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyPressed(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsKeyDown(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsKeyDown(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyDown(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsKeyReleased(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsKeyReleased(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyReleased(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsKeyUp(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsKeyUp(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsKeyUp(arg1); + lua_pushboolean(L, result); + return 1; } int lua_GetKeyPressed(lua_State* L) { - int result = GetKeyPressed(); - lua_pushinteger(L, result); - return 1; + int result = GetKeyPressed(); + lua_pushinteger(L, result); + return 1; } int lua_SetExitKey(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetExitKey(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetExitKey(arg1); + return 0; } int lua_IsGamepadAvailable(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsGamepadAvailable(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsGamepadAvailable(arg1); + lua_pushboolean(L, result); + return 1; } int lua_GetGamepadAxisMovement(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - float result = GetGamepadAxisMovement(arg1, arg2); - lua_pushnumber(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float result = GetGamepadAxisMovement(arg1, arg2); + lua_pushnumber(L, result); + return 1; } int lua_IsGamepadButtonPressed(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - bool result = IsGamepadButtonPressed(arg1, arg2); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonPressed(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_IsGamepadButtonDown(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - bool result = IsGamepadButtonDown(arg1, arg2); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonDown(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_IsGamepadButtonReleased(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - bool result = IsGamepadButtonReleased(arg1, arg2); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonReleased(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_IsGamepadButtonUp(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - bool result = IsGamepadButtonUp(arg1, arg2); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + bool result = IsGamepadButtonUp(arg1, arg2); + lua_pushboolean(L, result); + return 1; } #endif int lua_IsMouseButtonPressed(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsMouseButtonPressed(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonPressed(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsMouseButtonDown(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsMouseButtonDown(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonDown(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsMouseButtonReleased(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsMouseButtonReleased(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonReleased(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsMouseButtonUp(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsMouseButtonUp(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsMouseButtonUp(arg1); + lua_pushboolean(L, result); + return 1; } int lua_GetMouseX(lua_State* L) { - int result = GetMouseX(); - lua_pushinteger(L, result); - return 1; + int result = GetMouseX(); + lua_pushinteger(L, result); + return 1; } int lua_GetMouseY(lua_State* L) { - int result = GetMouseY(); - lua_pushinteger(L, result); - return 1; + int result = GetMouseY(); + lua_pushinteger(L, result); + return 1; } int lua_GetMousePosition(lua_State* L) { - Vector2 result = GetMousePosition(); - LuaPush_Vector2(L, result); - return 1; + Vector2 result = GetMousePosition(); + LuaPush_Vector2(L, result); + return 1; } int lua_SetMousePosition(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - SetMousePosition(arg1); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + SetMousePosition(arg1); + return 0; } int lua_GetMouseWheelMove(lua_State* L) { - int result = GetMouseWheelMove(); - lua_pushinteger(L, result); - return 1; + int result = GetMouseWheelMove(); + lua_pushinteger(L, result); + return 1; } int lua_GetTouchX(lua_State* L) { - int result = GetTouchX(); - lua_pushinteger(L, result); - return 1; + int result = GetTouchX(); + lua_pushinteger(L, result); + return 1; } int lua_GetTouchY(lua_State* L) { - int result = GetTouchY(); - lua_pushinteger(L, result); - return 1; + int result = GetTouchY(); + lua_pushinteger(L, result); + return 1; } int lua_GetTouchPosition(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); - Vector2 result = GetTouchPosition(arg1); - LuaPush_Vector2(L, result); - return 1; + Vector2 result = GetTouchPosition(arg1); + LuaPush_Vector2(L, result); + return 1; } #if defined(PLATFORM_ANDROID) int lua_IsButtonPressed(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsButtonPressed(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonPressed(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsButtonDown(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsButtonDown(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonDown(arg1); + lua_pushboolean(L, result); + return 1; } int lua_IsButtonReleased(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - bool result = IsButtonReleased(arg1); - lua_pushboolean(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + bool result = IsButtonReleased(arg1); + lua_pushboolean(L, result); + return 1; } #endif @@ -1313,66 +1313,66 @@ int lua_IsButtonReleased(lua_State* L) //------------------------------------------------------------------------------------ int lua_SetGesturesEnabled(lua_State* L) { - unsigned arg1 = LuaGetArgument_unsigned(L, 1); - SetGesturesEnabled(arg1); - return 0; + unsigned arg1 = LuaGetArgument_unsigned(L, 1); + SetGesturesEnabled(arg1); + return 0; } int lua_IsGestureDetected(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); - bool result = IsGestureDetected(arg1); - lua_pushboolean(L, result); - return 1; + bool result = IsGestureDetected(arg1); + lua_pushboolean(L, result); + return 1; } int lua_GetTouchPointsCount(lua_State* L) { - int result = GetTouchPointsCount(); - lua_pushinteger(L, result); - return 1; + int result = GetTouchPointsCount(); + lua_pushinteger(L, result); + return 1; } int lua_GetGestureDetected(lua_State* L) { - int result = GetGestureDetected(); - lua_pushinteger(L, result); - return 1; + int result = GetGestureDetected(); + lua_pushinteger(L, result); + return 1; } int lua_GetGestureHoldDuration(lua_State* L) { - int result = GetGestureHoldDuration(); - lua_pushinteger(L, result); - return 1; + int result = GetGestureHoldDuration(); + lua_pushinteger(L, result); + return 1; } int lua_GetGestureDragVector(lua_State* L) { - Vector2 result = GetGestureDragVector(); - LuaPush_Vector2(L, result); - return 1; + Vector2 result = GetGestureDragVector(); + LuaPush_Vector2(L, result); + return 1; } int lua_GetGestureDragAngle(lua_State* L) { - float result = GetGestureDragAngle(); - lua_pushnumber(L, result); - return 1; + float result = GetGestureDragAngle(); + lua_pushnumber(L, result); + return 1; } int lua_GetGesturePinchVector(lua_State* L) { - Vector2 result = GetGesturePinchVector(); - LuaPush_Vector2(L, result); - return 1; + Vector2 result = GetGesturePinchVector(); + LuaPush_Vector2(L, result); + return 1; } int lua_GetGesturePinchAngle(lua_State* L) { - float result = GetGesturePinchAngle(); - lua_pushnumber(L, result); - return 1; + float result = GetGesturePinchAngle(); + lua_pushnumber(L, result); + return 1; } //------------------------------------------------------------------------------------ @@ -1380,88 +1380,88 @@ int lua_GetGesturePinchAngle(lua_State* L) //------------------------------------------------------------------------------------ int lua_SetCameraMode(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetCameraMode(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetCameraMode(arg1); + return 0; } int lua_UpdateCamera(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - UpdateCamera(&arg1); - LuaPush_Camera(L, arg1); - return 1; + Camera arg1 = LuaGetArgument_Camera(L, 1); + UpdateCamera(&arg1); + LuaPush_Camera(L, arg1); + return 1; } int lua_UpdateCameraPlayer(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - UpdateCameraPlayer(&arg1, &arg2); - LuaPush_Camera(L, arg1); - LuaPush_Vector3(L, arg2); - return 2; + Camera arg1 = LuaGetArgument_Camera(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + UpdateCameraPlayer(&arg1, &arg2); + LuaPush_Camera(L, arg1); + LuaPush_Vector3(L, arg2); + return 2; } int lua_SetCameraPosition(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - SetCameraPosition(arg1); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + SetCameraPosition(arg1); + return 0; } int lua_SetCameraTarget(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - SetCameraTarget(arg1); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + SetCameraTarget(arg1); + return 0; } int lua_SetCameraFovy(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - SetCameraFovy(arg1); - return 0; + float arg1 = LuaGetArgument_float(L, 1); + SetCameraFovy(arg1); + return 0; } int lua_SetCameraPanControl(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetCameraPanControl(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetCameraPanControl(arg1); + return 0; } int lua_SetCameraAltControl(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetCameraAltControl(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetCameraAltControl(arg1); + return 0; } int lua_SetCameraSmoothZoomControl(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - SetCameraSmoothZoomControl(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + SetCameraSmoothZoomControl(arg1); + return 0; } int lua_SetCameraMoveControls(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - int arg6 = LuaGetArgument_int(L, 6); - SetCameraMoveControls(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + int arg6 = LuaGetArgument_int(L, 6); + SetCameraMoveControls(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_SetCameraMouseSensitivity(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - SetCameraMouseSensitivity(arg1); - return 0; + float arg1 = LuaGetArgument_float(L, 1); + SetCameraMouseSensitivity(arg1); + return 0; } //------------------------------------------------------------------------------------ @@ -1469,274 +1469,274 @@ int lua_SetCameraMouseSensitivity(lua_State* L) //------------------------------------------------------------------------------------ int lua_DrawPixel(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawPixel(arg1, arg2, arg3); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawPixel(arg1, arg2, arg3); + return 0; } int lua_DrawPixelV(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - DrawPixelV(arg1, arg2); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPixelV(arg1, arg2); + return 0; } int lua_DrawLine(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawLine(arg1, arg2, arg3, arg4, arg5); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawLine(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawLineV(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawLineV(arg1, arg2, arg3); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawLineV(arg1, arg2, arg3); + return 0; } int lua_DrawCircle(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawCircle(arg1, arg2, arg3, arg4); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawCircle(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawCircleGradient(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawCircleGradient(arg1, arg2, arg3, arg4, arg5); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCircleGradient(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawCircleV(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawCircleV(arg1, arg2, arg3); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawCircleV(arg1, arg2, arg3); + return 0; } int lua_DrawCircleLines(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawCircleLines(arg1, arg2, arg3, arg4); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawCircleLines(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawRectangle(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawRectangle(arg1, arg2, arg3, arg4, arg5); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawRectangle(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawRectangleRec(lua_State* L) { - Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - DrawRectangleRec(arg1, arg2); - return 0; + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawRectangleRec(arg1, arg2); + return 0; } int lua_DrawRectangleGradient(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawRectangleGradient(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawRectangleGradient(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawRectangleV(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawRectangleV(arg1, arg2, arg3); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawRectangleV(arg1, arg2, arg3); + return 0; } int lua_DrawRectangleLines(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawRectangleLines(arg1, arg2, arg3, arg4, arg5); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawRectangleLines(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawTriangle(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawTriangle(arg1, arg2, arg3, arg4); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTriangle(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawTriangleLines(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawTriangleLines(arg1, arg2, arg3, arg4); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTriangleLines(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawPoly(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawPoly(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawPoly(arg1, arg2, arg3, arg4, arg5); + return 0; } #define GET_TABLE(type, name, index) \ - type* name = 0; \ - size_t name##_size = 0; \ - { \ - size_t sz = 0; \ - luaL_checktype(L, index, LUA_TTABLE); \ - lua_pushnil(L); \ - while (lua_next(L, index)) { \ - LuaGetArgument_##type(L, -1); \ - sz++; \ - lua_pop(L, 1); \ - } \ - lua_pop(L, 1); \ - name = calloc(sz, sizeof(type)); \ - sz = 0; \ - lua_pushnil(L); \ - while (lua_next(L, index)) { \ - name[sz] = LuaGetArgument_##type(L, -1); \ - sz++; \ - lua_pop(L, 1); \ - } \ - lua_pop(L, 1); \ - name##_size = sz; \ - } + type* name = 0; \ + size_t name##_size = 0; \ + { \ + size_t sz = 0; \ + luaL_checktype(L, index, LUA_TTABLE); \ + lua_pushnil(L); \ + while (lua_next(L, index)) { \ + LuaGetArgument_##type(L, -1); \ + sz++; \ + lua_pop(L, 1); \ + } \ + lua_pop(L, 1); \ + name = calloc(sz, sizeof(type)); \ + sz = 0; \ + lua_pushnil(L); \ + while (lua_next(L, index)) { \ + name[sz] = LuaGetArgument_##type(L, -1); \ + sz++; \ + lua_pop(L, 1); \ + } \ + lua_pop(L, 1); \ + name##_size = sz; \ + } int lua_DrawPolyEx(lua_State* L) { - GET_TABLE(Vector2, arg1, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - DrawPolyEx(arg1, arg1_size, arg2); - free(arg1); - return 0; + GET_TABLE(Vector2, arg1, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPolyEx(arg1, arg1_size, arg2); + free(arg1); + return 0; } int lua_DrawPolyExLines(lua_State* L) { - GET_TABLE(Vector2, arg1, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - DrawPolyExLines(arg1, arg1_size, arg2); - free(arg1); - return 0; + GET_TABLE(Vector2, arg1, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawPolyExLines(arg1, arg1_size, arg2); + free(arg1); + return 0; } int lua_CheckCollisionRecs(lua_State* L) { - Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - bool result = CheckCollisionRecs(arg1, arg2); - lua_pushboolean(L, result); - return 1; + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + bool result = CheckCollisionRecs(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionCircles(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - bool result = CheckCollisionCircles(arg1, arg2, arg3, arg4); - lua_pushboolean(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + bool result = CheckCollisionCircles(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionCircleRec(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); - bool result = CheckCollisionCircleRec(arg1, arg2, arg3); - lua_pushboolean(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + bool result = CheckCollisionCircleRec(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; } int lua_GetCollisionRec(lua_State* L) { - Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - Rectangle result = GetCollisionRec(arg1, arg2); - LuaPush_Rectangle(L, result); - return 1; + Rectangle arg1 = LuaGetArgument_Rectangle(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Rectangle result = GetCollisionRec(arg1, arg2); + LuaPush_Rectangle(L, result); + return 1; } int lua_CheckCollisionPointRec(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - bool result = CheckCollisionPointRec(arg1, arg2); - lua_pushboolean(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + bool result = CheckCollisionPointRec(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionPointCircle(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - bool result = CheckCollisionPointCircle(arg1, arg2, arg3); - lua_pushboolean(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + bool result = CheckCollisionPointCircle(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionPointTriangle(lua_State* L) { - Vector2 arg1 = LuaGetArgument_Vector2(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - Vector2 arg4 = LuaGetArgument_Vector2(L, 4); - bool result = CheckCollisionPointTriangle(arg1, arg2, arg3, arg4); - lua_pushboolean(L, result); - return 1; + Vector2 arg1 = LuaGetArgument_Vector2(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Vector2 arg4 = LuaGetArgument_Vector2(L, 4); + bool result = CheckCollisionPointTriangle(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; } //------------------------------------------------------------------------------------ @@ -1744,385 +1744,385 @@ int lua_CheckCollisionPointTriangle(lua_State* L) //------------------------------------------------------------------------------------ int lua_LoadImage(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - Image result = LoadImage(arg1); - LuaPush_Image(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + Image result = LoadImage(arg1); + LuaPush_Image(L, result); + return 1; } int lua_LoadImageEx(lua_State* L) { - //Color * arg1 = LuaGetArgument_Color *(L, 1); - GET_TABLE(Color, arg1, 1); + //Color * arg1 = LuaGetArgument_Color *(L, 1); + GET_TABLE(Color, arg1, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - Image result = LoadImageEx(arg1, arg2, arg3); - LuaPush_Image(L, result); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + Image result = LoadImageEx(arg1, arg2, arg3); + LuaPush_Image(L, result); - free(arg1); - return 1; + free(arg1); + return 1; } int lua_LoadImageRaw(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - Image result = LoadImageRaw(arg1, arg2, arg3, arg4, arg5); - LuaPush_Image(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Image result = LoadImageRaw(arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, result); + return 1; } int lua_LoadImageFromRES(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Image result = LoadImageFromRES(arg1, arg2); - LuaPush_Image(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Image result = LoadImageFromRES(arg1, arg2); + LuaPush_Image(L, result); + return 1; } int lua_LoadTexture(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - Texture2D result = LoadTexture(arg1); - LuaPush_Texture2D(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + Texture2D result = LoadTexture(arg1); + LuaPush_Texture2D(L, result); + return 1; } int lua_LoadTextureEx(lua_State* L) { - void * arg1 = (char *)LuaGetArgument_string(L, 1); // NOTE: getting argument as string + void * arg1 = (char *)LuaGetArgument_string(L, 1); // NOTE: getting argument as string int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Texture2D result = LoadTextureEx(arg1, arg2, arg3, arg4); - LuaPush_Texture2D(L, result); - return 1; + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Texture2D result = LoadTextureEx(arg1, arg2, arg3, arg4); + LuaPush_Texture2D(L, result); + return 1; } int lua_LoadTextureFromRES(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Texture2D result = LoadTextureFromRES(arg1, arg2); - LuaPush_Texture2D(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Texture2D result = LoadTextureFromRES(arg1, arg2); + LuaPush_Texture2D(L, result); + return 1; } int lua_LoadTextureFromImage(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Texture2D result = LoadTextureFromImage(arg1); - LuaPush_Texture2D(L, result); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Texture2D result = LoadTextureFromImage(arg1); + LuaPush_Texture2D(L, result); + return 1; } int lua_LoadRenderTexture(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - RenderTexture2D result = LoadRenderTexture(arg1, arg2); - LuaPush_RenderTexture2D(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + RenderTexture2D result = LoadRenderTexture(arg1, arg2); + LuaPush_RenderTexture2D(L, result); + return 1; } int lua_UnloadImage(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - UnloadImage(arg1); - return 0; + Image arg1 = LuaGetArgument_Image(L, 1); + UnloadImage(arg1); + return 0; } int lua_UnloadTexture(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - UnloadTexture(arg1); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + UnloadTexture(arg1); + return 0; } int lua_UnloadRenderTexture(lua_State* L) { - RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); - UnloadRenderTexture(arg1); - return 0; + RenderTexture2D arg1 = LuaGetArgument_RenderTexture2D(L, 1); + UnloadRenderTexture(arg1); + return 0; } int lua_GetImageData(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Color * result = GetImageData(arg1); - lua_createtable(L, arg1.width*arg1.height, 0); - for (int i = 0; i < arg1.width*arg1.height; i++) - { - LuaPush_Color(L, result[i]); - lua_rawseti(L, -2, i + 1); - } - free(result); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Color * result = GetImageData(arg1); + lua_createtable(L, arg1.width*arg1.height, 0); + for (int i = 0; i < arg1.width*arg1.height; i++) + { + LuaPush_Color(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + free(result); + return 1; } int lua_GetTextureData(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Image result = GetTextureData(arg1); - LuaPush_Image(L, result); - return 1; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Image result = GetTextureData(arg1); + LuaPush_Image(L, result); + return 1; } int lua_ImageToPOT(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - ImageToPOT(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + ImageToPOT(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageFormat(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - ImageFormat(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + ImageFormat(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageDither(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); + Image arg1 = LuaGetArgument_Image(L, 1); int arg2 = LuaGetArgument_int(L, 2); int arg3 = LuaGetArgument_int(L, 3); int arg4 = LuaGetArgument_int(L, 4); int arg5 = LuaGetArgument_int(L, 5); - ImageDither(&arg1, arg2, arg3, arg4, arg5); - LuaPush_Image(L, arg1); - return 1; + ImageDither(&arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageCopy(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Image result = ImageCopy(arg1); - LuaPush_Image(L, result); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Image result = ImageCopy(arg1); + LuaPush_Image(L, result); + return 1; } int lua_ImageCrop(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - ImageCrop(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + ImageCrop(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageResize(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - ImageResize(&arg1, arg2, arg3); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + ImageResize(&arg1, arg2, arg3); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageResizeNN(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - ImageResizeNN(&arg1, arg2, arg3); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + ImageResizeNN(&arg1, arg2, arg3); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageText(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - Image result = ImageText(arg1, arg2, arg3); - LuaPush_Image(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + Image result = ImageText(arg1, arg2, arg3); + LuaPush_Image(L, result); + return 1; } int lua_ImageTextEx(lua_State* L) { SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); - const char * arg2 = LuaGetArgument_string(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - Image result = ImageTextEx(arg1, arg2, arg3, arg4, arg5); - LuaPush_Image(L, result); - return 1; + const char * arg2 = LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Image result = ImageTextEx(arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, result); + return 1; } int lua_ImageDraw(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Image arg2 = LuaGetArgument_Image(L, 2); - Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); - Rectangle arg4 = LuaGetArgument_Rectangle(L, 4); - ImageDraw(&arg1, arg2, arg3, arg4); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Image arg2 = LuaGetArgument_Image(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Rectangle arg4 = LuaGetArgument_Rectangle(L, 4); + ImageDraw(&arg1, arg2, arg3, arg4); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageDrawText(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - const char * arg3 = LuaGetArgument_string(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - ImageDrawText(&arg1, arg2, arg3, arg4, arg5); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + const char * arg3 = LuaGetArgument_string(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + ImageDrawText(&arg1, arg2, arg3, arg4, arg5); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageDrawTextEx(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3); - const char * arg4 = LuaGetArgument_string(L, 4); - int arg5 = LuaGetArgument_int(L, 5); + Image arg1 = LuaGetArgument_Image(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3); + const char * arg4 = LuaGetArgument_string(L, 4); + int arg5 = LuaGetArgument_int(L, 5); int arg6 = LuaGetArgument_int(L, 6); - Color arg7 = LuaGetArgument_Color(L, 7); - ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7); - LuaPush_Image(L, arg1); - return 1; + Color arg7 = LuaGetArgument_Color(L, 7); + ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageFlipVertical(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - ImageFlipVertical(&arg1); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + ImageFlipVertical(&arg1); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageFlipHorizontal(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - ImageFlipHorizontal(&arg1); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + ImageFlipHorizontal(&arg1); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageColorTint(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - ImageColorTint(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + ImageColorTint(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageColorInvert(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - ImageColorInvert(&arg1); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + ImageColorInvert(&arg1); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageColorGrayscale(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - ImageColorGrayscale(&arg1); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + ImageColorGrayscale(&arg1); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageColorContrast(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - ImageColorContrast(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + ImageColorContrast(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_ImageColorBrightness(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - ImageColorBrightness(&arg1, arg2); - LuaPush_Image(L, arg1); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + ImageColorBrightness(&arg1, arg2); + LuaPush_Image(L, arg1); + return 1; } int lua_GenTextureMipmaps(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - GenTextureMipmaps(arg1); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + GenTextureMipmaps(arg1); + return 0; } int lua_UpdateTexture(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); void * arg2 = (char *)LuaGetArgument_string(L, 2); // NOTE: Getting (void *) as string? - UpdateTexture(arg1, arg2); - return 0; + UpdateTexture(arg1, arg2); + return 0; } int lua_DrawTexture(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawTexture(arg1, arg2, arg3, arg4); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTexture(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawTextureV(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawTextureV(arg1, arg2, arg3); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawTextureV(arg1, arg2, arg3); + return 0; } int lua_DrawTextureEx(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawTextureEx(arg1, arg2, arg3, arg4, arg5); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawTextureEx(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawTextureRec(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawTextureRec(arg1, arg2, arg3, arg4); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawTextureRec(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawTexturePro(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); - Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); - Vector2 arg4 = LuaGetArgument_Vector2(L, 4); - float arg5 = LuaGetArgument_float(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawTexturePro(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Rectangle arg2 = LuaGetArgument_Rectangle(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Vector2 arg4 = LuaGetArgument_Vector2(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawTexturePro(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } //------------------------------------------------------------------------------------ @@ -2130,230 +2130,230 @@ int lua_DrawTexturePro(lua_State* L) //------------------------------------------------------------------------------------ int lua_GetDefaultFont(lua_State* L) { - SpriteFont result = GetDefaultFont(); - LuaPush_SpriteFont(L, result); - return 1; + SpriteFont result = GetDefaultFont(); + LuaPush_SpriteFont(L, result); + return 1; } int lua_LoadSpriteFont(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - SpriteFont result = LoadSpriteFont(arg1); - LuaPush_SpriteFont(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + SpriteFont result = LoadSpriteFont(arg1); + LuaPush_SpriteFont(L, result); + return 1; } int lua_UnloadSpriteFont(lua_State* L) { - SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); - UnloadSpriteFont(arg1); - return 0; + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + UnloadSpriteFont(arg1); + return 0; } int lua_DrawText(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawText(arg1, arg2, arg3, arg4, arg5); - return 0; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawText(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawTextEx(lua_State* L) { - SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); - const char * arg2 = LuaGetArgument_string(L, 2); - Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + Vector2 arg3 = LuaGetArgument_Vector2(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_MeasureText(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int result = MeasureText(arg1, arg2); - lua_pushinteger(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int result = MeasureText(arg1, arg2); + lua_pushinteger(L, result); + return 1; } int lua_MeasureTextEx(lua_State* L) { - SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); - const char * arg2 = LuaGetArgument_string(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Vector2 result = MeasureTextEx(arg1, arg2, arg3, arg4); - LuaPush_Vector2(L, result); - return 1; + SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Vector2 result = MeasureTextEx(arg1, arg2, arg3, arg4); + LuaPush_Vector2(L, result); + return 1; } int lua_DrawFPS(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - DrawFPS(arg1, arg2); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + DrawFPS(arg1, arg2); + return 0; } -// TODO: const char *FormatText(const char *text, ...); -// TODO: const char *SubText(const char *text, int position, int length); +// NOTE: FormatText() can be replaced by Lua function: string.format() +// NOTE: SubText() can be replaced by Lua function: string.sub() int lua_DrawCube(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawCube(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCube(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawCubeV(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawCubeV(arg1, arg2, arg3); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawCubeV(arg1, arg2, arg3); + return 0; } int lua_DrawCubeWires(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawCubeWires(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCubeWires(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawCubeTexture(lua_State* L) { - Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - float arg5 = LuaGetArgument_float(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawCubeTexture(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCubeTexture(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawSphere(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawSphere(arg1, arg2, arg3); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawSphere(arg1, arg2, arg3); + return 0; } int lua_DrawSphereEx(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawSphereEx(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawSphereEx(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawSphereWires(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawSphereWires(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawSphereWires(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawCylinder(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawCylinder(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCylinder(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawCylinderWires(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawCylinderWires(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawCylinderWires(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawPlane(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector2 arg2 = LuaGetArgument_Vector2(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - DrawPlane(arg1, arg2, arg3); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector2 arg2 = LuaGetArgument_Vector2(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawPlane(arg1, arg2, arg3); + return 0; } int lua_DrawRay(lua_State* L) { - Ray arg1 = LuaGetArgument_Ray(L, 1); - Color arg2 = LuaGetArgument_Color(L, 2); - DrawRay(arg1, arg2); - return 0; + Ray arg1 = LuaGetArgument_Ray(L, 1); + Color arg2 = LuaGetArgument_Color(L, 2); + DrawRay(arg1, arg2); + return 0; } int lua_DrawGrid(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - DrawGrid(arg1, arg2); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + DrawGrid(arg1, arg2); + return 0; } int lua_DrawGizmo(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - DrawGizmo(arg1); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + DrawGizmo(arg1); + return 0; } // TODO: DrawLight(Light light); int lua_Draw3DLine(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - Draw3DLine(arg1, arg2, arg3); - return 0; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + Draw3DLine(arg1, arg2, arg3); + return 0; } int lua_Draw3DCircle(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); float arg2 = LuaGetArgument_float(L, 2); float arg3 = LuaGetArgument_float(L, 3); - Vector3 arg4 = LuaGetArgument_Vector3(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - Draw3DCircle(arg1, arg2, arg3, arg4, arg5); - return 0; + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + Draw3DCircle(arg1, arg2, arg3, arg4, arg5); + return 0; } //------------------------------------------------------------------------------------ @@ -2361,231 +2361,231 @@ int lua_Draw3DCircle(lua_State* L) //------------------------------------------------------------------------------------ int lua_LoadModel(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - Model result = LoadModel(arg1); - LuaPush_Model(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + Model result = LoadModel(arg1); + LuaPush_Model(L, result); + return 1; } int lua_LoadModelEx(lua_State* L) { - Mesh arg1 = LuaGetArgument_Mesh(L, 1); - bool arg2 = LuaGetArgument_int(L, 2); - Model result = LoadModelEx(arg1, arg2); - LuaPush_Model(L, result); - return 1; + Mesh arg1 = LuaGetArgument_Mesh(L, 1); + bool arg2 = LuaGetArgument_int(L, 2); + Model result = LoadModelEx(arg1, arg2); + LuaPush_Model(L, result); + return 1; } int lua_LoadModelFromRES(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Model result = LoadModelFromRES(arg1, arg2); - LuaPush_Model(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Model result = LoadModelFromRES(arg1, arg2); + LuaPush_Model(L, result); + return 1; } int lua_LoadHeightmap(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Model result = LoadHeightmap(arg1, arg2); - LuaPush_Model(L, result); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Model result = LoadHeightmap(arg1, arg2); + LuaPush_Model(L, result); + return 1; } int lua_LoadCubicmap(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Model result = LoadCubicmap(arg1); - LuaPush_Model(L, result); - return 1; + Image arg1 = LuaGetArgument_Image(L, 1); + Model result = LoadCubicmap(arg1); + LuaPush_Model(L, result); + return 1; } int lua_UnloadModel(lua_State* L) { - Model arg1 = LuaGetArgument_Model(L, 1); - UnloadModel(arg1); - return 0; + Model arg1 = LuaGetArgument_Model(L, 1); + UnloadModel(arg1); + return 0; } // TODO: GenMesh*() functionality (not ready yet on raylib 1.6) int lua_LoadMaterial(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - Material result = LoadMaterial(arg1); - LuaPush_Material(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + Material result = LoadMaterial(arg1); + LuaPush_Material(L, result); + return 1; } int lua_LoadDefaultMaterial(lua_State* L) { - Material result = LoadDefaultMaterial(); - LuaPush_Material(L, result); - return 1; + Material result = LoadDefaultMaterial(); + LuaPush_Material(L, result); + return 1; } int lua_LoadStandardMaterial(lua_State* L) { - Material result = LoadStandardMaterial(); - LuaPush_Material(L, result); - return 1; + Material result = LoadStandardMaterial(); + LuaPush_Material(L, result); + return 1; } int lua_UnloadMaterial(lua_State* L) { - Material arg1 = LuaGetArgument_Material(L, 1); - UnloadMaterial(arg1); - return 0; + Material arg1 = LuaGetArgument_Material(L, 1); + UnloadMaterial(arg1); + return 0; } int lua_DrawModel(lua_State* L) { - Model arg1 = LuaGetArgument_Model(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawModel(arg1, arg2, arg3, arg4); - return 0; + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawModel(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawModelEx(lua_State* L) { - Model arg1 = LuaGetArgument_Model(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Vector3 arg5 = LuaGetArgument_Vector3(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawModelEx(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + float arg4 = LuaGetArgument_float(L, 4); + Vector3 arg5 = LuaGetArgument_Vector3(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawModelEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawModelWires(lua_State* L) { - Model arg1 = LuaGetArgument_Model(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Color arg4 = LuaGetArgument_Color(L, 4); - DrawModelWires(arg1, arg2, arg3, arg4); - return 0; + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Color arg4 = LuaGetArgument_Color(L, 4); + DrawModelWires(arg1, arg2, arg3, arg4); + return 0; } int lua_DrawModelWiresEx(lua_State* L) { - Model arg1 = LuaGetArgument_Model(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Model arg1 = LuaGetArgument_Model(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Vector3 arg5 = LuaGetArgument_Vector3(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawModelWiresEx(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + float arg4 = LuaGetArgument_float(L, 4); + Vector3 arg5 = LuaGetArgument_Vector3(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawModelWiresEx(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_DrawBillboard(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); - Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - DrawBillboard(arg1, arg2, arg3, arg4, arg5); - return 0; + Camera arg1 = LuaGetArgument_Camera(L, 1); + Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawBillboard(arg1, arg2, arg3, arg4, arg5); + return 0; } int lua_DrawBillboardRec(lua_State* L) { - Camera arg1 = LuaGetArgument_Camera(L, 1); - Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); - Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); - Vector3 arg4 = LuaGetArgument_Vector3(L, 4); - float arg5 = LuaGetArgument_float(L, 5); - Color arg6 = LuaGetArgument_Color(L, 6); - DrawBillboardRec(arg1, arg2, arg3, arg4, arg5, arg6); - return 0; + Camera arg1 = LuaGetArgument_Camera(L, 1); + Texture2D arg2 = LuaGetArgument_Texture2D(L, 2); + Rectangle arg3 = LuaGetArgument_Rectangle(L, 3); + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + float arg5 = LuaGetArgument_float(L, 5); + Color arg6 = LuaGetArgument_Color(L, 6); + DrawBillboardRec(arg1, arg2, arg3, arg4, arg5, arg6); + return 0; } int lua_CalculateBoundingBox(lua_State* L) { - Mesh arg1 = LuaGetArgument_Mesh(L, 1); + Mesh arg1 = LuaGetArgument_Mesh(L, 1); BoundingBox result = CalculateBoundingBox(arg1); - LuaPush_BoundingBox(L, result); - return 1; + LuaPush_BoundingBox(L, result); + return 1; } int lua_CheckCollisionSpheres(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - bool result = CheckCollisionSpheres(arg1, arg2, arg3, arg4); - lua_pushboolean(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + bool result = CheckCollisionSpheres(arg1, arg2, arg3, arg4); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionBoxes(lua_State* L) { - BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); - BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); - bool result = CheckCollisionBoxes(arg1, arg2); - lua_pushboolean(L, result); - return 1; + BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); + BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); + bool result = CheckCollisionBoxes(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionBoxSphere(lua_State* L) { - BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - bool result = CheckCollisionBoxSphere(arg1, arg2, arg3); - lua_pushboolean(L, result); - return 1; + BoundingBox arg1 = LuaGetArgument_BoundingBox(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + bool result = CheckCollisionBoxSphere(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionRaySphere(lua_State* L) { - Ray arg1 = LuaGetArgument_Ray(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - bool result = CheckCollisionRaySphere(arg1, arg2, arg3); - lua_pushboolean(L, result); - return 1; + Ray arg1 = LuaGetArgument_Ray(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + bool result = CheckCollisionRaySphere(arg1, arg2, arg3); + lua_pushboolean(L, result); + return 1; } int lua_CheckCollisionRaySphereEx(lua_State* L) { - Ray arg1 = LuaGetArgument_Ray(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); + Ray arg1 = LuaGetArgument_Ray(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); Vector3 arg4 = LuaGetArgument_Vector3(L, 4); - bool result = CheckCollisionRaySphereEx(arg1, arg2, arg3, &arg4); - lua_pushboolean(L, result); + bool result = CheckCollisionRaySphereEx(arg1, arg2, arg3, &arg4); + lua_pushboolean(L, result); LuaPush_Vector3(L, arg4); - return 2; + return 2; } int lua_CheckCollisionRayBox(lua_State* L) { - Ray arg1 = LuaGetArgument_Ray(L, 1); - BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); - bool result = CheckCollisionRayBox(arg1, arg2); - lua_pushboolean(L, result); - return 1; + Ray arg1 = LuaGetArgument_Ray(L, 1); + BoundingBox arg2 = LuaGetArgument_BoundingBox(L, 2); + bool result = CheckCollisionRayBox(arg1, arg2); + lua_pushboolean(L, result); + return 1; } int lua_ResolveCollisionCubicmap(lua_State* L) { - Image arg1 = LuaGetArgument_Image(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - float arg4 = LuaGetArgument_float(L, 4); - Vector3 result = ResolveCollisionCubicmap(arg1, arg2, &arg3, arg4); - LuaPush_Vector3(L, result); - LuaPush_Vector3(L, arg3); - return 2; + Image arg1 = LuaGetArgument_Image(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + float arg4 = LuaGetArgument_float(L, 4); + Vector3 result = ResolveCollisionCubicmap(arg1, arg2, &arg3, arg4); + LuaPush_Vector3(L, result); + LuaPush_Vector3(L, arg3); + return 2; } //------------------------------------------------------------------------------------ @@ -2593,167 +2593,170 @@ int lua_ResolveCollisionCubicmap(lua_State* L) //------------------------------------------------------------------------------------ int lua_LoadShader(lua_State* L) { - char * arg1 = (char *)LuaGetArgument_string(L, 1); - char * arg2 = (char *)LuaGetArgument_string(L, 2); - Shader result = LoadShader(arg1, arg2); - LuaPush_Shader(L, result); - return 1; + char * arg1 = (char *)LuaGetArgument_string(L, 1); + char * arg2 = (char *)LuaGetArgument_string(L, 2); + Shader result = LoadShader(arg1, arg2); + LuaPush_Shader(L, result); + return 1; } int lua_UnloadShader(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - UnloadShader(arg1); - return 0; + Shader arg1 = LuaGetArgument_Shader(L, 1); + UnloadShader(arg1); + return 0; } int lua_GetDefaultShader(lua_State* L) { - Shader result = GetDefaultShader(); - LuaPush_Shader(L, result); - return 1; + Shader result = GetDefaultShader(); + LuaPush_Shader(L, result); + return 1; } int lua_GetStandardShader(lua_State* L) { - Shader result = GetStandardShader(); - LuaPush_Shader(L, result); - return 1; + Shader result = GetStandardShader(); + LuaPush_Shader(L, result); + return 1; } int lua_GetDefaultTexture(lua_State* L) { - Texture2D result = GetDefaultTexture(); - LuaPush_Texture2D(L, result); - return 1; + Texture2D result = GetDefaultTexture(); + LuaPush_Texture2D(L, result); + return 1; } int lua_GetShaderLocation(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - const char * arg2 = LuaGetArgument_string(L, 2); - int result = GetShaderLocation(arg1, arg2); - lua_pushinteger(L, result); - return 1; + Shader arg1 = LuaGetArgument_Shader(L, 1); + const char * arg2 = LuaGetArgument_string(L, 2); + int result = GetShaderLocation(arg1, arg2); + lua_pushinteger(L, result); + return 1; } int lua_SetShaderValue(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - GET_TABLE(float, arg3, 3); - SetShaderValue(arg1, arg2, arg3, arg3_size); - free(arg3); - return 0; + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + GET_TABLE(float, arg3, 3); + SetShaderValue(arg1, arg2, arg3, arg3_size); + free(arg3); + return 0; } int lua_SetShaderValuei(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - GET_TABLE(int, arg3, 3); - SetShaderValuei(arg1, arg2, arg3, arg3_size); - free(arg3); - return 0; + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + GET_TABLE(int, arg3, 3); + SetShaderValuei(arg1, arg2, arg3, arg3_size); + free(arg3); + return 0; } int lua_SetShaderValueMatrix(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Matrix arg3 = LuaGetArgument_Matrix(L, 3); - SetShaderValueMatrix(arg1, arg2, arg3); - return 0; + Shader arg1 = LuaGetArgument_Shader(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Matrix arg3 = LuaGetArgument_Matrix(L, 3); + SetShaderValueMatrix(arg1, arg2, arg3); + return 0; } int lua_SetMatrixProjection(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - SetMatrixProjection(arg1); - return 0; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + SetMatrixProjection(arg1); + return 0; } int lua_SetMatrixModelview(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - SetMatrixModelview(arg1); - return 0; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + SetMatrixModelview(arg1); + return 0; } int lua_BeginShaderMode(lua_State* L) { - Shader arg1 = LuaGetArgument_Shader(L, 1); - BeginShaderMode(arg1); - return 0; + Shader arg1 = LuaGetArgument_Shader(L, 1); + BeginShaderMode(arg1); + return 0; } int lua_EndShaderMode(lua_State* L) { - EndShaderMode(); - return 0; + EndShaderMode(); + return 0; } int lua_BeginBlendMode(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - BeginBlendMode(arg1); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + BeginBlendMode(arg1); + return 0; } int lua_EndBlendMode(lua_State* L) { - EndBlendMode(); - return 0; + EndBlendMode(); + return 0; } -// TODO: Light CreateLight(int type, Vector3 position, Color diffuse); -// TODO: void DestroyLight(Light light); - -//------------------------------------------------------------------------------------ -// raylib [rlgl] module functions - VR experience -//------------------------------------------------------------------------------------ -int lua_InitVrDevice(lua_State* L) +int lua_CreateLight(lua_State* L) { int arg1 = LuaGetArgument_int(L, 1); - InitVrDevice(arg1); - return 0; + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + Light result = CreateLight(arg1, arg2, arg3); + LuaPush_Light(L, result); + return 1; } -int lua_CloseVrDevice(lua_State* L) +int lua_DestroyLight(lua_State* L) { - CloseVrDevice(); - return 0; + Light arg1 = LuaGetArgument_Light(L, 1); + DestroyLight(arg1); + return 0; } -int lua_UpdateVrTracking(lua_State* L) + +//------------------------------------------------------------------------------------ +// raylib [rlgl] module functions - VR experience +//------------------------------------------------------------------------------------ +int lua_InitVrDevice(lua_State* L) { - UpdateVrTracking(); - return 0; + int arg1 = LuaGetArgument_int(L, 1); + InitVrDevice(arg1); + return 0; } -int lua_BeginVrDrawing(lua_State* L) +int lua_CloseVrDevice(lua_State* L) { - BeginVrDrawing(); - return 0; + CloseVrDevice(); + return 0; } -int lua_EndVrDrawing(lua_State* L) +int lua_IsVrDeviceReady(lua_State* L) { - EndVrDrawing(); - return 0; + bool result = IsVrDeviceReady(); + lua_pushboolean(L, result); + return 1; } -int lua_IsVrDeviceReady(lua_State* L) +int lua_UpdateVrTracking(lua_State* L) { - bool result = IsVrDeviceReady(); - lua_pushboolean(L, result); - return 1; + UpdateVrTracking(); + return 0; } int lua_ToggleVrMode(lua_State* L) { - ToggleVrMode(); - return 0; + ToggleVrMode(); + return 0; } //------------------------------------------------------------------------------------ @@ -2761,213 +2764,213 @@ int lua_ToggleVrMode(lua_State* L) //------------------------------------------------------------------------------------ int lua_InitAudioDevice(lua_State* L) { - InitAudioDevice(); - return 0; + InitAudioDevice(); + return 0; } int lua_CloseAudioDevice(lua_State* L) { - CloseAudioDevice(); - return 0; + CloseAudioDevice(); + return 0; } int lua_IsAudioDeviceReady(lua_State* L) { - bool result = IsAudioDeviceReady(); + bool result = IsAudioDeviceReady(); lua_pushboolean(L, result); - return 1; + return 1; } int lua_LoadSound(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - Sound result = LoadSound((char*)arg1); - LuaPush_Sound(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + Sound result = LoadSound((char*)arg1); + LuaPush_Sound(L, result); + return 1; } int lua_LoadSoundFromWave(lua_State* L) { - Wave arg1 = LuaGetArgument_Wave(L, 1); - Sound result = LoadSoundFromWave(arg1); - LuaPush_Sound(L, result); - return 1; + Wave arg1 = LuaGetArgument_Wave(L, 1); + Sound result = LoadSoundFromWave(arg1); + LuaPush_Sound(L, result); + return 1; } int lua_LoadSoundFromRES(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - Sound result = LoadSoundFromRES(arg1, arg2); - LuaPush_Sound(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + Sound result = LoadSoundFromRES(arg1, arg2); + LuaPush_Sound(L, result); + return 1; } int lua_UnloadSound(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - UnloadSound(arg1); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + UnloadSound(arg1); + return 0; } int lua_PlaySound(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - PlaySound(arg1); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + PlaySound(arg1); + return 0; } int lua_PauseSound(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - PauseSound(arg1); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + PauseSound(arg1); + return 0; } int lua_ResumeSound(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - ResumeSound(arg1); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + ResumeSound(arg1); + return 0; } int lua_StopSound(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - StopSound(arg1); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + StopSound(arg1); + return 0; } int lua_IsSoundPlaying(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - bool result = IsSoundPlaying(arg1); - lua_pushboolean(L, result); - return 1; + Sound arg1 = LuaGetArgument_Sound(L, 1); + bool result = IsSoundPlaying(arg1); + lua_pushboolean(L, result); + return 1; } int lua_SetSoundVolume(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - SetSoundVolume(arg1, arg2); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetSoundVolume(arg1, arg2); + return 0; } int lua_SetSoundPitch(lua_State* L) { - Sound arg1 = LuaGetArgument_Sound(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - SetSoundPitch(arg1, arg2); - return 0; + Sound arg1 = LuaGetArgument_Sound(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + SetSoundPitch(arg1, arg2); + return 0; } int lua_LoadMusicStream(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); + const char * arg1 = LuaGetArgument_string(L, 1); Music result = LoadMusicStream((char *)arg1); - LuaPush_Music(L, result); - return 1; + LuaPush_Music(L, result); + return 1; } int lua_UnloadMusicStream(lua_State* L) { - Music arg1 = LuaGetArgument_Music(L, 1); - UnloadMusicStream(arg1); - return 0; + Music arg1 = LuaGetArgument_Music(L, 1); + UnloadMusicStream(arg1); + return 0; } int lua_UpdateMusicStream(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - UpdateMusicStream(arg1); - return 0; + UpdateMusicStream(arg1); + return 0; } int lua_PlayMusicStream(lua_State* L) { - Music arg1 = LuaGetArgument_Music(L, 1); - PlayMusicStream(arg1); - return 0; + Music arg1 = LuaGetArgument_Music(L, 1); + PlayMusicStream(arg1); + return 0; } int lua_StopMusicStream(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - StopMusicStream(arg1); - return 0; + StopMusicStream(arg1); + return 0; } int lua_PauseMusicStream(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - PauseMusicStream(arg1); - return 0; + PauseMusicStream(arg1); + return 0; } int lua_ResumeMusicStream(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - ResumeMusicStream(arg1); - return 0; + ResumeMusicStream(arg1); + return 0; } int lua_IsMusicPlaying(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - bool result = IsMusicPlaying(arg1); - lua_pushboolean(L, result); - return 1; + bool result = IsMusicPlaying(arg1); + lua_pushboolean(L, result); + return 1; } int lua_SetMusicVolume(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - SetMusicVolume(arg1, arg2); - return 0; + float arg2 = LuaGetArgument_float(L, 2); + SetMusicVolume(arg1, arg2); + return 0; } int lua_SetMusicPitch(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - SetMusicPitch(arg1, arg2); - return 0; + float arg2 = LuaGetArgument_float(L, 2); + SetMusicPitch(arg1, arg2); + return 0; } int lua_GetMusicTimeLength(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - float result = GetMusicTimeLength(arg1); - lua_pushnumber(L, result); - return 1; + float result = GetMusicTimeLength(arg1); + lua_pushnumber(L, result); + return 1; } int lua_GetMusicTimePlayed(lua_State* L) { Music arg1 = LuaGetArgument_Music(L, 1); - float result = GetMusicTimePlayed(arg1); - lua_pushnumber(L, result); - return 1; + float result = GetMusicTimePlayed(arg1); + lua_pushnumber(L, result); + return 1; } int lua_InitAudioStream(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int arg2 = LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); + int arg1 = LuaGetArgument_int(L, 1); + int arg2 = LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); AudioStream result = InitAudioStream(arg1, arg2, arg3); - LuaPush_AudioStream(L, result); - return 1; + LuaPush_AudioStream(L, result); + return 1; } int lua_CloseAudioStream(lua_State* L) { - AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - CloseAudioStream(arg1); - return 0; + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + CloseAudioStream(arg1); + return 0; } int lua_UpdateAudioStream(lua_State* L) @@ -2975,45 +2978,45 @@ int lua_UpdateAudioStream(lua_State* L) AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); void * arg2 = (char *)LuaGetArgument_string(L, 2); int arg3 = LuaGetArgument_int(L, 3); - UpdateAudioStream(arg1, arg2, arg3); - return 0; + UpdateAudioStream(arg1, arg2, arg3); + return 0; } int lua_IsAudioBufferProcessed(lua_State* L) { AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - bool result = IsAudioBufferProcessed(arg1); - lua_pushboolean(L, result); - return 1; + bool result = IsAudioBufferProcessed(arg1); + lua_pushboolean(L, result); + return 1; } int lua_PlayAudioStream(lua_State* L) { - AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - PlayAudioStream(arg1); - return 0; + AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); + PlayAudioStream(arg1); + return 0; } int lua_StopAudioStream(lua_State* L) { AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - StopAudioStream(arg1); - return 0; + StopAudioStream(arg1); + return 0; } int lua_PauseAudioStream(lua_State* L) { AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - PauseAudioStream(arg1); - return 0; + PauseAudioStream(arg1); + return 0; } int lua_ResumeAudioStream(lua_State* L) { AudioStream arg1 = LuaGetArgument_AudioStream(L, 1); - ResumeAudioStream(arg1); - return 0; + ResumeAudioStream(arg1); + return 0; } //---------------------------------------------------------------------------------- @@ -3021,70 +3024,70 @@ int lua_ResumeAudioStream(lua_State* L) //---------------------------------------------------------------------------------- int lua_DecompressData(lua_State* L) { - unsigned char *arg1 = (unsigned char *)LuaGetArgument_string(L, 1); - unsigned arg2 = (unsigned)LuaGetArgument_int(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - unsigned char *result = DecompressData(arg1, arg2, arg3); - lua_pushlstring(L, (const char *)result, arg3); - return 1; + unsigned char *arg1 = (unsigned char *)LuaGetArgument_string(L, 1); + unsigned arg2 = (unsigned)LuaGetArgument_int(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + unsigned char *result = DecompressData(arg1, arg2, arg3); + lua_pushlstring(L, (const char *)result, arg3); + return 1; } #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) int lua_WriteBitmap(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - WriteBitmap(arg1, arg2, arg3, arg4); - return 0; + const char * arg1 = LuaGetArgument_string(L, 1); + unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + WriteBitmap(arg1, arg2, arg3, arg4); + return 0; } int lua_WritePNG(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); - int arg3 = LuaGetArgument_int(L, 3); - int arg4 = LuaGetArgument_int(L, 4); - int arg5 = LuaGetArgument_int(L, 5); - WritePNG(arg1, arg2, arg3, arg4, arg5); - return 0; + const char * arg1 = LuaGetArgument_string(L, 1); + unsigned char* arg2 = (unsigned char*)LuaGetArgument_string(L, 2); + int arg3 = LuaGetArgument_int(L, 3); + int arg4 = LuaGetArgument_int(L, 4); + int arg5 = LuaGetArgument_int(L, 5); + WritePNG(arg1, arg2, arg3, arg4, arg5); + return 0; } #endif int lua_TraceLog(lua_State* L) { - int num_args = lua_gettop(L) - 1; - int arg1 = LuaGetArgument_int(L, 1); + int num_args = lua_gettop(L) - 1; + int arg1 = LuaGetArgument_int(L, 1); - /// type, fmt, args... + /// type, fmt, args... - lua_rotate(L, 1, -1); /// fmt, args..., type - lua_pop(L, 1); /// fmt, args... + lua_rotate(L, 1, -1); /// fmt, args..., type + lua_pop(L, 1); /// fmt, args... - lua_getglobal(L, "string"); /// fmt, args..., [string] - lua_getfield(L, 1, "format"); /// fmt, args..., [string], format() - lua_rotate(L, 1, 2); /// [string], format(), fmt, args... - lua_call(L, num_args, 1); /// [string], formatted_string - - TraceLog(arg1, "%s", luaL_checkstring(L,-1)); - return 0; + lua_getglobal(L, "string"); /// fmt, args..., [string] + lua_getfield(L, 1, "format"); /// fmt, args..., [string], format() + lua_rotate(L, 1, 2); /// [string], format(), fmt, args... + lua_call(L, num_args, 1); /// [string], formatted_string + + TraceLog(arg1, "%s", luaL_checkstring(L,-1)); + return 0; } int lua_GetExtension(lua_State* L) { - const char * arg1 = LuaGetArgument_string(L, 1); - const char* result = GetExtension(arg1); - lua_pushstring(L, result); - return 1; + const char * arg1 = LuaGetArgument_string(L, 1); + const char* result = GetExtension(arg1); + lua_pushstring(L, result); + return 1; } int lua_GetNextPOT(lua_State* L) { - int arg1 = LuaGetArgument_int(L, 1); - int result = GetNextPOT(arg1); - lua_pushinteger(L, result); - return 1; + int arg1 = LuaGetArgument_int(L, 1); + int result = GetNextPOT(arg1); + lua_pushinteger(L, result); + return 1; } //---------------------------------------------------------------------------------- @@ -3092,123 +3095,123 @@ int lua_GetNextPOT(lua_State* L) //---------------------------------------------------------------------------------- int lua_VectorAdd(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 result = VectorAdd(arg1, arg2); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorAdd(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorSubtract(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 result = VectorSubtract(arg1, arg2); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorSubtract(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorCrossProduct(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 result = VectorCrossProduct(arg1, arg2); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorCrossProduct(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorPerpendicular(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 result = VectorPerpendicular(arg1); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 result = VectorPerpendicular(arg1); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorDotProduct(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float result = VectorDotProduct(arg1, arg2); - lua_pushnumber(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float result = VectorDotProduct(arg1, arg2); + lua_pushnumber(L, result); + return 1; } int lua_VectorLength(lua_State* L) { - const Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float result = VectorLength(arg1); - lua_pushnumber(L, result); - return 1; + const Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float result = VectorLength(arg1); + lua_pushnumber(L, result); + return 1; } int lua_VectorScale(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - VectorScale(&arg1, arg2); - LuaPush_Vector3(L, arg1); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + VectorScale(&arg1, arg2); + LuaPush_Vector3(L, arg1); + return 1; } int lua_VectorNegate(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - VectorNegate(&arg1); - LuaPush_Vector3(L, arg1); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + VectorNegate(&arg1); + LuaPush_Vector3(L, arg1); + return 1; } int lua_VectorNormalize(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - VectorNormalize(&arg1); - LuaPush_Vector3(L, arg1); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + VectorNormalize(&arg1); + LuaPush_Vector3(L, arg1); + return 1; } int lua_VectorDistance(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float result = VectorDistance(arg1, arg2); - lua_pushnumber(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float result = VectorDistance(arg1, arg2); + lua_pushnumber(L, result); + return 1; } int lua_VectorLerp(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Vector3 result = VectorLerp(arg1, arg2, arg3); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Vector3 result = VectorLerp(arg1, arg2, arg3); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorReflect(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 result = VectorReflect(arg1, arg2); - LuaPush_Vector3(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 result = VectorReflect(arg1, arg2); + LuaPush_Vector3(L, result); + return 1; } int lua_VectorTransform(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Matrix arg2 = LuaGetArgument_Matrix(L, 2); - VectorTransform(&arg1, arg2); - LuaPush_Vector3(L, arg1); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + VectorTransform(&arg1, arg2); + LuaPush_Vector3(L, arg1); + return 1; } int lua_VectorZero(lua_State* L) { - Vector3 result = VectorZero(); - LuaPush_Vector3(L, result); - return 1; + Vector3 result = VectorZero(); + LuaPush_Vector3(L, result); + return 1; } //---------------------------------------------------------------------------------- @@ -3216,176 +3219,176 @@ int lua_VectorZero(lua_State* L) //---------------------------------------------------------------------------------- int lua_MatrixDeterminant(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - float result = MatrixDeterminant(arg1); - lua_pushnumber(L, result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float result = MatrixDeterminant(arg1); + lua_pushnumber(L, result); + return 1; } int lua_MatrixTrace(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - float result = MatrixTrace(arg1); - lua_pushnumber(L, result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + float result = MatrixTrace(arg1); + lua_pushnumber(L, result); + return 1; } int lua_MatrixTranspose(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - MatrixTranspose(&arg1); - LuaPush_Matrix(L, &arg1); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixTranspose(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; } int lua_MatrixInvert(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - MatrixInvert(&arg1); - LuaPush_Matrix(L, &arg1); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixInvert(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; } int lua_MatrixNormalize(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - MatrixNormalize(&arg1); - LuaPush_Matrix(L, &arg1); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + MatrixNormalize(&arg1); + LuaPush_Matrix(L, &arg1); + return 1; } int lua_MatrixIdentity(lua_State* L) { - Matrix result = MatrixIdentity(); - LuaPush_Matrix(L, &result); - return 1; + Matrix result = MatrixIdentity(); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixAdd(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - Matrix arg2 = LuaGetArgument_Matrix(L, 2); - Matrix result = MatrixAdd(arg1, arg2); - LuaPush_Matrix(L, &result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixAdd(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixSubstract(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - Matrix arg2 = LuaGetArgument_Matrix(L, 2); - Matrix result = MatrixSubstract(arg1, arg2); - LuaPush_Matrix(L, &result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixSubstract(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixTranslate(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Matrix result = MatrixTranslate(arg1, arg2, arg3); - LuaPush_Matrix(L, &result); - return 1; + float arg1 = LuaGetArgument_float(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Matrix result = MatrixTranslate(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixRotate(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Matrix result = MatrixRotate(arg1, arg2); - LuaPush_Matrix(L, &result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Matrix result = MatrixRotate(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixRotateX(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - Matrix result = MatrixRotateX(arg1); - LuaPush_Matrix(L, &result); - return 1; + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateX(arg1); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixRotateY(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - Matrix result = MatrixRotateY(arg1); - LuaPush_Matrix(L, &result); - return 1; + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateY(arg1); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixRotateZ(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - Matrix result = MatrixRotateZ(arg1); - LuaPush_Matrix(L, &result); - return 1; + float arg1 = LuaGetArgument_float(L, 1); + Matrix result = MatrixRotateZ(arg1); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixScale(lua_State* L) { - float arg1 = LuaGetArgument_float(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Matrix result = MatrixScale(arg1, arg2, arg3); - LuaPush_Matrix(L, &result); - return 1; + float arg1 = LuaGetArgument_float(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Matrix result = MatrixScale(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixMultiply(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - Matrix arg2 = LuaGetArgument_Matrix(L, 2); - Matrix result = MatrixMultiply(arg1, arg2); - LuaPush_Matrix(L, &result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + Matrix result = MatrixMultiply(arg1, arg2); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixFrustum(lua_State* L) { - double arg1 = LuaGetArgument_double(L, 1); - double arg2 = LuaGetArgument_double(L, 2); - double arg3 = LuaGetArgument_double(L, 3); - double arg4 = LuaGetArgument_double(L, 4); - double arg5 = LuaGetArgument_double(L, 5); - double arg6 = LuaGetArgument_double(L, 6); - Matrix result = MatrixFrustum(arg1, arg2, arg3, arg4, arg5, arg6); - LuaPush_Matrix(L, &result); - return 1; + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + double arg5 = LuaGetArgument_double(L, 5); + double arg6 = LuaGetArgument_double(L, 6); + Matrix result = MatrixFrustum(arg1, arg2, arg3, arg4, arg5, arg6); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixPerspective(lua_State* L) { - double arg1 = LuaGetArgument_double(L, 1); - double arg2 = LuaGetArgument_double(L, 2); - double arg3 = LuaGetArgument_double(L, 3); - double arg4 = LuaGetArgument_double(L, 4); - Matrix result = MatrixPerspective(arg1, arg2, arg3, arg4); - LuaPush_Matrix(L, &result); - return 1; + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + Matrix result = MatrixPerspective(arg1, arg2, arg3, arg4); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixOrtho(lua_State* L) { - double arg1 = LuaGetArgument_double(L, 1); - double arg2 = LuaGetArgument_double(L, 2); - double arg3 = LuaGetArgument_double(L, 3); - double arg4 = LuaGetArgument_double(L, 4); - double arg5 = LuaGetArgument_double(L, 5); - double arg6 = LuaGetArgument_double(L, 6); - Matrix result = MatrixOrtho(arg1, arg2, arg3, arg4, arg5, arg6); - LuaPush_Matrix(L, &result); - return 1; + double arg1 = LuaGetArgument_double(L, 1); + double arg2 = LuaGetArgument_double(L, 2); + double arg3 = LuaGetArgument_double(L, 3); + double arg4 = LuaGetArgument_double(L, 4); + double arg5 = LuaGetArgument_double(L, 5); + double arg6 = LuaGetArgument_double(L, 6); + Matrix result = MatrixOrtho(arg1, arg2, arg3, arg4, arg5, arg6); + LuaPush_Matrix(L, &result); + return 1; } int lua_MatrixLookAt(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Vector3 arg3 = LuaGetArgument_Vector3(L, 3); - Matrix result = MatrixLookAt(arg1, arg2, arg3); - LuaPush_Matrix(L, &result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Vector3 arg3 = LuaGetArgument_Vector3(L, 3); + Matrix result = MatrixLookAt(arg1, arg2, arg3); + LuaPush_Matrix(L, &result); + return 1; } //---------------------------------------------------------------------------------- @@ -3393,82 +3396,82 @@ int lua_MatrixLookAt(lua_State* L) //---------------------------------------------------------------------------------- int lua_QuaternionLength(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - float result = QuaternionLength(arg1); - lua_pushnumber(L, result); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + float result = QuaternionLength(arg1); + lua_pushnumber(L, result); + return 1; } int lua_QuaternionNormalize(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - QuaternionNormalize(&arg1); - LuaPush_Quaternion(L, arg1); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + QuaternionNormalize(&arg1); + LuaPush_Quaternion(L, arg1); + return 1; } int lua_QuaternionMultiply(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); - Quaternion result = QuaternionMultiply(arg1, arg2); - LuaPush_Quaternion(L, result); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); + Quaternion result = QuaternionMultiply(arg1, arg2); + LuaPush_Quaternion(L, result); + return 1; } int lua_QuaternionSlerp(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Quaternion result = QuaternionSlerp(arg1, arg2, arg3); - LuaPush_Quaternion(L, result); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Quaternion arg2 = LuaGetArgument_Quaternion(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Quaternion result = QuaternionSlerp(arg1, arg2, arg3); + LuaPush_Quaternion(L, result); + return 1; } int lua_QuaternionFromMatrix(lua_State* L) { - Matrix arg1 = LuaGetArgument_Matrix(L, 1); - Quaternion result = QuaternionFromMatrix(arg1); - LuaPush_Quaternion(L, result); - return 1; + Matrix arg1 = LuaGetArgument_Matrix(L, 1); + Quaternion result = QuaternionFromMatrix(arg1); + LuaPush_Quaternion(L, result); + return 1; } int lua_QuaternionToMatrix(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - Matrix result = QuaternionToMatrix(arg1); - LuaPush_Matrix(L, &result); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Matrix result = QuaternionToMatrix(arg1); + LuaPush_Matrix(L, &result); + return 1; } int lua_QuaternionFromAxisAngle(lua_State* L) { - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - Quaternion result = QuaternionFromAxisAngle(arg1, arg2); - LuaPush_Quaternion(L, result); - return 1; + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + Quaternion result = QuaternionFromAxisAngle(arg1, arg2); + LuaPush_Quaternion(L, result); + return 1; } int lua_QuaternionToAxisAngle(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); Vector3 arg2; - float arg3 = 0; - QuaternionToAxisAngle(arg1, &arg2, &arg3); - LuaPush_Vector3(L, arg2); - lua_pushnumber(L, arg3); - return 2; + float arg3 = 0; + QuaternionToAxisAngle(arg1, &arg2, &arg3); + LuaPush_Vector3(L, arg2); + lua_pushnumber(L, arg3); + return 2; } int lua_QuaternionTransform(lua_State* L) { - Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); - Matrix arg2 = LuaGetArgument_Matrix(L, 2); - QuaternionTransform(&arg1, arg2); - LuaPush_Quaternion(L, arg1); - return 1; + Quaternion arg1 = LuaGetArgument_Quaternion(L, 1); + Matrix arg2 = LuaGetArgument_Matrix(L, 2); + QuaternionTransform(&arg1, arg2); + LuaPush_Quaternion(L, arg1); + return 1; } @@ -3479,174 +3482,174 @@ int lua_QuaternionTransform(lua_State* L) // raylib Functions (and data types) list static luaL_Reg raylib_functions[] = { - + // Register non-opaque data types REG(Color) - REG(Vector2) - REG(Vector3) + REG(Vector2) + REG(Vector3) //REG(Matrix) REG(Quaternion) - REG(Rectangle) - REG(Ray) - REG(Camera) - REG(Camera2D) + REG(Rectangle) + REG(Ray) + REG(Camera) + REG(Camera2D) REG(BoundingBox) //REG(Material) // Register functions - REG(InitWindow) - REG(CloseWindow) - REG(WindowShouldClose) - REG(IsWindowMinimized) - REG(ToggleFullscreen) - REG(GetScreenWidth) - REG(GetScreenHeight) + REG(InitWindow) + REG(CloseWindow) + REG(WindowShouldClose) + REG(IsWindowMinimized) + REG(ToggleFullscreen) + REG(GetScreenWidth) + REG(GetScreenHeight) - REG(ShowCursor) - REG(HideCursor) - REG(IsCursorHidden) - REG(EnableCursor) - REG(DisableCursor) - - REG(ClearBackground) - REG(BeginDrawing) - REG(EndDrawing) + REG(ShowCursor) + REG(HideCursor) + REG(IsCursorHidden) + REG(EnableCursor) + REG(DisableCursor) + + REG(ClearBackground) + REG(BeginDrawing) + REG(EndDrawing) REG(Begin2dMode) - REG(End2dMode) - REG(Begin3dMode) - REG(End3dMode) + REG(End2dMode) + REG(Begin3dMode) + REG(End3dMode) REG(BeginTextureMode) - REG(EndTextureMode) + REG(EndTextureMode) - REG(GetMouseRay) - REG(GetWorldToScreen) - REG(GetCameraMatrix) + REG(GetMouseRay) + REG(GetWorldToScreen) + REG(GetCameraMatrix) #if defined(PLATFORM_WEB) - REG(SetDrawingLoop) + REG(SetDrawingLoop) #else - REG(SetTargetFPS) + REG(SetTargetFPS) #endif - REG(GetFPS) - REG(GetFrameTime) + REG(GetFPS) + REG(GetFrameTime) - REG(GetColor) - REG(GetHexValue) - REG(ColorToFloat) - REG(VectorToFloat) - REG(MatrixToFloat) - REG(GetRandomValue) - REG(Fade) - REG(SetConfigFlags) - REG(ShowLogo) + REG(GetColor) + REG(GetHexValue) + REG(ColorToFloat) + REG(VectorToFloat) + REG(MatrixToFloat) + REG(GetRandomValue) + REG(Fade) + REG(SetConfigFlags) + REG(ShowLogo) - REG(IsFileDropped) - //REG(*GetDroppedFiles) - REG(ClearDroppedFiles) - REG(StorageSaveValue) - REG(StorageLoadValue) + REG(IsFileDropped) + //REG(*GetDroppedFiles) + REG(ClearDroppedFiles) + REG(StorageSaveValue) + REG(StorageLoadValue) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) - REG(IsKeyPressed) - REG(IsKeyDown) - REG(IsKeyReleased) - REG(IsKeyUp) - REG(GetKeyPressed) + REG(IsKeyPressed) + REG(IsKeyDown) + REG(IsKeyReleased) + REG(IsKeyUp) + REG(GetKeyPressed) REG(SetExitKey) - REG(IsGamepadAvailable) + REG(IsGamepadAvailable) REG(GetGamepadAxisMovement) - REG(IsGamepadButtonPressed) - REG(IsGamepadButtonDown) - REG(IsGamepadButtonReleased) - REG(IsGamepadButtonUp) + REG(IsGamepadButtonPressed) + REG(IsGamepadButtonDown) + REG(IsGamepadButtonReleased) + REG(IsGamepadButtonUp) #endif - REG(IsMouseButtonPressed) - REG(IsMouseButtonDown) - REG(IsMouseButtonReleased) - REG(IsMouseButtonUp) - REG(GetMouseX) - REG(GetMouseY) - REG(GetMousePosition) - REG(SetMousePosition) - REG(GetMouseWheelMove) - REG(GetTouchX) - REG(GetTouchY) - REG(GetTouchPosition) + REG(IsMouseButtonPressed) + REG(IsMouseButtonDown) + REG(IsMouseButtonReleased) + REG(IsMouseButtonUp) + REG(GetMouseX) + REG(GetMouseY) + REG(GetMousePosition) + REG(SetMousePosition) + REG(GetMouseWheelMove) + REG(GetTouchX) + REG(GetTouchY) + REG(GetTouchPosition) #if defined(PLATFORM_ANDROID) - REG(IsButtonPressed) - REG(IsButtonDown) - REG(IsButtonReleased) + REG(IsButtonPressed) + REG(IsButtonDown) + REG(IsButtonReleased) #endif - REG(SetGesturesEnabled) - REG(IsGestureDetected) - REG(GetGestureDetected) + REG(SetGesturesEnabled) + REG(IsGestureDetected) + REG(GetGestureDetected) REG(GetTouchPointsCount) - REG(GetGestureHoldDuration) - REG(GetGestureDragVector) - REG(GetGestureDragAngle) - REG(GetGesturePinchVector) - REG(GetGesturePinchAngle) - - REG(SetCameraMode) - REG(UpdateCamera) - REG(UpdateCameraPlayer) - REG(SetCameraPosition) - REG(SetCameraTarget) + REG(GetGestureHoldDuration) + REG(GetGestureDragVector) + REG(GetGestureDragAngle) + REG(GetGesturePinchVector) + REG(GetGesturePinchAngle) + + REG(SetCameraMode) + REG(UpdateCamera) + REG(UpdateCameraPlayer) + REG(SetCameraPosition) + REG(SetCameraTarget) REG(SetCameraFovy) - REG(SetCameraPanControl) - REG(SetCameraAltControl) - REG(SetCameraSmoothZoomControl) - REG(SetCameraMoveControls) - REG(SetCameraMouseSensitivity) + REG(SetCameraPanControl) + REG(SetCameraAltControl) + REG(SetCameraSmoothZoomControl) + REG(SetCameraMoveControls) + REG(SetCameraMouseSensitivity) - REG(DrawPixel) - REG(DrawPixelV) - REG(DrawLine) - REG(DrawLineV) - REG(DrawCircle) - REG(DrawCircleGradient) - REG(DrawCircleV) - REG(DrawCircleLines) - REG(DrawRectangle) - REG(DrawRectangleRec) - REG(DrawRectangleGradient) - REG(DrawRectangleV) - REG(DrawRectangleLines) - REG(DrawTriangle) - REG(DrawTriangleLines) - REG(DrawPoly) - REG(DrawPolyEx) - REG(DrawPolyExLines) + REG(DrawPixel) + REG(DrawPixelV) + REG(DrawLine) + REG(DrawLineV) + REG(DrawCircle) + REG(DrawCircleGradient) + REG(DrawCircleV) + REG(DrawCircleLines) + REG(DrawRectangle) + REG(DrawRectangleRec) + REG(DrawRectangleGradient) + REG(DrawRectangleV) + REG(DrawRectangleLines) + REG(DrawTriangle) + REG(DrawTriangleLines) + REG(DrawPoly) + REG(DrawPolyEx) + REG(DrawPolyExLines) - REG(CheckCollisionRecs) - REG(CheckCollisionCircles) - REG(CheckCollisionCircleRec) - REG(GetCollisionRec) - REG(CheckCollisionPointRec) - REG(CheckCollisionPointCircle) - REG(CheckCollisionPointTriangle) + REG(CheckCollisionRecs) + REG(CheckCollisionCircles) + REG(CheckCollisionCircleRec) + REG(GetCollisionRec) + REG(CheckCollisionPointRec) + REG(CheckCollisionPointCircle) + REG(CheckCollisionPointTriangle) - REG(LoadImage) - REG(LoadImageEx) - REG(LoadImageRaw) - REG(LoadImageFromRES) - REG(LoadTexture) - REG(LoadTextureEx) - REG(LoadTextureFromRES) - REG(LoadTextureFromImage) + REG(LoadImage) + REG(LoadImageEx) + REG(LoadImageRaw) + REG(LoadImageFromRES) + REG(LoadTexture) + REG(LoadTextureEx) + REG(LoadTextureFromRES) + REG(LoadTextureFromImage) REG(LoadRenderTexture) - REG(UnloadImage) - REG(UnloadTexture) - REG(UnloadRenderTexture) - REG(GetImageData) - REG(GetTextureData) - REG(ImageToPOT) - REG(ImageFormat) + REG(UnloadImage) + REG(UnloadTexture) + REG(UnloadRenderTexture) + REG(GetImageData) + REG(GetTextureData) + REG(ImageToPOT) + REG(ImageFormat) REG(ImageDither) REG(ImageCopy) REG(ImageCrop) @@ -3664,192 +3667,188 @@ static luaL_Reg raylib_functions[] = { REG(ImageColorGrayscale) REG(ImageColorContrast) REG(ImageColorBrightness) - REG(GenTextureMipmaps) + REG(GenTextureMipmaps) REG(UpdateTexture) - REG(DrawTexture) - REG(DrawTextureV) - REG(DrawTextureEx) - REG(DrawTextureRec) - REG(DrawTexturePro) + REG(DrawTexture) + REG(DrawTextureV) + REG(DrawTextureEx) + REG(DrawTextureRec) + REG(DrawTexturePro) - REG(GetDefaultFont) - REG(LoadSpriteFont) - REG(UnloadSpriteFont) - REG(DrawText) - REG(DrawTextEx) - REG(MeasureText) - REG(MeasureTextEx) - REG(DrawFPS) - //REG(FormatText) - //REG(SubText) + REG(GetDefaultFont) + REG(LoadSpriteFont) + REG(UnloadSpriteFont) + REG(DrawText) + REG(DrawTextEx) + REG(MeasureText) + REG(MeasureTextEx) + REG(DrawFPS) - REG(DrawCube) - REG(DrawCubeV) - REG(DrawCubeWires) - REG(DrawCubeTexture) - REG(DrawSphere) - REG(DrawSphereEx) - REG(DrawSphereWires) - REG(DrawCylinder) - REG(DrawCylinderWires) - REG(DrawPlane) - REG(DrawRay) - REG(DrawGrid) - REG(DrawGizmo) + REG(DrawCube) + REG(DrawCubeV) + REG(DrawCubeWires) + REG(DrawCubeTexture) + REG(DrawSphere) + REG(DrawSphereEx) + REG(DrawSphereWires) + REG(DrawCylinder) + REG(DrawCylinderWires) + REG(DrawPlane) + REG(DrawRay) + REG(DrawGrid) + REG(DrawGizmo) - REG(LoadModel) - REG(LoadModelEx) + REG(LoadModel) + REG(LoadModelEx) REG(LoadModelFromRES) - REG(LoadHeightmap) - REG(LoadCubicmap) - REG(UnloadModel) - REG(LoadMaterial) - REG(LoadDefaultMaterial) - REG(LoadStandardMaterial) - REG(UnloadMaterial) + REG(LoadHeightmap) + REG(LoadCubicmap) + REG(UnloadModel) + REG(LoadMaterial) + REG(LoadDefaultMaterial) + REG(LoadStandardMaterial) + REG(UnloadMaterial) //REG(GenMesh*) // Not ready yet... - REG(DrawModel) - REG(DrawModelEx) - REG(DrawModelWires) - REG(DrawModelWiresEx) - REG(DrawBillboard) - REG(DrawBillboardRec) + REG(DrawModel) + REG(DrawModelEx) + REG(DrawModelWires) + REG(DrawModelWiresEx) + REG(DrawBillboard) + REG(DrawBillboardRec) REG(CalculateBoundingBox) - REG(CheckCollisionSpheres) - REG(CheckCollisionBoxes) - REG(CheckCollisionBoxSphere) + REG(CheckCollisionSpheres) + REG(CheckCollisionBoxes) + REG(CheckCollisionBoxSphere) REG(CheckCollisionRaySphere) REG(CheckCollisionRaySphereEx) REG(CheckCollisionRayBox) - REG(ResolveCollisionCubicmap) + REG(ResolveCollisionCubicmap) - REG(LoadShader) - REG(UnloadShader) + REG(LoadShader) + REG(UnloadShader) REG(GetDefaultShader) REG(GetStandardShader) REG(GetDefaultTexture) - REG(GetShaderLocation) - REG(SetShaderValue) - REG(SetShaderValuei) - REG(SetShaderValueMatrix) - REG(SetMatrixProjection) - REG(SetMatrixModelview) - REG(BeginShaderMode) - REG(EndShaderMode) - REG(BeginBlendMode) - REG(EndBlendMode) - //REG(CreateLight) - //REG(DestroyLight) + REG(GetShaderLocation) + REG(SetShaderValue) + REG(SetShaderValuei) + REG(SetShaderValueMatrix) + REG(SetMatrixProjection) + REG(SetMatrixModelview) + REG(BeginShaderMode) + REG(EndShaderMode) + REG(BeginBlendMode) + REG(EndBlendMode) + REG(CreateLight) + REG(DestroyLight) - REG(InitVrDevice) - REG(CloseVrDevice) - REG(UpdateVrTracking) - REG(BeginVrDrawing) - REG(EndVrDrawing) - REG(IsVrDeviceReady) - REG(ToggleVrMode) + REG(InitVrDevice) + REG(CloseVrDevice) + REG(IsVrDeviceReady) + REG(UpdateVrTracking) + REG(ToggleVrMode) - REG(InitAudioDevice) - REG(CloseAudioDevice) + REG(InitAudioDevice) + REG(CloseAudioDevice) REG(IsAudioDeviceReady) - REG(LoadSound) - REG(LoadSoundFromWave) - REG(LoadSoundFromRES) - REG(UnloadSound) - REG(PlaySound) - REG(PauseSound) - REG(ResumeSound) - REG(StopSound) - REG(IsSoundPlaying) - REG(SetSoundVolume) - REG(SetSoundPitch) + REG(LoadSound) + REG(LoadSoundFromWave) + REG(LoadSoundFromRES) + REG(UnloadSound) + REG(PlaySound) + REG(PauseSound) + REG(ResumeSound) + REG(StopSound) + REG(IsSoundPlaying) + REG(SetSoundVolume) + REG(SetSoundPitch) - REG(LoadMusicStream) - REG(UnloadMusicStream) - REG(UpdateMusicStream) + REG(LoadMusicStream) + REG(UnloadMusicStream) + REG(UpdateMusicStream) REG(PlayMusicStream) - REG(StopMusicStream) - REG(PauseMusicStream) - REG(ResumeMusicStream) - REG(IsMusicPlaying) - REG(SetMusicVolume) - REG(SetMusicPitch) - REG(GetMusicTimeLength) - REG(GetMusicTimePlayed) + REG(StopMusicStream) + REG(PauseMusicStream) + REG(ResumeMusicStream) + REG(IsMusicPlaying) + REG(SetMusicVolume) + REG(SetMusicPitch) + REG(GetMusicTimeLength) + REG(GetMusicTimePlayed) - REG(InitAudioStream) - REG(UpdateAudioStream) - REG(CloseAudioStream) - REG(IsAudioBufferProcessed) - REG(PlayAudioStream) - REG(PauseAudioStream) - REG(ResumeAudioStream) - REG(StopAudioStream) - - /// Math and util - REG(DecompressData) + REG(InitAudioStream) + REG(UpdateAudioStream) + REG(CloseAudioStream) + REG(IsAudioBufferProcessed) + REG(PlayAudioStream) + REG(PauseAudioStream) + REG(ResumeAudioStream) + REG(StopAudioStream) + + /// Math and util + REG(DecompressData) #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) - REG(WriteBitmap) - REG(WritePNG) + REG(WriteBitmap) + REG(WritePNG) #endif - REG(TraceLog) - REG(GetExtension) - REG(GetNextPOT) - REG(VectorAdd) - REG(VectorSubtract) - REG(VectorCrossProduct) - REG(VectorPerpendicular) - REG(VectorDotProduct) - REG(VectorLength) - REG(VectorScale) - REG(VectorNegate) - REG(VectorNormalize) - REG(VectorDistance) - REG(VectorLerp) - REG(VectorReflect) - REG(VectorTransform) - REG(VectorZero) - REG(MatrixDeterminant) - REG(MatrixTrace) - REG(MatrixTranspose) - REG(MatrixInvert) - REG(MatrixNormalize) - REG(MatrixIdentity) - REG(MatrixAdd) - REG(MatrixSubstract) - REG(MatrixTranslate) - REG(MatrixRotate) - REG(MatrixRotateX) - REG(MatrixRotateY) - REG(MatrixRotateZ) - REG(MatrixScale) - REG(MatrixMultiply) - REG(MatrixFrustum) - REG(MatrixPerspective) - REG(MatrixOrtho) - REG(MatrixLookAt) - REG(QuaternionLength) - REG(QuaternionNormalize) - REG(QuaternionMultiply) - REG(QuaternionSlerp) - REG(QuaternionFromMatrix) - REG(QuaternionToMatrix) - REG(QuaternionFromAxisAngle) - REG(QuaternionToAxisAngle) - REG(QuaternionTransform) - - {0,0} + REG(TraceLog) + REG(GetExtension) + REG(GetNextPOT) + REG(VectorAdd) + REG(VectorSubtract) + REG(VectorCrossProduct) + REG(VectorPerpendicular) + REG(VectorDotProduct) + REG(VectorLength) + REG(VectorScale) + REG(VectorNegate) + REG(VectorNormalize) + REG(VectorDistance) + REG(VectorLerp) + REG(VectorReflect) + REG(VectorTransform) + REG(VectorZero) + REG(MatrixDeterminant) + REG(MatrixTrace) + REG(MatrixTranspose) + REG(MatrixInvert) + REG(MatrixNormalize) + REG(MatrixIdentity) + REG(MatrixAdd) + REG(MatrixSubstract) + REG(MatrixTranslate) + REG(MatrixRotate) + REG(MatrixRotateX) + REG(MatrixRotateY) + REG(MatrixRotateZ) + REG(MatrixScale) + REG(MatrixMultiply) + REG(MatrixFrustum) + REG(MatrixPerspective) + REG(MatrixOrtho) + REG(MatrixLookAt) + REG(QuaternionLength) + REG(QuaternionNormalize) + REG(QuaternionMultiply) + REG(QuaternionSlerp) + REG(QuaternionFromMatrix) + REG(QuaternionToMatrix) + REG(QuaternionFromAxisAngle) + REG(QuaternionToAxisAngle) + REG(QuaternionTransform) + + {0,0} }; // Register raylib functionality static void LuaRegisterRayLib(const char *opt_table) { - if (opt_table) lua_createtable(L, 0, sizeof(raylib_functions)/sizeof(raylib_functions[0])); - else lua_pushglobaltable(L); + if (opt_table) lua_createtable(L, 0, sizeof(raylib_functions)/sizeof(raylib_functions[0])); + else lua_pushglobaltable(L); - luaL_setfuncs(L, raylib_functions, 0); + luaL_setfuncs(L, raylib_functions, 0); } //---------------------------------------------------------------------------------- @@ -3859,210 +3858,216 @@ static void LuaRegisterRayLib(const char *opt_table) // Initialize Lua system RLUADEF void InitLuaDevice(void) { - mainLuaState = luaL_newstate(); - L = mainLuaState; + mainLuaState = luaL_newstate(); + L = mainLuaState; - LuaStartEnum(); - LuaSetEnum("FULLSCREEN_MODE", 1); - LuaSetEnum("SHOW_LOGO", 2); - LuaSetEnum("SHOW_MOUSE_CURSOR", 4); - LuaSetEnum("CENTERED_MODE", 8); - LuaSetEnum("MSAA_4X_HINT", 16); - LuaSetEnum("VSYNC_HINT", 32); - LuaEndEnum("FLAG"); - - LuaStartEnum(); - LuaSetEnum("SPACE", 32); - LuaSetEnum("ESCAPE", 256); - LuaSetEnum("ENTER", 257); - LuaSetEnum("BACKSPACE", 259); - LuaSetEnum("RIGHT", 262); - LuaSetEnum("LEFT", 263); - LuaSetEnum("DOWN", 264); - LuaSetEnum("UP", 265); - LuaSetEnum("F1", 290); - LuaSetEnum("F2", 291); - LuaSetEnum("F3", 292); - LuaSetEnum("F4", 293); - LuaSetEnum("F5", 294); - LuaSetEnum("F6", 295); - LuaSetEnum("F7", 296); - LuaSetEnum("F8", 297); - LuaSetEnum("F9", 298); - LuaSetEnum("F10", 299); - LuaSetEnum("LEFT_SHIFT", 340); - LuaSetEnum("LEFT_CONTROL", 341); - LuaSetEnum("LEFT_ALT", 342); - LuaSetEnum("RIGHT_SHIFT", 344); - LuaSetEnum("RIGHT_CONTROL", 345); - LuaSetEnum("RIGHT_ALT", 346); - LuaSetEnum("ZERO", 48); - LuaSetEnum("ONE", 49); - LuaSetEnum("TWO", 50); - LuaSetEnum("THREE", 51); - LuaSetEnum("FOUR", 52); - LuaSetEnum("FIVE", 53); - LuaSetEnum("SIX", 54); - LuaSetEnum("SEVEN", 55); - LuaSetEnum("EIGHT", 56); - LuaSetEnum("NINE", 57); - LuaSetEnum("A", 65); - LuaSetEnum("B", 66); - LuaSetEnum("C", 67); - LuaSetEnum("D", 68); - LuaSetEnum("E", 69); - LuaSetEnum("F", 70); - LuaSetEnum("G", 71); - LuaSetEnum("H", 72); - LuaSetEnum("I", 73); - LuaSetEnum("J", 74); - LuaSetEnum("K", 75); - LuaSetEnum("L", 76); - LuaSetEnum("M", 77); - LuaSetEnum("N", 78); - LuaSetEnum("O", 79); - LuaSetEnum("P", 80); - LuaSetEnum("Q", 81); - LuaSetEnum("R", 82); - LuaSetEnum("S", 83); - LuaSetEnum("T", 84); - LuaSetEnum("U", 85); - LuaSetEnum("V", 86); - LuaSetEnum("W", 87); - LuaSetEnum("X", 88); - LuaSetEnum("Y", 89); - LuaSetEnum("Z", 90); - LuaEndEnum("KEY"); - - LuaStartEnum(); - LuaSetEnum("LEFT_BUTTON", 0); - LuaSetEnum("RIGHT_BUTTON", 1); - LuaSetEnum("MIDDLE_BUTTON", 2); - LuaEndEnum("MOUSE"); - - LuaStartEnum(); - LuaSetEnum("PLAYER1", 0); - LuaSetEnum("PLAYER2", 1); - LuaSetEnum("PLAYER3", 2); - LuaSetEnum("PLAYER4", 3); - - LuaSetEnum("BUTTON_A", 2); - LuaSetEnum("BUTTON_B", 1); - LuaSetEnum("BUTTON_X", 3); - LuaSetEnum("BUTTON_Y", 4); - LuaSetEnum("BUTTON_R1", 7); - LuaSetEnum("BUTTON_R2", 5); - LuaSetEnum("BUTTON_L1", 6); - LuaSetEnum("BUTTON_L2", 8); - LuaSetEnum("BUTTON_SELECT", 9); - LuaSetEnum("BUTTON_START", 10); + LuaStartEnum(); + LuaSetEnum("FULLSCREEN_MODE", 1); + LuaSetEnum("SHOW_LOGO", 2); + LuaSetEnum("SHOW_MOUSE_CURSOR", 4); + LuaSetEnum("CENTERED_MODE", 8); + LuaSetEnum("MSAA_4X_HINT", 16); + LuaSetEnum("VSYNC_HINT", 32); + LuaEndEnum("FLAG"); + + LuaStartEnum(); + LuaSetEnum("SPACE", 32); + LuaSetEnum("ESCAPE", 256); + LuaSetEnum("ENTER", 257); + LuaSetEnum("BACKSPACE", 259); + LuaSetEnum("RIGHT", 262); + LuaSetEnum("LEFT", 263); + LuaSetEnum("DOWN", 264); + LuaSetEnum("UP", 265); + LuaSetEnum("F1", 290); + LuaSetEnum("F2", 291); + LuaSetEnum("F3", 292); + LuaSetEnum("F4", 293); + LuaSetEnum("F5", 294); + LuaSetEnum("F6", 295); + LuaSetEnum("F7", 296); + LuaSetEnum("F8", 297); + LuaSetEnum("F9", 298); + LuaSetEnum("F10", 299); + LuaSetEnum("LEFT_SHIFT", 340); + LuaSetEnum("LEFT_CONTROL", 341); + LuaSetEnum("LEFT_ALT", 342); + LuaSetEnum("RIGHT_SHIFT", 344); + LuaSetEnum("RIGHT_CONTROL", 345); + LuaSetEnum("RIGHT_ALT", 346); + LuaSetEnum("ZERO", 48); + LuaSetEnum("ONE", 49); + LuaSetEnum("TWO", 50); + LuaSetEnum("THREE", 51); + LuaSetEnum("FOUR", 52); + LuaSetEnum("FIVE", 53); + LuaSetEnum("SIX", 54); + LuaSetEnum("SEVEN", 55); + LuaSetEnum("EIGHT", 56); + LuaSetEnum("NINE", 57); + LuaSetEnum("A", 65); + LuaSetEnum("B", 66); + LuaSetEnum("C", 67); + LuaSetEnum("D", 68); + LuaSetEnum("E", 69); + LuaSetEnum("F", 70); + LuaSetEnum("G", 71); + LuaSetEnum("H", 72); + LuaSetEnum("I", 73); + LuaSetEnum("J", 74); + LuaSetEnum("K", 75); + LuaSetEnum("L", 76); + LuaSetEnum("M", 77); + LuaSetEnum("N", 78); + LuaSetEnum("O", 79); + LuaSetEnum("P", 80); + LuaSetEnum("Q", 81); + LuaSetEnum("R", 82); + LuaSetEnum("S", 83); + LuaSetEnum("T", 84); + LuaSetEnum("U", 85); + LuaSetEnum("V", 86); + LuaSetEnum("W", 87); + LuaSetEnum("X", 88); + LuaSetEnum("Y", 89); + LuaSetEnum("Z", 90); + LuaEndEnum("KEY"); + + LuaStartEnum(); + LuaSetEnum("LEFT_BUTTON", 0); + LuaSetEnum("RIGHT_BUTTON", 1); + LuaSetEnum("MIDDLE_BUTTON", 2); + LuaEndEnum("MOUSE"); + + LuaStartEnum(); + LuaSetEnum("PLAYER1", 0); + LuaSetEnum("PLAYER2", 1); + LuaSetEnum("PLAYER3", 2); + LuaSetEnum("PLAYER4", 3); + + LuaSetEnum("BUTTON_A", 2); + LuaSetEnum("BUTTON_B", 1); + LuaSetEnum("BUTTON_X", 3); + LuaSetEnum("BUTTON_Y", 4); + LuaSetEnum("BUTTON_R1", 7); + LuaSetEnum("BUTTON_R2", 5); + LuaSetEnum("BUTTON_L1", 6); + LuaSetEnum("BUTTON_L2", 8); + LuaSetEnum("BUTTON_SELECT", 9); + LuaSetEnum("BUTTON_START", 10); - LuaSetEnum("XBOX_BUTTON_A", 0); - LuaSetEnum("XBOX_BUTTON_B", 1); - LuaSetEnum("XBOX_BUTTON_X", 2); - LuaSetEnum("XBOX_BUTTON_Y", 3); - LuaSetEnum("XBOX_BUTTON_LB", 4); - LuaSetEnum("XBOX_BUTTON_RB", 5); - LuaSetEnum("XBOX_BUTTON_SELECT", 6); - LuaSetEnum("XBOX_BUTTON_START", 7); + LuaSetEnum("XBOX_BUTTON_A", 0); + LuaSetEnum("XBOX_BUTTON_B", 1); + LuaSetEnum("XBOX_BUTTON_X", 2); + LuaSetEnum("XBOX_BUTTON_Y", 3); + LuaSetEnum("XBOX_BUTTON_LB", 4); + LuaSetEnum("XBOX_BUTTON_RB", 5); + LuaSetEnum("XBOX_BUTTON_SELECT", 6); + LuaSetEnum("XBOX_BUTTON_START", 7); #if defined(PLATFORM_RPI) - LuaSetEnum("XBOX_AXIS_DPAD_X", 7); - LuaSetEnum("XBOX_AXIS_DPAD_Y", 6); - LuaSetEnum("XBOX_AXIS_RIGHT_X", 3); - LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4); - LuaSetEnum("XBOX_AXIS_LT", 2); - LuaSetEnum("XBOX_AXIS_RT", 5); + LuaSetEnum("XBOX_AXIS_DPAD_X", 7); + LuaSetEnum("XBOX_AXIS_DPAD_Y", 6); + LuaSetEnum("XBOX_AXIS_RIGHT_X", 3); + LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4); + LuaSetEnum("XBOX_AXIS_LT", 2); + LuaSetEnum("XBOX_AXIS_RT", 5); #else - LuaSetEnum("XBOX_BUTTON_UP", 10); - LuaSetEnum("XBOX_BUTTON_DOWN", 12); - LuaSetEnum("XBOX_BUTTON_LEFT", 13); - LuaSetEnum("XBOX_BUTTON_RIGHT", 11); - LuaSetEnum("XBOX_AXIS_RIGHT_X", 4); - LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3); - LuaSetEnum("XBOX_AXIS_LT_RT", 2); + LuaSetEnum("XBOX_BUTTON_UP", 10); + LuaSetEnum("XBOX_BUTTON_DOWN", 12); + LuaSetEnum("XBOX_BUTTON_LEFT", 13); + LuaSetEnum("XBOX_BUTTON_RIGHT", 11); + LuaSetEnum("XBOX_AXIS_RIGHT_X", 4); + LuaSetEnum("XBOX_AXIS_RIGHT_Y", 3); + LuaSetEnum("XBOX_AXIS_LT_RT", 2); #endif - LuaSetEnum("XBOX_AXIS_LEFT_X", 0); - LuaSetEnum("XBOX_AXIS_LEFT_Y", 1); - LuaEndEnum("GAMEPAD"); - - lua_pushglobaltable(L); - LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY); - LuaSetEnumColor("GRAY", GRAY); - LuaSetEnumColor("DARKGRAY", DARKGRAY); - LuaSetEnumColor("YELLOW", YELLOW); - LuaSetEnumColor("GOLD", GOLD); - LuaSetEnumColor("ORANGE", ORANGE); - LuaSetEnumColor("PINK", PINK); - LuaSetEnumColor("RED", RED); - LuaSetEnumColor("MAROON", MAROON); - LuaSetEnumColor("GREEN", GREEN); - LuaSetEnumColor("LIME", LIME); - LuaSetEnumColor("DARKGREEN", DARKGREEN); - LuaSetEnumColor("SKYBLUE", SKYBLUE); - LuaSetEnumColor("BLUE", BLUE); - LuaSetEnumColor("DARKBLUE", DARKBLUE); - LuaSetEnumColor("PURPLE", PURPLE); - LuaSetEnumColor("VIOLET", VIOLET); - LuaSetEnumColor("DARKPURPLE", DARKPURPLE); - LuaSetEnumColor("BEIGE", BEIGE); - LuaSetEnumColor("BROWN", BROWN); - LuaSetEnumColor("DARKBROWN", DARKBROWN); - LuaSetEnumColor("WHITE", WHITE); - LuaSetEnumColor("BLACK", BLACK); - LuaSetEnumColor("BLANK", BLANK); - LuaSetEnumColor("MAGENTA", MAGENTA); - LuaSetEnumColor("RAYWHITE", RAYWHITE); - lua_pop(L, 1); - - LuaStartEnum(); - LuaSetEnum("UNCOMPRESSED_GRAYSCALE", UNCOMPRESSED_GRAYSCALE); - LuaSetEnum("UNCOMPRESSED_GRAY_ALPHA", UNCOMPRESSED_GRAY_ALPHA); - LuaSetEnum("UNCOMPRESSED_R5G6B5", UNCOMPRESSED_R5G6B5); - LuaSetEnum("UNCOMPRESSED_R8G8B8", UNCOMPRESSED_R8G8B8); - LuaSetEnum("UNCOMPRESSED_R5G5B5A1", UNCOMPRESSED_R5G5B5A1); - LuaSetEnum("UNCOMPRESSED_R4G4B4A4", UNCOMPRESSED_R4G4B4A4); - LuaSetEnum("UNCOMPRESSED_R8G8B8A8", UNCOMPRESSED_R8G8B8A8); - LuaSetEnum("COMPRESSED_DXT1_RGB", COMPRESSED_DXT1_RGB); - LuaSetEnum("COMPRESSED_DXT1_RGBA", COMPRESSED_DXT1_RGBA); - LuaSetEnum("COMPRESSED_DXT3_RGBA", COMPRESSED_DXT3_RGBA); - LuaSetEnum("COMPRESSED_DXT5_RGBA", COMPRESSED_DXT5_RGBA); - LuaSetEnum("COMPRESSED_ETC1_RGB", COMPRESSED_ETC1_RGB); - LuaSetEnum("COMPRESSED_ETC2_RGB", COMPRESSED_ETC2_RGB); - LuaSetEnum("COMPRESSED_ETC2_EAC_RGBA", COMPRESSED_ETC2_EAC_RGBA); - LuaSetEnum("COMPRESSED_PVRT_RGB", COMPRESSED_PVRT_RGB); - LuaSetEnum("COMPRESSED_PVRT_RGBA", COMPRESSED_PVRT_RGBA); - LuaSetEnum("COMPRESSED_ASTC_4x4_RGBA", COMPRESSED_ASTC_4x4_RGBA); - LuaSetEnum("COMPRESSED_ASTC_8x8_RGBA", COMPRESSED_ASTC_8x8_RGBA); - LuaEndEnum("TextureFormat"); - - LuaStartEnum(); - LuaSetEnum("ALPHA", BLEND_ALPHA); - LuaSetEnum("ADDITIVE", BLEND_ADDITIVE); - LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED); - LuaEndEnum("BlendMode"); - - LuaStartEnum(); - LuaSetEnum("NONE", GESTURE_NONE); - LuaSetEnum("TAP", GESTURE_TAP); - LuaSetEnum("DOUBLETAP", GESTURE_DOUBLETAP); - LuaSetEnum("HOLD", GESTURE_HOLD); - LuaSetEnum("DRAG", GESTURE_DRAG); - LuaSetEnum("SWIPE_RIGHT", GESTURE_SWIPE_RIGHT); - LuaSetEnum("SWIPE_LEFT", GESTURE_SWIPE_LEFT); - LuaSetEnum("SWIPE_UP", GESTURE_SWIPE_UP); - LuaSetEnum("SWIPE_DOWN", GESTURE_SWIPE_DOWN); - LuaSetEnum("PINCH_IN", GESTURE_PINCH_IN); - LuaSetEnum("PINCH_OUT", GESTURE_PINCH_OUT); - LuaEndEnum("Gestures"); - - LuaStartEnum(); - LuaSetEnum("CUSTOM", CAMERA_CUSTOM); - LuaSetEnum("FREE", CAMERA_FREE); - LuaSetEnum("ORBITAL", CAMERA_ORBITAL); - LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON); - LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON); - LuaEndEnum("CameraMode"); + LuaSetEnum("XBOX_AXIS_LEFT_X", 0); + LuaSetEnum("XBOX_AXIS_LEFT_Y", 1); + LuaEndEnum("GAMEPAD"); + + lua_pushglobaltable(L); + LuaSetEnumColor("LIGHTGRAY", LIGHTGRAY); + LuaSetEnumColor("GRAY", GRAY); + LuaSetEnumColor("DARKGRAY", DARKGRAY); + LuaSetEnumColor("YELLOW", YELLOW); + LuaSetEnumColor("GOLD", GOLD); + LuaSetEnumColor("ORANGE", ORANGE); + LuaSetEnumColor("PINK", PINK); + LuaSetEnumColor("RED", RED); + LuaSetEnumColor("MAROON", MAROON); + LuaSetEnumColor("GREEN", GREEN); + LuaSetEnumColor("LIME", LIME); + LuaSetEnumColor("DARKGREEN", DARKGREEN); + LuaSetEnumColor("SKYBLUE", SKYBLUE); + LuaSetEnumColor("BLUE", BLUE); + LuaSetEnumColor("DARKBLUE", DARKBLUE); + LuaSetEnumColor("PURPLE", PURPLE); + LuaSetEnumColor("VIOLET", VIOLET); + LuaSetEnumColor("DARKPURPLE", DARKPURPLE); + LuaSetEnumColor("BEIGE", BEIGE); + LuaSetEnumColor("BROWN", BROWN); + LuaSetEnumColor("DARKBROWN", DARKBROWN); + LuaSetEnumColor("WHITE", WHITE); + LuaSetEnumColor("BLACK", BLACK); + LuaSetEnumColor("BLANK", BLANK); + LuaSetEnumColor("MAGENTA", MAGENTA); + LuaSetEnumColor("RAYWHITE", RAYWHITE); + lua_pop(L, 1); + + LuaStartEnum(); + LuaSetEnum("UNCOMPRESSED_GRAYSCALE", UNCOMPRESSED_GRAYSCALE); + LuaSetEnum("UNCOMPRESSED_GRAY_ALPHA", UNCOMPRESSED_GRAY_ALPHA); + LuaSetEnum("UNCOMPRESSED_R5G6B5", UNCOMPRESSED_R5G6B5); + LuaSetEnum("UNCOMPRESSED_R8G8B8", UNCOMPRESSED_R8G8B8); + LuaSetEnum("UNCOMPRESSED_R5G5B5A1", UNCOMPRESSED_R5G5B5A1); + LuaSetEnum("UNCOMPRESSED_R4G4B4A4", UNCOMPRESSED_R4G4B4A4); + LuaSetEnum("UNCOMPRESSED_R8G8B8A8", UNCOMPRESSED_R8G8B8A8); + LuaSetEnum("COMPRESSED_DXT1_RGB", COMPRESSED_DXT1_RGB); + LuaSetEnum("COMPRESSED_DXT1_RGBA", COMPRESSED_DXT1_RGBA); + LuaSetEnum("COMPRESSED_DXT3_RGBA", COMPRESSED_DXT3_RGBA); + LuaSetEnum("COMPRESSED_DXT5_RGBA", COMPRESSED_DXT5_RGBA); + LuaSetEnum("COMPRESSED_ETC1_RGB", COMPRESSED_ETC1_RGB); + LuaSetEnum("COMPRESSED_ETC2_RGB", COMPRESSED_ETC2_RGB); + LuaSetEnum("COMPRESSED_ETC2_EAC_RGBA", COMPRESSED_ETC2_EAC_RGBA); + LuaSetEnum("COMPRESSED_PVRT_RGB", COMPRESSED_PVRT_RGB); + LuaSetEnum("COMPRESSED_PVRT_RGBA", COMPRESSED_PVRT_RGBA); + LuaSetEnum("COMPRESSED_ASTC_4x4_RGBA", COMPRESSED_ASTC_4x4_RGBA); + LuaSetEnum("COMPRESSED_ASTC_8x8_RGBA", COMPRESSED_ASTC_8x8_RGBA); + LuaEndEnum("TextureFormat"); + + LuaStartEnum(); + LuaSetEnum("ALPHA", BLEND_ALPHA); + LuaSetEnum("ADDITIVE", BLEND_ADDITIVE); + LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED); + LuaEndEnum("BlendMode"); + + LuaStartEnum(); + LuaSetEnum("POINT", LIGHT_POINT); + LuaSetEnum("DIRECTIONAL", LIGHT_DIRECTIONAL); + LuaSetEnum("SPOT", LIGHT_SPOT); + LuaEndEnum("LightType"); + + LuaStartEnum(); + LuaSetEnum("NONE", GESTURE_NONE); + LuaSetEnum("TAP", GESTURE_TAP); + LuaSetEnum("DOUBLETAP", GESTURE_DOUBLETAP); + LuaSetEnum("HOLD", GESTURE_HOLD); + LuaSetEnum("DRAG", GESTURE_DRAG); + LuaSetEnum("SWIPE_RIGHT", GESTURE_SWIPE_RIGHT); + LuaSetEnum("SWIPE_LEFT", GESTURE_SWIPE_LEFT); + LuaSetEnum("SWIPE_UP", GESTURE_SWIPE_UP); + LuaSetEnum("SWIPE_DOWN", GESTURE_SWIPE_DOWN); + LuaSetEnum("PINCH_IN", GESTURE_PINCH_IN); + LuaSetEnum("PINCH_OUT", GESTURE_PINCH_OUT); + LuaEndEnum("Gestures"); + + LuaStartEnum(); + LuaSetEnum("CUSTOM", CAMERA_CUSTOM); + LuaSetEnum("FREE", CAMERA_FREE); + LuaSetEnum("ORBITAL", CAMERA_ORBITAL); + LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON); + LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON); + LuaEndEnum("CameraMode"); LuaStartEnum(); LuaSetEnum("DEFAULT_DEVICE", HMD_DEFAULT_DEVICE); @@ -4074,82 +4079,82 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("SONY_PLAYSTATION_VR", HMD_SONY_PLAYSTATION_VR); LuaSetEnum("RAZER_OSVR", HMD_RAZER_OSVR); LuaSetEnum("FOVE_VR", HMD_FOVE_VR); - LuaEndEnum("VrDevice"); + LuaEndEnum("VrDevice"); - lua_pushglobaltable(L); - LuaSetEnum("INFO", INFO); - LuaSetEnum("ERROR", ERROR); - LuaSetEnum("WARNING", WARNING); - LuaSetEnum("DEBUG", DEBUG); - LuaSetEnum("OTHER", OTHER); - lua_pop(L, 1); + lua_pushglobaltable(L); + LuaSetEnum("INFO", INFO); + LuaSetEnum("ERROR", ERROR); + LuaSetEnum("WARNING", WARNING); + LuaSetEnum("DEBUG", DEBUG); + LuaSetEnum("OTHER", OTHER); + lua_pop(L, 1); - lua_pushboolean(L, true); + lua_pushboolean(L, true); #if defined(PLATFORM_DESKTOP) - lua_setglobal(L, "PLATFORM_DESKTOP"); + lua_setglobal(L, "PLATFORM_DESKTOP"); #elif defined(PLATFORM_ANDROID) - lua_setglobal(L, "PLATFORM_ANDROID"); + lua_setglobal(L, "PLATFORM_ANDROID"); #elif defined(PLATFORM_RPI) - lua_setglobal(L, "PLATFORM_RPI"); + lua_setglobal(L, "PLATFORM_RPI"); #elif defined(PLATFORM_WEB) - lua_setglobal(L, "PLATFORM_WEB"); + lua_setglobal(L, "PLATFORM_WEB"); #endif - luaL_openlibs(L); - LuaBuildOpaqueMetatables(); + luaL_openlibs(L); + LuaBuildOpaqueMetatables(); - LuaRegisterRayLib(0); + LuaRegisterRayLib(0); } // De-initialize Lua system RLUADEF void CloseLuaDevice(void) { - if (mainLuaState) - { - lua_close(mainLuaState); - mainLuaState = 0; - L = 0; - } + if (mainLuaState) + { + lua_close(mainLuaState); + mainLuaState = 0; + L = 0; + } } // Execute raylib Lua code RLUADEF void ExecuteLuaCode(const char *code) { - if (!mainLuaState) - { - TraceLog(WARNING, "Lua device not initialized"); - return; - } + if (!mainLuaState) + { + TraceLog(WARNING, "Lua device not initialized"); + return; + } - int result = luaL_dostring(L, code); + int result = luaL_dostring(L, code); - switch (result) - { + switch (result) + { case LUA_OK: break; case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1)); break; case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1)); break; default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1)); break; - } + } } // Execute raylib Lua script RLUADEF void ExecuteLuaFile(const char *filename) { - if (!mainLuaState) - { - TraceLog(WARNING, "Lua device not initialized"); - return; - } + if (!mainLuaState) + { + TraceLog(WARNING, "Lua device not initialized"); + return; + } - int result = luaL_dofile(L, filename); + int result = luaL_dofile(L, filename); - switch (result) - { + switch (result) + { case LUA_OK: break; case LUA_ERRRUN: TraceLog(ERROR, "Lua Runtime Error: %s", lua_tostring(L, -1)); case LUA_ERRMEM: TraceLog(ERROR, "Lua Memory Error: %s", lua_tostring(L, -1)); default: TraceLog(ERROR, "Lua Error: %s", lua_tostring(L, -1)); - } + } } #endif // RLUA_IMPLEMENTATION -- cgit v1.2.3 From 6f27941e286eba9872d1c341b446c9d13272405a Mon Sep 17 00:00:00 2001 From: ghassanpl Date: Sat, 6 Aug 2016 21:51:08 +0200 Subject: GetDroppedFiles and SetShaderValue in Lua working Exposed Texture2D.id to Lua Lights now have settable/gettable fields --- examples/core_drop_files.lua | 9 ++-- examples/shaders_custom_uniform.lua | 6 +-- src/rlua.h | 102 ++++++++++++++++++++++++++++++------ 3 files changed, 96 insertions(+), 21 deletions(-) (limited to 'src/rlua.h') diff --git a/examples/core_drop_files.lua b/examples/core_drop_files.lua index 0a437422..99ab4325 100644 --- a/examples/core_drop_files.lua +++ b/examples/core_drop_files.lua @@ -28,7 +28,10 @@ SetTargetFPS(60) while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- - if (IsFileDropped()) then droppedFiles = GetDroppedFiles(count) end + if (IsFileDropped()) then + droppedFiles = GetDroppedFiles() + count = #droppedFiles + end --------------------------------------------------------------------------------------- -- Draw @@ -41,11 +44,11 @@ while not WindowShouldClose() do -- Detect window close button or ESC key else DrawText("Dropped files:", 100, 40, 20, DARKGRAY) - for i = 0, count do + for i = 0, count-1 do if (i%2 == 0) then DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.5)) else DrawRectangle(0, 85 + 40*i, screenWidth, 40, Fade(LIGHTGRAY, 0.3)) end - DrawText(droppedFiles[i], 120, 100 + 40*i, 10, GRAY) + DrawText(droppedFiles[i+1], 120, 100 + 40*i, 10, GRAY) end DrawText("Drop new files...", 100, 110 + 40*count, 20, DARKGRAY) diff --git a/examples/shaders_custom_uniform.lua b/examples/shaders_custom_uniform.lua index fb93adc1..3a8bbae5 100644 --- a/examples/shaders_custom_uniform.lua +++ b/examples/shaders_custom_uniform.lua @@ -60,11 +60,11 @@ while not WindowShouldClose() do -- Detect window close button or ESC key --------------------------------------------------------------------------------------- local mousePosition = GetMousePosition() - swirlCenter[0] = mousePosition.x - swirlCenter[1] = screenHeight - mousePosition.y + swirlCenter[1] = mousePosition.x + swirlCenter[2] = screenHeight - mousePosition.y -- Send new value to the shader to be used on drawing - SetShaderValue(shader, swirlCenterLoc, swirlCenter, 2) + SetShaderValue(shader, swirlCenterLoc, swirlCenter) camera = UpdateCamera(camera) -- Update internal camera and our camera --------------------------------------------------------------------------------------- diff --git a/src/rlua.h b/src/rlua.h index 08ffbca0..fb3a6698 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -126,7 +126,7 @@ RLUADEF void CloseLuaDevice(void); // De-initialize Lua system #define LuaPush_SpriteFont(L, sf) LuaPushOpaqueTypeWithMetatable(L, sf, SpriteFont) #define LuaPush_Mesh(L, vd) LuaPushOpaqueType(L, vd) #define LuaPush_Shader(L, s) LuaPushOpaqueType(L, s) -#define LuaPush_Light(L, light) LuaPushOpaqueType(L, light) +#define LuaPush_Light(L, light) LuaPushOpaqueTypeWithMetatable(L, light, Light) #define LuaPush_Sound(L, snd) LuaPushOpaqueType(L, snd) #define LuaPush_Wave(L, wav) LuaPushOpaqueType(L, wav) #define LuaPush_Music(L, mus) LuaPushOpaqueType(L, mus) @@ -263,6 +263,8 @@ static int LuaIndexTexture2D(lua_State* L) lua_pushinteger(L, img.mipmaps); else if (!strcmp(key, "format")) lua_pushinteger(L, img.format); + else if (!strcmp(key, "id")) + lua_pushinteger(L, img.id); else return 0; return 1; @@ -296,6 +298,58 @@ static int LuaIndexSpriteFont(lua_State* L) return 1; } +static int LuaIndexLight(lua_State* L) +{ + Light light = LuaGetArgument_Light(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "id")) + lua_pushinteger(L, light->id); + else if (!strcmp(key, "enabled")) + lua_pushboolean(L, light->enabled); + else if (!strcmp(key, "type")) + lua_pushinteger(L, light->type); + else if (!strcmp(key, "position")) + LuaPush_Vector3(L, light->position); + else if (!strcmp(key, "target")) + LuaPush_Vector3(L, light->target); + else if (!strcmp(key, "radius")) + lua_pushnumber(L, light->radius); + else if (!strcmp(key, "diffuse")) + LuaPush_Color(L, light->diffuse); + else if (!strcmp(key, "intensity")) + lua_pushnumber(L, light->intensity); + else if (!strcmp(key, "coneAngle")) + lua_pushnumber(L, light->coneAngle); + else + return 0; + return 1; +} + +static int LuaNewIndexLight(lua_State* L) +{ + Light light = LuaGetArgument_Light(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "id")) + light->id = LuaGetArgument_int(L, 3); + else if (!strcmp(key, "enabled")) + light->enabled = lua_toboolean(L, 3); + else if (!strcmp(key, "type")) + light->type = LuaGetArgument_int(L, 3); + else if (!strcmp(key, "position")) + light->position = LuaGetArgument_Vector3(L, 3); + else if (!strcmp(key, "target")) + light->target = LuaGetArgument_Vector3(L, 3); + else if (!strcmp(key, "radius")) + light->radius = LuaGetArgument_float(L, 3); + else if (!strcmp(key, "diffuse")) + light->diffuse = LuaGetArgument_Color(L, 3); + else if (!strcmp(key, "intensity")) + light->intensity = LuaGetArgument_float(L, 3); + else if (!strcmp(key, "coneAngle")) + light->coneAngle = LuaGetArgument_float(L, 3); + return 0; +} + static void LuaBuildOpaqueMetatables(void) { luaL_newmetatable(L, "Image"); @@ -313,10 +367,17 @@ static void LuaBuildOpaqueMetatables(void) lua_setfield(L, -2, "__index"); lua_pop(L, 1); - luaL_newmetatable(L, "SpriteFont"); - lua_pushcfunction(L, &LuaIndexSpriteFont); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + luaL_newmetatable(L, "SpriteFont"); + lua_pushcfunction(L, &LuaIndexSpriteFont); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); + + luaL_newmetatable(L, "Light"); + lua_pushcfunction(L, &LuaIndexLight); + lua_setfield(L, -2, "__index"); + lua_pushcfunction(L, &LuaNewIndexLight); + lua_setfield(L, -2, "__newindex"); + lua_pop(L, 1); } //---------------------------------------------------------------------------------- @@ -1057,15 +1118,20 @@ int lua_IsFileDropped(lua_State* L) lua_pushboolean(L, result); return 1; } -/* -int lua_*GetDroppedFiles(lua_State* L) + +int lua_GetDroppedFiles(lua_State* L) { - int * arg1 = LuaGetArgument_int *(L, 1); - //char * result = *GetDroppedFiles(arg1); - LuaPush_//char *(L, result); - return 1; + int count = 0; + char ** result = GetDroppedFiles(&count); + lua_createtable(L, count, 0); + for (int i = 0; i < count; i++) + { + lua_pushstring(L, result[i]); + lua_rawseti(L, -2, i + 1); + } + return 1; } -*/ + int lua_ClearDroppedFiles(lua_State* L) { ClearDroppedFiles(); @@ -1638,7 +1704,6 @@ int lua_DrawPoly(lua_State* L) sz++; \ lua_pop(L, 1); \ } \ - lua_pop(L, 1); \ name = calloc(sz, sizeof(type)); \ sz = 0; \ lua_pushnil(L); \ @@ -2334,7 +2399,12 @@ int lua_DrawGizmo(lua_State* L) return 0; } -// TODO: DrawLight(Light light); +int lua_DrawLight(lua_State* L) +{ + Light arg1 = LuaGetArgument_Light(L, 1); + DrawLight(arg1); + return 0; +} int lua_Draw3DLine(lua_State* L) { @@ -3544,7 +3614,7 @@ static luaL_Reg raylib_functions[] = { REG(ShowLogo) REG(IsFileDropped) - //REG(*GetDroppedFiles) + REG(GetDroppedFiles) REG(ClearDroppedFiles) REG(StorageSaveValue) REG(StorageLoadValue) @@ -3698,6 +3768,8 @@ static luaL_Reg raylib_functions[] = { REG(DrawRay) REG(DrawGrid) REG(DrawGizmo) + + REG(DrawLight) REG(LoadModel) REG(LoadModelEx) -- cgit v1.2.3 From 47b6e627449187f5385e9beafeda3b8517faae26 Mon Sep 17 00:00:00 2001 From: ghassanpl Date: Sat, 6 Aug 2016 22:14:49 +0200 Subject: Fixed bug with BoundingBox Lua constructor Fixed use-after-free in DestroyLight --- src/rlgl.c | 7 ++++--- src/rlua.h | 2 +- 2 files changed, 5 insertions(+), 4 deletions(-) (limited to 'src/rlua.h') diff --git a/src/rlgl.c b/src/rlgl.c index d027495f..6fb4bf3d 100644 --- a/src/rlgl.c +++ b/src/rlgl.c @@ -2559,11 +2559,13 @@ void DestroyLight(Light light) { if (light != NULL) { + int light_id = light->id; + // Free dynamic memory allocation - free(lights[light->id]); + free(lights[light_id]); // Remove *obj from the pointers array - for (int i = light->id; i < lightsCount; i++) + for (int i = light_id; i < lightsCount; i++) { // Resort all the following pointers of the array if ((i + 1) < lightsCount) @@ -2571,7 +2573,6 @@ void DestroyLight(Light light) lights[i] = lights[i + 1]; lights[i]->id = lights[i + 1]->id; } - else free(lights[i]); } // Decrease enabled physic objects count diff --git a/src/rlua.h b/src/rlua.h index fb3a6698..85853793 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -768,7 +768,7 @@ static int lua_BoundingBox(lua_State* L) { Vector3 min = LuaGetArgument_Vector3(L, 1); Vector3 max = LuaGetArgument_Vector3(L, 2); - LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y }, { max.x, max.y } }); + LuaPush_BoundingBox(L, (BoundingBox) { { min.x, min.y, min.z }, { max.x, max.y, max.z } }); return 1; } -- cgit v1.2.3 From 2c079d7c6ea0a5a252f0d3f93bc39e8f5700e23a Mon Sep 17 00:00:00 2001 From: Ray Date: Sun, 7 Aug 2016 11:14:08 +0200 Subject: Review Lua examples and formatting --- examples/core_drop_files.lua | 8 ++-- examples/rlua_execute_file.c | 14 +++--- src/rlgl.c | 8 ++-- src/rlua.h | 100 +++++++++++++++++++++---------------------- 4 files changed, 65 insertions(+), 65 deletions(-) (limited to 'src/rlua.h') diff --git a/examples/core_drop_files.lua b/examples/core_drop_files.lua index 99ab4325..1d27e618 100644 --- a/examples/core_drop_files.lua +++ b/examples/core_drop_files.lua @@ -19,7 +19,7 @@ local screenHeight = 450 InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files") local count = 0 ---char **droppedFiles -- ??? +local droppedFiles = {} SetTargetFPS(60) ------------------------------------------------------------------------------------------- @@ -29,9 +29,9 @@ while not WindowShouldClose() do -- Detect window close button or ESC key -- Update --------------------------------------------------------------------------------------- if (IsFileDropped()) then - droppedFiles = GetDroppedFiles() - count = #droppedFiles - end + droppedFiles = GetDroppedFiles() + count = #droppedFiles + end --------------------------------------------------------------------------------------- -- Draw diff --git a/examples/rlua_execute_file.c b/examples/rlua_execute_file.c index 6050cf14..71720313 100644 --- a/examples/rlua_execute_file.c +++ b/examples/rlua_execute_file.c @@ -35,11 +35,11 @@ int main() // ExecuteLuaFile("core_input_gamepad.lua"); // OK! // ExecuteLuaFile("core_random_values.lua"); // OK! // ExecuteLuaFile("core_color_select.lua"); // OK! - // ExecuteLuaFile("core_drop_files.lua"); // ERROR: GetDroppedFiles() + // ExecuteLuaFile("core_drop_files.lua"); // OK! // ExecuteLuaFile("core_storage_values.lua"); // OK! // ExecuteLuaFile("core_gestures_detection.lua"); // OK! // ExecuteLuaFile("core_3d_mode.lua"); // OK! - // ExecuteLuaFile("core_3d_picking.lua"); // ISSUE: CheckCollisionRayBox() returns false despite touching box + // ExecuteLuaFile("core_3d_picking.lua"); // OK! // ExecuteLuaFile("core_3d_camera_free.lua"); // OK! // ExecuteLuaFile("core_3d_camera_first_person.lua"); // OK! // ExecuteLuaFile("core_2d_camera.lua"); // OK! @@ -54,8 +54,8 @@ int main() // ExecuteLuaFile("textures_rectangle.lua"); // OK! // ExecuteLuaFile("textures_srcrec_dstrec.lua"); // OK! // ExecuteLuaFile("textures_to_image.lua"); // OK! - // ExecuteLuaFile("textures_raw_data.lua"); // ERROR: bad argument #2 to 'LoadImageEx' (number expected, got no value) - // ExecuteLuaFile("textures_formats_loading.lua"); // ISSUE: texture.id not exposed to be checked (not really an issue...) + // ExecuteLuaFile("textures_raw_data.lua"); // ERROR: LoadImageEx() + // ExecuteLuaFile("textures_formats_loading.lua"); // OK! // ExecuteLuaFile("textures_particles_trail_blending.lua"); // OK! // ExecuteLuaFile("textures_image_processing.lua"); // ERROR: GetImageData() --> UpdateTexture() // ExecuteLuaFile("textures_image_drawing.lua"); // OK! @@ -73,13 +73,13 @@ int main() // ExecuteLuaFile("models_cubicmap.lua"); // OK! // ExecuteLuaFile("shaders_model_shader.lua"); // OK! // ExecuteLuaFile("shaders_shapes_textures.lua"); // OK! - // ExecuteLuaFile("shaders_custom_uniform.lua"); // ISSUE: SetShaderValue() + // ExecuteLuaFile("shaders_custom_uniform.lua"); // OK! // ExecuteLuaFile("shaders_postprocessing.lua"); // OK! - // ExecuteLuaFile("shaders_standard_lighting.lua"); // ERROR: CreateLight() returns an opaque pointer (fields can not be accessed) + // ExecuteLuaFile("shaders_standard_lighting.lua"); // OK! // ExecuteLuaFile("audio_sound_loading.lua"); // OK! // ExecuteLuaFile("audio_music_stream.lua"); // OK! // ExecuteLuaFile("audio_module_playing.lua"); // OK! - ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream() + // ExecuteLuaFile("audio_raw_stream.lua"); // ERROR: UpdateAudioStream() // De-Initialization //-------------------------------------------------------------------------------------- diff --git a/src/rlgl.c b/src/rlgl.c index 6fb4bf3d..68d562c7 100644 --- a/src/rlgl.c +++ b/src/rlgl.c @@ -2559,13 +2559,13 @@ void DestroyLight(Light light) { if (light != NULL) { - int light_id = light->id; + int lightId = light->id; // Free dynamic memory allocation - free(lights[light_id]); - + free(lights[lightId]); + // Remove *obj from the pointers array - for (int i = light_id; i < lightsCount; i++) + for (int i = lightId; i < lightsCount; i++) { // Resort all the following pointers of the array if ((i + 1) < lightsCount) diff --git a/src/rlua.h b/src/rlua.h index 85853793..153f2c37 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -300,29 +300,29 @@ static int LuaIndexSpriteFont(lua_State* L) static int LuaIndexLight(lua_State* L) { - Light light = LuaGetArgument_Light(L, 1); - const char *key = luaL_checkstring(L, 2); - if (!strcmp(key, "id")) - lua_pushinteger(L, light->id); - else if (!strcmp(key, "enabled")) - lua_pushboolean(L, light->enabled); - else if (!strcmp(key, "type")) - lua_pushinteger(L, light->type); - else if (!strcmp(key, "position")) - LuaPush_Vector3(L, light->position); - else if (!strcmp(key, "target")) - LuaPush_Vector3(L, light->target); - else if (!strcmp(key, "radius")) - lua_pushnumber(L, light->radius); - else if (!strcmp(key, "diffuse")) - LuaPush_Color(L, light->diffuse); - else if (!strcmp(key, "intensity")) - lua_pushnumber(L, light->intensity); - else if (!strcmp(key, "coneAngle")) - lua_pushnumber(L, light->coneAngle); - else - return 0; - return 1; + Light light = LuaGetArgument_Light(L, 1); + const char *key = luaL_checkstring(L, 2); + if (!strcmp(key, "id")) + lua_pushinteger(L, light->id); + else if (!strcmp(key, "enabled")) + lua_pushboolean(L, light->enabled); + else if (!strcmp(key, "type")) + lua_pushinteger(L, light->type); + else if (!strcmp(key, "position")) + LuaPush_Vector3(L, light->position); + else if (!strcmp(key, "target")) + LuaPush_Vector3(L, light->target); + else if (!strcmp(key, "radius")) + lua_pushnumber(L, light->radius); + else if (!strcmp(key, "diffuse")) + LuaPush_Color(L, light->diffuse); + else if (!strcmp(key, "intensity")) + lua_pushnumber(L, light->intensity); + else if (!strcmp(key, "coneAngle")) + lua_pushnumber(L, light->coneAngle); + else + return 0; + return 1; } static int LuaNewIndexLight(lua_State* L) @@ -335,17 +335,17 @@ static int LuaNewIndexLight(lua_State* L) light->enabled = lua_toboolean(L, 3); else if (!strcmp(key, "type")) light->type = LuaGetArgument_int(L, 3); - else if (!strcmp(key, "position")) + else if (!strcmp(key, "position")) light->position = LuaGetArgument_Vector3(L, 3); - else if (!strcmp(key, "target")) + else if (!strcmp(key, "target")) light->target = LuaGetArgument_Vector3(L, 3); - else if (!strcmp(key, "radius")) + else if (!strcmp(key, "radius")) light->radius = LuaGetArgument_float(L, 3); - else if (!strcmp(key, "diffuse")) + else if (!strcmp(key, "diffuse")) light->diffuse = LuaGetArgument_Color(L, 3); - else if (!strcmp(key, "intensity")) + else if (!strcmp(key, "intensity")) light->intensity = LuaGetArgument_float(L, 3); - else if (!strcmp(key, "coneAngle")) + else if (!strcmp(key, "coneAngle")) light->coneAngle = LuaGetArgument_float(L, 3); return 0; } @@ -367,17 +367,17 @@ static void LuaBuildOpaqueMetatables(void) lua_setfield(L, -2, "__index"); lua_pop(L, 1); - luaL_newmetatable(L, "SpriteFont"); - lua_pushcfunction(L, &LuaIndexSpriteFont); - lua_setfield(L, -2, "__index"); - lua_pop(L, 1); + luaL_newmetatable(L, "SpriteFont"); + lua_pushcfunction(L, &LuaIndexSpriteFont); + lua_setfield(L, -2, "__index"); + lua_pop(L, 1); - luaL_newmetatable(L, "Light"); - lua_pushcfunction(L, &LuaIndexLight); - lua_setfield(L, -2, "__index"); - lua_pushcfunction(L, &LuaNewIndexLight); - lua_setfield(L, -2, "__newindex"); - lua_pop(L, 1); + luaL_newmetatable(L, "Light"); + lua_pushcfunction(L, &LuaIndexLight); + lua_setfield(L, -2, "__index"); + lua_pushcfunction(L, &LuaNewIndexLight); + lua_setfield(L, -2, "__newindex"); + lua_pop(L, 1); } //---------------------------------------------------------------------------------- @@ -1121,14 +1121,14 @@ int lua_IsFileDropped(lua_State* L) int lua_GetDroppedFiles(lua_State* L) { - int count = 0; + int count = 0; char ** result = GetDroppedFiles(&count); - lua_createtable(L, count, 0); - for (int i = 0; i < count; i++) - { - lua_pushstring(L, result[i]); - lua_rawseti(L, -2, i + 1); - } + lua_createtable(L, count, 0); + for (int i = 0; i < count; i++) + { + lua_pushstring(L, result[i]); + lua_rawseti(L, -2, i + 1); + } return 1; } @@ -2401,9 +2401,9 @@ int lua_DrawGizmo(lua_State* L) int lua_DrawLight(lua_State* L) { - Light arg1 = LuaGetArgument_Light(L, 1); - DrawLight(arg1); - return 0; + Light arg1 = LuaGetArgument_Light(L, 1); + DrawLight(arg1); + return 0; } int lua_Draw3DLine(lua_State* L) @@ -3769,7 +3769,7 @@ static luaL_Reg raylib_functions[] = { REG(DrawGrid) REG(DrawGizmo) - REG(DrawLight) + REG(DrawLight) REG(LoadModel) REG(LoadModelEx) -- cgit v1.2.3 From 7fbd821727228396e03f47786a4db27f00aaebba Mon Sep 17 00:00:00 2001 From: raysan5 Date: Sun, 7 Aug 2016 13:51:01 +0200 Subject: Some code review tweaks --- examples/textures_raw_data.lua | 4 +-- src/rlua.h | 70 ++++++++++++------------------------------ 2 files changed, 22 insertions(+), 52 deletions(-) (limited to 'src/rlua.h') diff --git a/examples/textures_raw_data.lua b/examples/textures_raw_data.lua index 8a955adf..0bad1771 100644 --- a/examples/textures_raw_data.lua +++ b/examples/textures_raw_data.lua @@ -36,8 +36,8 @@ local pixels = {} for y = 1, height do for x = 1, width do - if ((((x - 1)/32+(y - 1)//32)//1)%2 == 0) then pixels[y*height + x] = DARKBLUE - else pixels[y*height + x] = SKYBLUE end + if ((((x - 1)/32+(y - 1)//32)//1)%2 == 0) then pixels[(y - 1)*height + x] = DARKBLUE + else pixels[(y - 1)*height + x] = SKYBLUE end end end diff --git a/src/rlua.h b/src/rlua.h index 153f2c37..849c1c64 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -138,6 +138,7 @@ RLUADEF void CloseLuaDevice(void); // De-initialize Lua system #define LuaGetArgument_char (char)luaL_checkinteger #define LuaGetArgument_float (float)luaL_checknumber #define LuaGetArgument_double luaL_checknumber + #define LuaGetArgument_Image(L, img) *(Image*)LuaGetArgumentOpaqueTypeWithMetatable(L, img, "Image") #define LuaGetArgument_Texture2D(L, tex) *(Texture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, tex, "Texture2D") #define LuaGetArgument_RenderTexture2D(L, rtex) *(RenderTexture2D*)LuaGetArgumentOpaqueTypeWithMetatable(L, rtex, "RenderTexture2D") @@ -739,17 +740,6 @@ static int lua_Quaternion(lua_State* L) return 1; } -/* -static int lua_Matrix(lua_State* L) -{ - LuaPush_Matrix(L, (Matrix) { (float)luaL_checknumber(L, 1), (float)luaL_checknumber(L, 2), (float)luaL_checknumber(L, 3), (float)luaL_checknumber(L, 4), - (float)luaL_checknumber(L, 5), (float)luaL_checknumber(L, 6), (float)luaL_checknumber(L, 7), (float)luaL_checknumber(L, 8), - (float)luaL_checknumber(L, 9), (float)luaL_checknumber(L, 10), (float)luaL_checknumber(L, 11), (float)luaL_checknumber(L, 12), - (float)luaL_checknumber(L, 13), (float)luaL_checknumber(L, 14), (float)luaL_checknumber(L, 15), (float)luaL_checknumber(L, 16) }); - return 1; -} -*/ - static int lua_Rectangle(lua_State* L) { LuaPush_Rectangle(L, (Rectangle) { (int)luaL_checkinteger(L, 1), (int)luaL_checkinteger(L, 2), (int)luaL_checkinteger(L, 3), (int)luaL_checkinteger(L, 4) }); @@ -777,8 +767,8 @@ static int lua_Camera(lua_State* L) Vector3 pos = LuaGetArgument_Vector3(L, 1); Vector3 tar = LuaGetArgument_Vector3(L, 2); Vector3 up = LuaGetArgument_Vector3(L, 3); - //float fovy = LuaGetArgument_float(L, 4); // ??? - LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, (float)luaL_checknumber(L, 4) }); + float fovy = LuaGetArgument_float(L, 4); + LuaPush_Camera(L, (Camera) { { pos.x, pos.y, pos.z }, { tar.x, tar.y, tar.z }, { up.x, up.y, up.z }, fovy }); return 1; } @@ -792,23 +782,6 @@ static int lua_Camera2D(lua_State* L) return 1; } -/* -// NOTE: does it make sense to have this constructor? Probably not... -static int lua_Material(lua_State* L) -{ - Shader sdr = LuaGetArgument_Shader(L, 1); - Texture2D td = LuaGetArgument_Texture2D(L, 2); - Texture2D tn = LuaGetArgument_Texture2D(L, 3); - Texture2D ts = LuaGetArgument_Texture2D(L, 4); - Color cd = LuaGetArgument_Color(L, 5); - Color ca = LuaGetArgument_Color(L, 6); - Color cs = LuaGetArgument_Color(L, 7); - float gloss = LuaGetArgument_float(L, 8); - LuaPush_Material(L, (Material) { sdr, td, tn, ts cd, ca, cs, gloss }); - return 1; -} -*/ - /************************************************************************************* * raylib Lua Functions Bindings **************************************************************************************/ @@ -1817,14 +1790,11 @@ int lua_LoadImage(lua_State* L) int lua_LoadImageEx(lua_State* L) { - //Color * arg1 = LuaGetArgument_Color *(L, 1); GET_TABLE(Color, arg1, 1); - int arg2 = LuaGetArgument_int(L, 2); int arg3 = LuaGetArgument_int(L, 3); - Image result = LoadImageEx(arg1, arg2, arg3); + Image result = LoadImageEx(arg1, arg2, arg3); // ISSUE: #3 number expected, got no value LuaPush_Image(L, result); - free(arg1); return 1; } @@ -1860,7 +1830,7 @@ int lua_LoadTexture(lua_State* L) int lua_LoadTextureEx(lua_State* L) { - void * arg1 = (char *)LuaGetArgument_string(L, 1); // NOTE: getting argument as string + void * arg1 = (char *)LuaGetArgument_string(L, 1); // NOTE: getting argument as string? int arg2 = LuaGetArgument_int(L, 2); int arg3 = LuaGetArgument_int(L, 3); int arg4 = LuaGetArgument_int(L, 4); @@ -2056,7 +2026,7 @@ int lua_ImageDrawTextEx(lua_State* L) Vector2 arg2 = LuaGetArgument_Vector2(L, 2); SpriteFont arg3 = LuaGetArgument_SpriteFont(L, 3); const char * arg4 = LuaGetArgument_string(L, 4); - int arg5 = LuaGetArgument_int(L, 5); + float arg5 = LuaGetArgument_float(L, 5); int arg6 = LuaGetArgument_int(L, 6); Color arg7 = LuaGetArgument_Color(L, 7); ImageDrawTextEx(&arg1, arg2, arg3, arg4, arg5, arg6, arg7); @@ -2134,7 +2104,7 @@ int lua_UpdateTexture(lua_State* L) { Texture2D arg1 = LuaGetArgument_Texture2D(L, 1); void * arg2 = (char *)LuaGetArgument_string(L, 2); // NOTE: Getting (void *) as string? - UpdateTexture(arg1, arg2); + UpdateTexture(arg1, arg2); // ISSUE: #2 string expected, got table -> GetImageData() returns a table! return 0; } @@ -2231,7 +2201,7 @@ int lua_DrawTextEx(lua_State* L) SpriteFont arg1 = LuaGetArgument_SpriteFont(L, 1); const char * arg2 = LuaGetArgument_string(L, 2); Vector2 arg3 = LuaGetArgument_Vector2(L, 3); - int arg4 = LuaGetArgument_int(L, 4); + float arg4 = LuaGetArgument_float(L, 4); int arg5 = LuaGetArgument_int(L, 5); Color arg6 = LuaGetArgument_Color(L, 6); DrawTextEx(arg1, arg2, arg3, arg4, arg5, arg6); @@ -3911,7 +3881,7 @@ static luaL_Reg raylib_functions[] = { REG(QuaternionToAxisAngle) REG(QuaternionTransform) - {0,0} + {NULL, NULL} // sentinel: end signal }; // Register raylib functionality @@ -4017,16 +3987,16 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("PLAYER3", 2); LuaSetEnum("PLAYER4", 3); - LuaSetEnum("BUTTON_A", 2); - LuaSetEnum("BUTTON_B", 1); - LuaSetEnum("BUTTON_X", 3); - LuaSetEnum("BUTTON_Y", 4); - LuaSetEnum("BUTTON_R1", 7); - LuaSetEnum("BUTTON_R2", 5); - LuaSetEnum("BUTTON_L1", 6); - LuaSetEnum("BUTTON_L2", 8); - LuaSetEnum("BUTTON_SELECT", 9); - LuaSetEnum("BUTTON_START", 10); + LuaSetEnum("PS3_BUTTON_A", 2); + LuaSetEnum("PS3_BUTTON_B", 1); + LuaSetEnum("PS3_BUTTON_X", 3); + LuaSetEnum("PS3_BUTTON_Y", 4); + LuaSetEnum("PS3_BUTTON_R1", 7); + LuaSetEnum("PS3_BUTTON_R2", 5); + LuaSetEnum("PS3_BUTTON_L1", 6); + LuaSetEnum("PS3_BUTTON_L2", 8); + LuaSetEnum("PS3_BUTTON_SELECT", 9); + LuaSetEnum("PS3_BUTTON_START", 10); LuaSetEnum("XBOX_BUTTON_A", 0); LuaSetEnum("XBOX_BUTTON_B", 1); @@ -4040,7 +4010,7 @@ RLUADEF void InitLuaDevice(void) #if defined(PLATFORM_RPI) LuaSetEnum("XBOX_AXIS_DPAD_X", 7); LuaSetEnum("XBOX_AXIS_DPAD_Y", 6); - LuaSetEnum("XBOX_AXIS_RIGHT_X", 3); + LuaSetEnum("XBOX_AXIS_RIGHT_X", 3); LuaSetEnum("XBOX_AXIS_RIGHT_Y", 4); LuaSetEnum("XBOX_AXIS_LT", 2); LuaSetEnum("XBOX_AXIS_RT", 5); -- cgit v1.2.3 From eb9072a2f133cdad9fb4fed4c8b80aca04770d55 Mon Sep 17 00:00:00 2001 From: Ray Date: Wed, 10 Aug 2016 12:20:46 +0200 Subject: Renamed functions for consistency --- src/models.c | 14 +++++++------- src/raylib.h | 4 ++-- src/rlua.h | 56 ++++++++++++++++++++++++++++++-------------------------- 3 files changed, 39 insertions(+), 35 deletions(-) (limited to 'src/rlua.h') diff --git a/src/models.c b/src/models.c index b194a0db..7f248aa2 100644 --- a/src/models.c +++ b/src/models.c @@ -66,7 +66,7 @@ static Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); //---------------------------------------------------------------------------------- // Draw a line in 3D world space -void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color) +void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color) { rlBegin(RL_LINES); rlColor4ub(color.r, color.g, color.b, color.a); @@ -76,7 +76,7 @@ void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color) } // Draw a circle in 3D world space -void Draw3DCircle(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color) +void DrawCircle3D(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color) { rlPushMatrix(); rlTranslatef(center.x, center.y, center.z); @@ -578,19 +578,19 @@ void DrawLight(Light light) case LIGHT_POINT: { DrawSphereWires(light->position, 0.3f*light->intensity, 4, 8, (light->enabled ? light->diffuse : BLACK)); - Draw3DCircle(light->position, light->radius, 0.0f, (Vector3){ 0, 0, 0 }, (light->enabled ? light->diffuse : BLACK)); - Draw3DCircle(light->position, light->radius, 90.0f, (Vector3){ 1, 0, 0 }, (light->enabled ? light->diffuse : BLACK)); - Draw3DCircle(light->position, light->radius, 90.0f, (Vector3){ 0, 1, 0 }, (light->enabled ? light->diffuse : BLACK)); + DrawCircle3D(light->position, light->radius, 0.0f, (Vector3){ 0, 0, 0 }, (light->enabled ? light->diffuse : BLACK)); + DrawCircle3D(light->position, light->radius, 90.0f, (Vector3){ 1, 0, 0 }, (light->enabled ? light->diffuse : BLACK)); + DrawCircle3D(light->position, light->radius, 90.0f, (Vector3){ 0, 1, 0 }, (light->enabled ? light->diffuse : BLACK)); } break; case LIGHT_DIRECTIONAL: { - Draw3DLine(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); + DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); DrawSphereWires(light->position, 0.3f*light->intensity, 4, 8, (light->enabled ? light->diffuse : BLACK)); DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : BLACK)); } break; case LIGHT_SPOT: { - Draw3DLine(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); + DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); DrawCylinderWires(light->position, 0.0f, 0.3f*light->coneAngle/50, 0.6f, 5, (light->enabled ? light->diffuse : BLACK)); DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : BLACK)); } break; diff --git a/src/raylib.h b/src/raylib.h index 41c32476..1673578d 100644 --- a/src/raylib.h +++ b/src/raylib.h @@ -800,6 +800,8 @@ const char *SubText(const char *text, int position, int length); //------------------------------------------------------------------------------------ // Basic 3d Shapes Drawing Functions (Module: models) //------------------------------------------------------------------------------------ +void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space +void DrawCircle3D(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color); // Draw a circle in 3D world space void DrawCube(Vector3 position, float width, float height, float lenght, Color color); // Draw cube void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version) void DrawCubeWires(Vector3 position, float width, float height, float lenght, Color color); // Draw cube wires @@ -814,8 +816,6 @@ void DrawRay(Ray ray, Color color); void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0)) void DrawGizmo(Vector3 position); // Draw simple gizmo void DrawLight(Light light); // Draw light in 3D world -void Draw3DLine(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space -void Draw3DCircle(Vector3 center, float radius, float rotationAngle, Vector3 rotation, Color color); // Draw a circle in 3D world space //DrawTorus(), DrawTeapot() are useless... //------------------------------------------------------------------------------------ diff --git a/src/rlua.h b/src/rlua.h index 849c1c64..b100b06d 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -2239,6 +2239,29 @@ int lua_DrawFPS(lua_State* L) // NOTE: FormatText() can be replaced by Lua function: string.format() // NOTE: SubText() can be replaced by Lua function: string.sub() +//------------------------------------------------------------------------------------ +// raylib [models] module functions - Basic 3d Shapes Drawing Functions +//------------------------------------------------------------------------------------ +int lua_DrawLine3D(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + Vector3 arg2 = LuaGetArgument_Vector3(L, 2); + Color arg3 = LuaGetArgument_Color(L, 3); + DrawLine3D(arg1, arg2, arg3); + return 0; +} + +int lua_DrawCircle3D(lua_State* L) +{ + Vector3 arg1 = LuaGetArgument_Vector3(L, 1); + float arg2 = LuaGetArgument_float(L, 2); + float arg3 = LuaGetArgument_float(L, 3); + Vector3 arg4 = LuaGetArgument_Vector3(L, 4); + Color arg5 = LuaGetArgument_Color(L, 5); + DrawCircle3D(arg1, arg2, arg3, arg4, arg5); + return 0; +} + int lua_DrawCube(lua_State* L) { Vector3 arg1 = LuaGetArgument_Vector3(L, 1); @@ -2376,26 +2399,6 @@ int lua_DrawLight(lua_State* L) return 0; } -int lua_Draw3DLine(lua_State* L) -{ - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - Vector3 arg2 = LuaGetArgument_Vector3(L, 2); - Color arg3 = LuaGetArgument_Color(L, 3); - Draw3DLine(arg1, arg2, arg3); - return 0; -} - -int lua_Draw3DCircle(lua_State* L) -{ - Vector3 arg1 = LuaGetArgument_Vector3(L, 1); - float arg2 = LuaGetArgument_float(L, 2); - float arg3 = LuaGetArgument_float(L, 3); - Vector3 arg4 = LuaGetArgument_Vector3(L, 4); - Color arg5 = LuaGetArgument_Color(L, 5); - Draw3DCircle(arg1, arg2, arg3, arg4, arg5); - return 0; -} - //------------------------------------------------------------------------------------ // raylib [models] module functions //------------------------------------------------------------------------------------ @@ -3725,6 +3728,8 @@ static luaL_Reg raylib_functions[] = { REG(MeasureTextEx) REG(DrawFPS) + REG(DrawLine3D) + REG(DrawCircle3D) REG(DrawCube) REG(DrawCubeV) REG(DrawCubeWires) @@ -3738,8 +3743,7 @@ static luaL_Reg raylib_functions[] = { REG(DrawRay) REG(DrawGrid) REG(DrawGizmo) - - REG(DrawLight) + REG(DrawLight) REG(LoadModel) REG(LoadModelEx) @@ -3747,10 +3751,10 @@ static luaL_Reg raylib_functions[] = { REG(LoadHeightmap) REG(LoadCubicmap) REG(UnloadModel) - REG(LoadMaterial) - REG(LoadDefaultMaterial) - REG(LoadStandardMaterial) - REG(UnloadMaterial) + REG(LoadMaterial) + REG(LoadDefaultMaterial) + REG(LoadStandardMaterial) + REG(UnloadMaterial) //REG(GenMesh*) // Not ready yet... REG(DrawModel) -- cgit v1.2.3 From 959a228815edcecdde692fcd47a7b540844c5712 Mon Sep 17 00:00:00 2001 From: raysan5 Date: Tue, 16 Aug 2016 11:09:55 +0200 Subject: Removed useless spacing --- src/audio.c | 74 +++++------ src/core.c | 342 ++++++++++++++++++++++++------------------------- src/models.c | 134 +++++++++---------- src/raylib.h | 4 +- src/rlgl.h | 26 ++-- src/rlua.h | 72 +++++------ src/text.c | 146 ++++++++++----------- src/textures.c | 398 ++++++++++++++++++++++++++++----------------------------- 8 files changed, 598 insertions(+), 598 deletions(-) (limited to 'src/rlua.h') diff --git a/src/audio.c b/src/audio.c index 683ee66b..1772196f 100644 --- a/src/audio.c +++ b/src/audio.c @@ -183,7 +183,7 @@ void CloseAudioDevice(void) alcMakeContextCurrent(NULL); alcDestroyContext(context); alcCloseDevice(device); - + TraceLog(INFO, "Audio device closed successfully"); } @@ -217,7 +217,7 @@ Sound LoadSound(char *fileName) else TraceLog(WARNING, "[%s] Sound extension not recognized, it can't be loaded", fileName); Sound sound = LoadSoundFromWave(wave); - + // Sound is loaded, we can unload wave UnloadWave(wave); @@ -233,7 +233,7 @@ Sound LoadSoundFromWave(Wave wave) if (wave.data != NULL) { ALenum format = 0; - + // The OpenAL format is worked out by looking at the number of channels and the sample size (bits per sample) if (wave.channels == 1) { @@ -256,7 +256,7 @@ Sound LoadSoundFromWave(Wave wave) } } else TraceLog(WARNING, "Wave number of channels not supported: %i", wave.channels); - + // Create an audio source ALuint source; alGenSources(1, &source); // Generate pointer to audio source @@ -271,7 +271,7 @@ Sound LoadSoundFromWave(Wave wave) //---------------------------------------- ALuint buffer; alGenBuffers(1, &buffer); // Generate pointer to buffer - + unsigned int dataSize = wave.sampleCount*wave.sampleSize/8; // Size in bytes // Upload sound data to buffer @@ -367,7 +367,7 @@ Sound LoadSoundFromRES(const char *rresName, int resId) free(data); sound = LoadSoundFromWave(wave); - + // Sound is loaded, we can unload wave data UnloadWave(wave); } @@ -506,13 +506,13 @@ Music LoadMusicStream(char *fileName) TraceLog(DEBUG, "[%s] OGG sample rate: %i", fileName, info.sample_rate); TraceLog(DEBUG, "[%s] OGG channels: %i", fileName, info.channels); TraceLog(DEBUG, "[%s] OGG memory required: %i", fileName, info.temp_memory_required); - + } } else if (strcmp(GetExtension(fileName), "xm") == 0) { int result = jar_xm_create_context_from_file(&music->ctxXm, 48000, fileName); - + if (!result) // XM context created successfully { jar_xm_set_max_loop_count(music->ctxXm, 0); // Set infinite number of loops @@ -523,7 +523,7 @@ Music LoadMusicStream(char *fileName) music->samplesLeft = music->totalSamples; music->ctxType = MUSIC_MODULE_XM; music->loop = true; - + TraceLog(DEBUG, "[%s] XM number of samples: %i", fileName, music->totalSamples); TraceLog(DEBUG, "[%s] XM track length: %11.6f sec", fileName, (float)music->totalSamples/48000.0f); } @@ -555,11 +555,11 @@ Music LoadMusicStream(char *fileName) void UnloadMusicStream(Music music) { CloseAudioStream(music->stream); - + if (music->ctxType == MUSIC_AUDIO_OGG) stb_vorbis_close(music->ctxOgg); else if (music->ctxType == MUSIC_MODULE_XM) jar_xm_free_context(music->ctxXm); else if (music->ctxType == MUSIC_MODULE_MOD) jar_mod_unload(&music->ctxMod); - + free(music); } @@ -597,58 +597,58 @@ void UpdateMusicStream(Music music) // Determine if music stream is ready to be written alGetSourcei(music->stream.source, AL_BUFFERS_PROCESSED, &processed); - + int numBuffersToProcess = processed; - + if (processed > 0) { bool active = true; short pcm[AUDIO_BUFFER_SIZE]; float pcmf[AUDIO_BUFFER_SIZE]; - - int numSamples = 0; // Total size of data steamed in L+R samples for xm floats, + + int numSamples = 0; // Total size of data steamed in L+R samples for xm floats, // individual L or R for ogg shorts for (int i = 0; i < numBuffersToProcess; i++) { switch (music->ctxType) { - case MUSIC_AUDIO_OGG: + case MUSIC_AUDIO_OGG: { if (music->samplesLeft >= AUDIO_BUFFER_SIZE) numSamples = AUDIO_BUFFER_SIZE; else numSamples = music->samplesLeft; - + // NOTE: Returns the number of samples to process (should be the same as numSamples -> it is) int numSamplesOgg = stb_vorbis_get_samples_short_interleaved(music->ctxOgg, music->stream.channels, pcm, numSamples); // TODO: Review stereo channels Ogg, not enough samples served! UpdateAudioStream(music->stream, pcm, numSamplesOgg*music->stream.channels); music->samplesLeft -= (numSamplesOgg*music->stream.channels); - + } break; - case MUSIC_MODULE_XM: + case MUSIC_MODULE_XM: { if (music->samplesLeft >= AUDIO_BUFFER_SIZE/2) numSamples = AUDIO_BUFFER_SIZE/2; else numSamples = music->samplesLeft; - + // NOTE: Output buffer is 2*numsamples elements (left and right value for each sample) jar_xm_generate_samples(music->ctxXm, pcmf, numSamples); UpdateAudioStream(music->stream, pcmf, numSamples*2); // Using 32bit PCM data music->samplesLeft -= numSamples; - + //TraceLog(INFO, "Samples left: %i", music->samplesLeft); - + } break; - case MUSIC_MODULE_MOD: + case MUSIC_MODULE_MOD: { if (music->samplesLeft >= AUDIO_BUFFER_SIZE/2) numSamples = AUDIO_BUFFER_SIZE/2; else numSamples = music->samplesLeft; - + // NOTE: Output buffer size is nbsample*channels (default: 48000Hz, 16bit, Stereo) - jar_mod_fillbuffer(&music->ctxMod, pcm, numSamples, 0); + jar_mod_fillbuffer(&music->ctxMod, pcm, numSamples, 0); UpdateAudioStream(music->stream, pcm, numSamples*2); music->samplesLeft -= numSamples; - + } break; default: break; } @@ -659,15 +659,15 @@ void UpdateMusicStream(Music music) break; } } - + // Reset audio stream for looping if (!active && music->loop) { // Restart music context (if required) - //if (music->ctxType == MUSIC_MODULE_XM) + //if (music->ctxType == MUSIC_MODULE_XM) if (music->ctxType == MUSIC_MODULE_MOD) jar_mod_seek_start(&music->ctxMod); else if (music->ctxType == MUSIC_AUDIO_OGG) stb_vorbis_seek_start(music->ctxOgg); - + // Reset samples left to total samples music->samplesLeft = music->totalSamples; } @@ -713,7 +713,7 @@ void SetMusicPitch(Music music, float pitch) float GetMusicTimeLength(Music music) { float totalSeconds = (float)music->totalSamples/music->stream.sampleRate; - + return totalSeconds; } @@ -732,7 +732,7 @@ float GetMusicTimePlayed(Music music) AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels) { AudioStream stream = { 0 }; - + stream.sampleRate = sampleRate; stream.sampleSize = sampleSize; stream.channels = channels; @@ -791,7 +791,7 @@ AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, un } alSourceQueueBuffers(stream.source, MAX_STREAM_BUFFERS, stream.buffers); - + TraceLog(INFO, "[AUD ID %i] Audio stream loaded successfully", stream.source); return stream; @@ -806,9 +806,9 @@ void CloseAudioStream(AudioStream stream) // Flush out all queued buffers int queued = 0; alGetSourcei(stream.source, AL_BUFFERS_QUEUED, &queued); - + ALuint buffer = 0; - + while (queued > 0) { alSourceUnqueueBuffers(stream.source, 1, &buffer); @@ -818,7 +818,7 @@ void CloseAudioStream(AudioStream stream) // Delete source and buffers alDeleteSources(1, &stream.source); alDeleteBuffers(MAX_STREAM_BUFFERS, stream.buffers); - + TraceLog(INFO, "[AUD ID %i] Unloaded audio stream data", stream.source); } @@ -828,14 +828,14 @@ void UpdateAudioStream(AudioStream stream, void *data, int numSamples) { ALuint buffer = 0; alSourceUnqueueBuffers(stream.source, 1, &buffer); - + // Check if any buffer was available for unqueue if (alGetError() != AL_INVALID_VALUE) { if (stream.sampleSize == 8) alBufferData(buffer, stream.format, (unsigned char *)data, numSamples*sizeof(unsigned char), stream.sampleRate); else if (stream.sampleSize == 16) alBufferData(buffer, stream.format, (short *)data, numSamples*sizeof(short), stream.sampleRate); else if (stream.sampleSize == 32) alBufferData(buffer, stream.format, (float *)data, numSamples*sizeof(float), stream.sampleRate); - + alSourceQueueBuffers(stream.source, 1, &buffer); } } diff --git a/src/core.c b/src/core.c index 2b5329e3..a76fe0be 100644 --- a/src/core.c +++ b/src/core.c @@ -120,9 +120,9 @@ //#define DEFAULT_KEYBOARD_DEV "/dev/input/eventN" //#define DEFAULT_MOUSE_DEV "/dev/input/eventN" //#define DEFAULT_GAMEPAD_DEV "/dev/input/eventN" - + #define MOUSE_SENSITIVITY 0.8f - + #define MAX_GAMEPADS 2 // Max number of gamepads supported #define MAX_GAMEPAD_BUTTONS 11 // Max bumber of buttons supported (per gamepad) #define MAX_GAMEPAD_AXIS 8 // Max number of axis supported (per gamepad) @@ -333,7 +333,7 @@ void InitWindow(int width, int height, const char *title) emscripten_set_touchend_callback("#canvas", NULL, 1, EmscriptenInputCallback); emscripten_set_touchmove_callback("#canvas", NULL, 1, EmscriptenInputCallback); emscripten_set_touchcancel_callback("#canvas", NULL, 1, EmscriptenInputCallback); - + // TODO: Add gamepad support (not provided by GLFW3 on emscripten) //emscripten_set_gamepadconnected_callback(NULL, 1, EmscriptenInputCallback); //emscripten_set_gamepaddisconnected_callback(NULL, 1, EmscriptenInputCallback); @@ -394,7 +394,7 @@ void InitWindow(int width, int height, struct android_app *state) //state->userData = &engine; app->onAppCmd = AndroidCommandCallback; app->onInputEvent = AndroidInputCallback; - + InitAssetManager(app->activity->assetManager); TraceLog(INFO, "Android app initialized successfully"); @@ -447,7 +447,7 @@ void CloseWindow(void) eglTerminate(display); display = EGL_NO_DISPLAY; - } + } #endif #if defined(PLATFORM_RPI) @@ -527,7 +527,7 @@ void BeginDrawing(void) currentTime = GetTime(); // Number of elapsed seconds since InitTimer() was called updateTime = currentTime - previousTime; previousTime = currentTime; - + rlClearScreenBuffers(); // Clear current framebuffers rlLoadIdentity(); // Reset current matrix (MODELVIEW) rlMultMatrixf(MatrixToFloat(downscaleView)); // If downscale required, apply it here @@ -543,7 +543,7 @@ void EndDrawing(void) SwapBuffers(); // Copy back buffer to front buffer PollInputEvents(); // Poll user events - + // Frame time control system currentTime = GetTime(); drawTime = currentTime - previousTime; @@ -575,9 +575,9 @@ void Begin2dMode(Camera2D camera) Matrix matRotation = MatrixRotate((Vector3){ 0.0f, 0.0f, 1.0f }, camera.rotation*DEG2RAD); Matrix matScale = MatrixScale(camera.zoom, camera.zoom, 1.0f); Matrix matTranslation = MatrixTranslate(camera.offset.x + camera.target.x, camera.offset.y + camera.target.y, 0.0f); - + Matrix matTransform = MatrixMultiply(MatrixMultiply(matOrigin, MatrixMultiply(matScale, matRotation)), matTranslation); - + rlMultMatrixf(MatrixToFloat(matTransform)); } @@ -593,14 +593,14 @@ void End2dMode(void) void Begin3dMode(Camera camera) { rlglDraw(); // Draw Buffers (Only OpenGL 3+ and ES2) - + if (IsVrDeviceReady()) BeginVrDrawing(); rlMatrixMode(RL_PROJECTION); // Switch to projection matrix rlPushMatrix(); // Save previous matrix, which contains the settings for the 2d ortho projection rlLoadIdentity(); // Reset current matrix (PROJECTION) - + // Setup perspective projection float aspect = (float)screenWidth/(float)screenHeight; double top = 0.01*tan(camera.fovy*PI/360.0); @@ -615,15 +615,15 @@ void Begin3dMode(Camera camera) // Setup Camera view Matrix cameraView = MatrixLookAt(camera.position, camera.target, camera.up); rlMultMatrixf(MatrixToFloat(cameraView)); // Multiply MODELVIEW matrix by view matrix (camera) - + rlEnableDepthTest(); // Enable DEPTH_TEST for 3D } // Ends 3D mode and returns to default 2D orthographic mode void End3dMode(void) -{ +{ rlglDraw(); // Process internal buffers (update + draw) - + if (IsVrDeviceReady()) EndVrDrawing(); rlMatrixMode(RL_PROJECTION); // Switch to projection matrix @@ -633,7 +633,7 @@ void End3dMode(void) rlLoadIdentity(); // Reset current matrix (MODELVIEW) //rlTranslatef(0.375, 0.375, 0); // HACK to ensure pixel-perfect drawing on OpenGL (after exiting 3D mode) - + rlDisableDepthTest(); // Disable DEPTH_TEST for 2D } @@ -645,16 +645,16 @@ void BeginTextureMode(RenderTexture2D target) rlEnableRenderTexture(target.id); // Enable render target rlClearScreenBuffers(); // Clear render texture buffers - + // Set viewport to framebuffer size - rlViewport(0, 0, target.texture.width, target.texture.height); - + rlViewport(0, 0, target.texture.width, target.texture.height); + rlMatrixMode(RL_PROJECTION); // Switch to PROJECTION matrix rlLoadIdentity(); // Reset current matrix (PROJECTION) // Set orthographic projection to current framebuffer size // NOTE: Configured top-left corner as (0, 0) - rlOrtho(0, target.texture.width, target.texture.height, 0, 0.0f, 1.0f); + rlOrtho(0, target.texture.width, target.texture.height, 0, 0.0f, 1.0f); rlMatrixMode(RL_MODELVIEW); // Switch back to MODELVIEW matrix rlLoadIdentity(); // Reset current matrix (MODELVIEW) @@ -672,10 +672,10 @@ void EndTextureMode(void) // Set viewport to default framebuffer size (screen size) // TODO: consider possible viewport offsets rlViewport(0, 0, GetScreenWidth(), GetScreenHeight()); - + rlMatrixMode(RL_PROJECTION); // Switch to PROJECTION matrix rlLoadIdentity(); // Reset current matrix (PROJECTION) - + // Set orthographic projection to current framebuffer size // NOTE: Configured top-left corner as (0, 0) rlOrtho(0, GetScreenWidth(), GetScreenHeight(), 0, 0.0f, 1.0f); @@ -701,7 +701,7 @@ float GetFPS(void) // Returns time in seconds for one frame float GetFrameTime(void) { - // As we are operate quite a lot with frameTime, + // As we are operate quite a lot with frameTime, // it could be no stable, so we round it before passing it around // NOTE: There are still problems with high framerates (>500fps) double roundedFrameTime = round(frameTime*10000)/10000.0; @@ -735,7 +735,7 @@ float *VectorToFloat(Vector3 vec) } // Converts Matrix to float array -// NOTE: Returned vector is a transposed version of the Matrix struct, +// NOTE: Returned vector is a transposed version of the Matrix struct, // it should be this way because, despite raymath use OpenGL column-major convention, // Matrix struct memory alignment and variables naming are not coherent float *MatrixToFloat(Matrix mat) @@ -799,7 +799,7 @@ Color Fade(Color color, float alpha) { if (alpha < 0.0f) alpha = 0.0f; else if (alpha > 1.0f) alpha = 1.0f; - + float colorAlpha = (float)color.a*alpha; return (Color){color.r, color.g, color.b, (unsigned char)colorAlpha}; @@ -841,9 +841,9 @@ void ClearDroppedFiles(void) if (dropFilesCount > 0) { for (int i = 0; i < dropFilesCount; i++) free(dropFilesPath[i]); - + free(dropFilesPath); - + dropFilesCount = 0; } } @@ -854,7 +854,7 @@ void ClearDroppedFiles(void) void StorageSaveValue(int position, int value) { FILE *storageFile = NULL; - + char path[128]; #if defined(PLATFORM_ANDROID) strcpy(path, internalDataPath); @@ -865,7 +865,7 @@ void StorageSaveValue(int position, int value) #endif // Try open existing file to append data - storageFile = fopen(path, "rb+"); + storageFile = fopen(path, "rb+"); // If file doesn't exist, create a new storage data file if (!storageFile) storageFile = fopen(path, "wb"); @@ -877,14 +877,14 @@ void StorageSaveValue(int position, int value) fseek(storageFile, 0, SEEK_END); int fileSize = ftell(storageFile); // Size in bytes fseek(storageFile, 0, SEEK_SET); - + if (fileSize < (position*4)) TraceLog(WARNING, "Storage position could not be found"); else { fseek(storageFile, (position*4), SEEK_SET); fwrite(&value, 1, 4, storageFile); } - + fclose(storageFile); } } @@ -894,7 +894,7 @@ void StorageSaveValue(int position, int value) int StorageLoadValue(int position) { int value = 0; - + char path[128]; #if defined(PLATFORM_ANDROID) strcpy(path, internalDataPath); @@ -903,9 +903,9 @@ int StorageLoadValue(int position) #else strcpy(path, STORAGE_FILENAME); #endif - + // Try open existing file to append data - FILE *storageFile = fopen(path, "rb"); + FILE *storageFile = fopen(path, "rb"); if (!storageFile) TraceLog(WARNING, "Storage data file could not be found"); else @@ -914,42 +914,42 @@ int StorageLoadValue(int position) fseek(storageFile, 0, SEEK_END); int fileSize = ftell(storageFile); // Size in bytes rewind(storageFile); - + if (fileSize < (position*4)) TraceLog(WARNING, "Storage position could not be found"); else { fseek(storageFile, (position*4), SEEK_SET); fread(&value, 1, 4, storageFile); } - + fclose(storageFile); } - + return value; } // Returns a ray trace from mouse position Ray GetMouseRay(Vector2 mousePosition, Camera camera) -{ +{ Ray ray; - + // Calculate normalized device coordinates // NOTE: y value is negative float x = (2.0f*mousePosition.x)/(float)GetScreenWidth() - 1.0f; float y = 1.0f - (2.0f*mousePosition.y)/(float)GetScreenHeight(); float z = 1.0f; - + // Store values in a vector Vector3 deviceCoords = { x, y, z }; - + TraceLog(DEBUG, "Device coordinates: (%f, %f, %f)", deviceCoords.x, deviceCoords.y, deviceCoords.z); - + // Calculate projection matrix (from perspective instead of frustum) Matrix matProj = MatrixPerspective(camera.fovy, ((double)GetScreenWidth()/(double)GetScreenHeight()), 0.01, 1000.0); - + // Calculate view matrix from camera look at Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up); - + // Do I need to transpose it? It seems that yes... // NOTE: matrix order may be incorrect... In OpenGL to get world position from // camera view it just needs to get inverted, but here we need to transpose it too. @@ -957,10 +957,10 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera) // to a vector, you will get its 3d world position coordinates (camera.position). // If you don't transpose, final position will be wrong. MatrixTranspose(&matView); - + //#define USE_RLGL_UNPROJECT #if defined(USE_RLGL_UNPROJECT) // OPTION 1: Use rlglUnproject() - + Vector3 nearPoint = rlglUnproject((Vector3){ deviceCoords.x, deviceCoords.y, 0.0f }, matProj, matView); Vector3 farPoint = rlglUnproject((Vector3){ deviceCoords.x, deviceCoords.y, 1.0f }, matProj, matView); @@ -969,56 +969,56 @@ Ray GetMouseRay(Vector2 mousePosition, Camera camera) // Calculate unproject matrix (multiply projection matrix and view matrix) and invert it Matrix matProjView = MatrixMultiply(matProj, matView); MatrixInvert(&matProjView); - + // Calculate far and near points Quaternion near = { deviceCoords.x, deviceCoords.y, 0.0f, 1.0f }; Quaternion far = { deviceCoords.x, deviceCoords.y, 1.0f, 1.0f }; - + // Multiply points by unproject matrix QuaternionTransform(&near, matProjView); QuaternionTransform(&far, matProjView); - + // Calculate normalized world points in vectors Vector3 nearPoint = { near.x/near.w, near.y/near.w, near.z/near.w}; Vector3 farPoint = { far.x/far.w, far.y/far.w, far.z/far.w}; #endif - + // Calculate normalized direction vector Vector3 direction = VectorSubtract(farPoint, nearPoint); VectorNormalize(&direction); - + // Apply calculated vectors to ray ray.position = camera.position; ray.direction = direction; - + return ray; } // Returns the screen space position from a 3d world space position Vector2 GetWorldToScreen(Vector3 position, Camera camera) -{ +{ // Calculate projection matrix (from perspective instead of frustum Matrix matProj = MatrixPerspective(camera.fovy, (double)GetScreenWidth()/(double)GetScreenHeight(), 0.01, 1000.0); - + // Calculate view matrix from camera look at (and transpose it) Matrix matView = MatrixLookAt(camera.position, camera.target, camera.up); MatrixTranspose(&matView); - + // Convert world position vector to quaternion Quaternion worldPos = { position.x, position.y, position.z, 1.0f }; - + // Transform world position to view QuaternionTransform(&worldPos, matView); - + // Transform result to projection (clip space position) QuaternionTransform(&worldPos, matProj); - + // Calculate normalized device coordinates (inverted y) Vector3 ndcPos = { worldPos.x / worldPos.w, -worldPos.y / worldPos.w, worldPos.z / worldPos.z }; - + // Calculate 2d screen position vector Vector2 screenPosition = { (ndcPos.x + 1.0f)/2.0f*(float)GetScreenWidth(), (ndcPos.y + 1.0f)/2.0f*(float)GetScreenHeight() }; - + return screenPosition; } @@ -1144,7 +1144,7 @@ bool IsCursorHidden() bool IsGamepadAvailable(int gamepad) { bool result = false; - + #if defined(PLATFORM_RPI) if ((gamepad < MAX_GAMEPADS) && gamepadReady[gamepad]) result = true; #else @@ -1158,7 +1158,7 @@ bool IsGamepadAvailable(int gamepad) float GetGamepadAxisMovement(int gamepad, int axis) { float value = 0; - + #if defined(PLATFORM_RPI) if ((gamepad < MAX_GAMEPADS) && gamepadReady[gamepad]) { @@ -1167,9 +1167,9 @@ float GetGamepadAxisMovement(int gamepad, int axis) #else const float *axes; int axisCount = 0; - + axes = glfwGetJoystickAxes(gamepad, &axisCount); - + if (axis < axisCount) value = axes[axis]; #endif @@ -1197,7 +1197,7 @@ bool IsGamepadButtonPressed(int gamepad, int button) bool IsGamepadButtonDown(int gamepad, int button) { bool result = false; - + #if defined(PLATFORM_RPI) // Get gamepad buttons information if ((gamepad < MAX_GAMEPADS) && gamepadReady[gamepad] && (gamepadButtons[gamepad][button] == 1)) result = true; @@ -1205,13 +1205,13 @@ bool IsGamepadButtonDown(int gamepad, int button) #else const unsigned char *buttons; int buttonsCount; - + buttons = glfwGetJoystickButtons(gamepad, &buttonsCount); if ((buttons != NULL) && (buttons[button] == GLFW_PRESS)) result = true; else result = false; #endif - + return result; } @@ -1260,7 +1260,7 @@ bool IsGamepadButtonUp(int gamepad, int button) bool IsMouseButtonPressed(int button) { bool pressed = false; - + #if defined(PLATFORM_ANDROID) if (IsGestureDetected(GESTURE_TAP)) pressed = true; #else @@ -1274,13 +1274,13 @@ bool IsMouseButtonPressed(int button) bool IsMouseButtonDown(int button) { bool down = false; - + #if defined(PLATFORM_ANDROID) if (IsGestureDetected(GESTURE_HOLD)) down = true; #else if (GetMouseButtonStatus(button) == 1) down = true; #endif - + return down; } @@ -1288,7 +1288,7 @@ bool IsMouseButtonDown(int button) bool IsMouseButtonReleased(int button) { bool released = false; - + #if !defined(PLATFORM_ANDROID) if ((currentMouseState[button] != previousMouseState[button]) && (currentMouseState[button] == 0)) released = true; #endif @@ -1300,7 +1300,7 @@ bool IsMouseButtonReleased(int button) bool IsMouseButtonUp(int button) { bool up = false; - + #if !defined(PLATFORM_ANDROID) if (GetMouseButtonStatus(button) == 0) up = true; #endif @@ -1385,7 +1385,7 @@ int GetTouchY(void) Vector2 GetTouchPosition(int index) { Vector2 position = { -1.0f, -1.0f }; - + #if defined(PLATFORM_ANDROID) || defined(PLATFORM_WEB) if (index < MAX_TOUCH_POINTS) position = touchPosition[index]; else TraceLog(WARNING, "Required touch point out of range (Max touch points: %i)", MAX_TOUCH_POINTS); @@ -1493,7 +1493,7 @@ static void InitGraphicsDevice(int width, int height) // NOTE: When asking for an OpenGL context version, most drivers provide highest supported version // with forward compatibility to older OpenGL versions. // For example, if using OpenGL 1.1, driver can provide a 3.3 context fordward compatible. - + if (configFlags & FLAG_MSAA_4X_HINT) { glfwWindowHint(GLFW_SAMPLES, 4); // Enables multisampling x4 (MSAA), default is 0 @@ -1513,7 +1513,7 @@ static void InitGraphicsDevice(int width, int height) glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Profiles Hint: Only 3.3 and above! // Other values: GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMPAT_PROFILE #ifdef __APPLE__ - glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // OSX Requires + glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // OSX Requires #else glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_FALSE); // Fordward Compatibility Hint: Only 3.3 and above! #endif @@ -1523,9 +1523,9 @@ static void InitGraphicsDevice(int width, int height) if (fullscreen) { // Obtain recommended displayWidth/displayHeight from a valid videomode for the monitor - int count; + int count; const GLFWvidmode *modes = glfwGetVideoModes(glfwGetPrimaryMonitor(), &count); - + // Get closest videomode to desired screenWidth/screenHeight for (int i = 0; i < count; i++) { @@ -1539,7 +1539,7 @@ static void InitGraphicsDevice(int width, int height) } } } - + TraceLog(WARNING, "Closest fullscreen videomode: %i x %i", displayWidth, displayHeight); // NOTE: ISSUE: Closest videomode could not match monitor aspect-ratio, for example, @@ -1548,12 +1548,12 @@ static void InitGraphicsDevice(int width, int height) // by the sides to fit all monitor space... // At this point we need to manage render size vs screen size - // NOTE: This function uses and modifies global module variables: + // NOTE: This function uses and modifies global module variables: // screenWidth/screenHeight - renderWidth/renderHeight - downscaleView SetupFramebufferSize(displayWidth, displayHeight); window = glfwCreateWindow(displayWidth, displayHeight, windowTitle, glfwGetPrimaryMonitor(), NULL); - + // NOTE: Full-screen change, not working properly... //glfwSetWindowMonitor(window, glfwGetPrimaryMonitor(), 0, 0, screenWidth, screenHeight, GLFW_DONT_CARE); } @@ -1561,15 +1561,15 @@ static void InitGraphicsDevice(int width, int height) { // No-fullscreen window creation window = glfwCreateWindow(screenWidth, screenHeight, windowTitle, NULL, NULL); - + #if defined(PLATFORM_DESKTOP) // Center window on screen int windowPosX = displayWidth/2 - screenWidth/2; int windowPosY = displayHeight/2 - screenHeight/2; - + if (windowPosX < 0) windowPosX = 0; if (windowPosY < 0) windowPosY = 0; - + glfwSetWindowPos(window, windowPosX, windowPosY); #endif renderWidth = screenWidth; @@ -1612,7 +1612,7 @@ static void InitGraphicsDevice(int width, int height) // NOTE: GLFW loader function is passed as parameter rlglLoadExtensions(glfwGetProcAddress); #endif - + // Enables GPU v-sync, so frames are not limited to screen refresh rate (60Hz -> 60 FPS) // If not set, swap interval uses GPU v-sync configuration // Framerate can be setup using SetTargetFPS() @@ -1620,7 +1620,7 @@ static void InitGraphicsDevice(int width, int height) { glfwSwapInterval(1); TraceLog(INFO, "Trying to enable VSYNC"); - } + } #endif // defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) #if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI) @@ -1643,13 +1643,13 @@ static void InitGraphicsDevice(int width, int height) EGLint samples = 0; EGLint sampleBuffer = 0; - if (configFlags & FLAG_MSAA_4X_HINT) + if (configFlags & FLAG_MSAA_4X_HINT) { samples = 4; sampleBuffer = 1; TraceLog(INFO, "Trying to enable MSAA x4"); } - + const EGLint framebufferAttribs[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, // Type of context support -> Required on RPI? @@ -1773,10 +1773,10 @@ static void InitGraphicsDevice(int width, int height) // Initialize OpenGL context (states and resources) // NOTE: screenWidth and screenHeight not used, just stored as globals rlglInit(screenWidth, screenHeight); - + #ifdef __APPLE__ // Get framebuffer size of current window - // NOTE: Required to handle HighDPI display correctly on OSX because framebuffer + // NOTE: Required to handle HighDPI display correctly on OSX because framebuffer // is automatically reasized to adapt to new DPI. // When OS does that, it can be detected using GLFW3 callback: glfwSetFramebufferSizeCallback() int fbWidth, fbHeight; @@ -1792,7 +1792,7 @@ static void InitGraphicsDevice(int width, int height) // NOTE: Default to orthographic projection mode with top-left corner at (0,0) rlMatrixMode(RL_PROJECTION); // Switch to PROJECTION matrix rlLoadIdentity(); // Reset current matrix (PROJECTION) - rlOrtho(0, renderWidth - renderOffsetX, renderHeight - renderOffsetY, 0, 0.0f, 1.0f); + rlOrtho(0, renderWidth - renderOffsetX, renderHeight - renderOffsetY, 0, 0.0f, 1.0f); rlMatrixMode(RL_MODELVIEW); // Switch back to MODELVIEW matrix rlLoadIdentity(); // Reset current matrix (MODELVIEW) @@ -1806,7 +1806,7 @@ static void InitGraphicsDevice(int width, int height) // Compute framebuffer size relative to screen size and display size // NOTE: Global variables renderWidth/renderHeight and renderOffsetX/renderOffsetY can be modified static void SetupFramebufferSize(int displayWidth, int displayHeight) -{ +{ // Calculate renderWidth and renderHeight, we have the display size (input params) and the desired screen size (global var) if ((screenWidth > displayWidth) || (screenHeight > displayHeight)) { @@ -1945,7 +1945,7 @@ static void PollInputEvents(void) // NOTE: Gestures update must be called every frame to reset gestures correctly // because ProcessGestureEvent() is just called on an event, not every frame UpdateGestures(); - + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_WEB) // Mouse input polling double mouseX; @@ -2025,7 +2025,7 @@ static void TakeScreenshot(void) unsigned char *imgData = rlglReadScreenPixels(renderWidth, renderHeight); sprintf(buffer, "screenshot%03i.png", shotNum); - + // Save image as PNG WritePNG(buffer, imgData, renderWidth, renderHeight, 4); @@ -2062,7 +2062,7 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i #if defined(PLATFORM_DESKTOP) else if (key == GLFW_KEY_F12 && action == GLFW_PRESS) TakeScreenshot(); #endif - else + else { currentKeyState[key] = action; if (action == GLFW_PRESS) lastKeyPressed = key; @@ -2073,27 +2073,27 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods) { currentMouseState[button] = action; - + #define ENABLE_MOUSE_GESTURES #if defined(ENABLE_MOUSE_GESTURES) // Process mouse events as touches to be able to use mouse-gestures GestureEvent gestureEvent; - + // Register touch actions if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) gestureEvent.touchAction = TOUCH_DOWN; else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON)) gestureEvent.touchAction = TOUCH_UP; - + // NOTE: TOUCH_MOVE event is registered in MouseCursorPosCallback() - + // Assign a pointer ID gestureEvent.pointerId[0] = 0; - + // Register touch points count gestureEvent.pointCount = 1; - + // Register touch points position, only one point registered gestureEvent.position[0] = GetMousePosition(); - + // Normalize gestureEvent.position[0] for screenWidth and screenHeight gestureEvent.position[0].x /= (float)GetScreenWidth(); gestureEvent.position[0].y /= (float)GetScreenHeight(); @@ -2112,20 +2112,20 @@ static void MouseCursorPosCallback(GLFWwindow *window, double x, double y) GestureEvent gestureEvent; gestureEvent.touchAction = TOUCH_MOVE; - + // Assign a pointer ID gestureEvent.pointerId[0] = 0; // Register touch points count gestureEvent.pointCount = 1; - + // Register touch points position, only one point registered gestureEvent.position[0] = (Vector2){ (float)x, (float)y }; - + touchPosition[0] = gestureEvent.position[0]; - + // Normalize gestureEvent.position[0] for screenWidth and screenHeight - gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].x /= (float)GetScreenWidth(); gestureEvent.position[0].y /= (float)GetScreenHeight(); // Gesture data is sent to gestures system for processing @@ -2166,7 +2166,7 @@ static void WindowSizeCallback(GLFWwindow *window, int width, int height) screenHeight = height; renderWidth = width; renderHeight = height; - + // NOTE: Postprocessing texture is not scaled to new size } @@ -2185,9 +2185,9 @@ static void WindowIconifyCallback(GLFWwindow* window, int iconified) static void WindowDropCallback(GLFWwindow *window, int count, const char **paths) { ClearDroppedFiles(); - + dropFilesPath = (char **)malloc(sizeof(char *)*count); - + for (int i = 0; i < count; i++) { dropFilesPath[i] = (char *)malloc(sizeof(char)*256); // Max path length set to 256 char @@ -2249,7 +2249,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd) for (int i = 0; i < assetsCount; i++) { // TODO: Unload old asset if required - + // Load texture again to pointed texture (*textureAsset + i) = LoadTexture(assetPath[i]); } @@ -2292,7 +2292,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd) // NOTE 2: In some cases (too many context loaded), OS could unload context automatically... :( eglMakeCurrent(display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); eglDestroySurface(display, surface); - + contextRebindRequired = true; TraceLog(INFO, "APP_CMD_TERM_WINDOW"); @@ -2329,7 +2329,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd) static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) { //http://developer.android.com/ndk/reference/index.html - + int type = AInputEvent_getType(event); if (type == AINPUT_EVENT_TYPE_MOTION) @@ -2337,7 +2337,7 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) // Get first touch position touchPosition[0].x = AMotionEvent_getX(event, 0); touchPosition[0].y = AMotionEvent_getY(event, 0); - + // Get second touch position touchPosition[1].x = AMotionEvent_getX(event, 1); touchPosition[1].y = AMotionEvent_getY(event, 1); @@ -2346,7 +2346,7 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) { int32_t keycode = AKeyEvent_getKeyCode(event); //int32_t AKeyEvent_getMetaState(event); - + // Save current button and its state currentButtonState[keycode] = AKeyEvent_getAction(event); // Down = 0, Up = 1 @@ -2358,7 +2358,7 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) // NOTE: AndroidManifest.xml must have // Before that change, activity was calling CMD_TERM_WINDOW and CMD_DESTROY when locking mobile, so that was not a normal behaviour return 0; - } + } else if ((keycode == AKEYCODE_BACK) || (keycode == AKEYCODE_MENU)) { // Eat BACK_BUTTON and AKEYCODE_MENU, just do nothing... and don't let to be handled by OS! @@ -2370,36 +2370,36 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) return 0; } } - + int32_t action = AMotionEvent_getAction(event); unsigned int flags = action & AMOTION_EVENT_ACTION_MASK; - + GestureEvent gestureEvent; - + // Register touch actions if (flags == AMOTION_EVENT_ACTION_DOWN) gestureEvent.touchAction = TOUCH_DOWN; else if (flags == AMOTION_EVENT_ACTION_UP) gestureEvent.touchAction = TOUCH_UP; else if (flags == AMOTION_EVENT_ACTION_MOVE) gestureEvent.touchAction = TOUCH_MOVE; - + // Register touch points count gestureEvent.pointCount = AMotionEvent_getPointerCount(event); - + // Register touch points id gestureEvent.pointerId[0] = AMotionEvent_getPointerId(event, 0); gestureEvent.pointerId[1] = AMotionEvent_getPointerId(event, 1); - + // Register touch points position // NOTE: Only two points registered gestureEvent.position[0] = (Vector2){ AMotionEvent_getX(event, 0), AMotionEvent_getY(event, 0) }; gestureEvent.position[1] = (Vector2){ AMotionEvent_getX(event, 1), AMotionEvent_getY(event, 1) }; - + // Normalize gestureEvent.position[x] for screenWidth and screenHeight - gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].x /= (float)GetScreenWidth(); gestureEvent.position[0].y /= (float)GetScreenHeight(); - - gestureEvent.position[1].x /= (float)GetScreenWidth(); + + gestureEvent.position[1].x /= (float)GetScreenWidth(); gestureEvent.position[1].y /= (float)GetScreenHeight(); - + // Gesture data is sent to gestures system for processing ProcessGestureEvent(gestureEvent); @@ -2410,13 +2410,13 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event) #if defined(PLATFORM_WEB) static EM_BOOL EmscriptenFullscreenChangeCallback(int eventType, const EmscriptenFullscreenChangeEvent *e, void *userData) { - //isFullscreen: int e->isFullscreen - //fullscreenEnabled: int e->fullscreenEnabled + //isFullscreen: int e->isFullscreen + //fullscreenEnabled: int e->fullscreenEnabled //fs element nodeName: (char *) e->nodeName //fs element id: (char *) e->id //Current element size: (int) e->elementWidth, (int) e->elementHeight //Screen size:(int) e->screenWidth, (int) e->screenHeight - + if (e->isFullscreen) { TraceLog(INFO, "Canvas scaled to fullscreen. ElementSize: (%ix%i), ScreenSize(%ix%i)", e->elementWidth, e->elementHeight, e->screenWidth, e->screenHeight); @@ -2425,7 +2425,7 @@ static EM_BOOL EmscriptenFullscreenChangeCallback(int eventType, const Emscripte { TraceLog(INFO, "Canvas scaled to windowed. ElementSize: (%ix%i), ScreenSize(%ix%i)", e->elementWidth, e->elementHeight, e->screenWidth, e->screenHeight); } - + // TODO: Depending on scaling factor (screen vs element), calculate factor to scale mouse/touch input return 0; @@ -2445,33 +2445,33 @@ static EM_BOOL EmscriptenInputCallback(int eventType, const EmscriptenTouchEvent x = touchEvent->touches[i].canvasX; y = touchEvent->touches[i].canvasY; } - + printf("%s, numTouches: %d %s%s%s%s\n", emscripten_event_type_to_string(eventType), event->numTouches, event->ctrlKey ? " CTRL" : "", event->shiftKey ? " SHIFT" : "", event->altKey ? " ALT" : "", event->metaKey ? " META" : ""); for(int i = 0; i < event->numTouches; ++i) { const EmscriptenTouchPoint *t = &event->touches[i]; - + printf(" %ld: screen: (%ld,%ld), client: (%ld,%ld), page: (%ld,%ld), isChanged: %d, onTarget: %d, canvas: (%ld, %ld)\n", t->identifier, t->screenX, t->screenY, t->clientX, t->clientY, t->pageX, t->pageY, t->isChanged, t->onTarget, t->canvasX, t->canvasY); } */ - + GestureEvent gestureEvent; // Register touch actions if (eventType == EMSCRIPTEN_EVENT_TOUCHSTART) gestureEvent.touchAction = TOUCH_DOWN; else if (eventType == EMSCRIPTEN_EVENT_TOUCHEND) gestureEvent.touchAction = TOUCH_UP; else if (eventType == EMSCRIPTEN_EVENT_TOUCHMOVE) gestureEvent.touchAction = TOUCH_MOVE; - + // Register touch points count gestureEvent.pointCount = touchEvent->numTouches; - + // Register touch points id gestureEvent.pointerId[0] = touchEvent->touches[0].identifier; gestureEvent.pointerId[1] = touchEvent->touches[1].identifier; - + // Register touch points position // NOTE: Only two points registered // TODO: Touch data should be scaled accordingly! @@ -2482,12 +2482,12 @@ static EM_BOOL EmscriptenInputCallback(int eventType, const EmscriptenTouchEvent touchPosition[0] = gestureEvent.position[0]; touchPosition[1] = gestureEvent.position[1]; - + // Normalize gestureEvent.position[x] for screenWidth and screenHeight - gestureEvent.position[0].x /= (float)GetScreenWidth(); + gestureEvent.position[0].x /= (float)GetScreenWidth(); gestureEvent.position[0].y /= (float)GetScreenHeight(); - - gestureEvent.position[1].x /= (float)GetScreenWidth(); + + gestureEvent.position[1].x /= (float)GetScreenWidth(); gestureEvent.position[1].y /= (float)GetScreenHeight(); // Gesture data is sent to gestures system for processing @@ -2533,7 +2533,7 @@ static void InitKeyboard(void) else { // We reconfigure keyboard mode to get: - // - scancodes (K_RAW) + // - scancodes (K_RAW) // - keycodes (K_MEDIUMRAW) // - ASCII chars (K_XLATE) // - UNICODE chars (K_UNICODE) @@ -2549,7 +2549,7 @@ static void InitKeyboard(void) static void ProcessKeyboard(void) { #define MAX_KEYBUFFER_SIZE 32 // Max size in bytes to read - + // Keyboard input polling (fill keys[256] array with status) int bufferByteCount = 0; // Bytes available on the buffer char keysBuffer[MAX_KEYBUFFER_SIZE]; // Max keys to be read at a time @@ -2564,7 +2564,7 @@ static void ProcessKeyboard(void) for (int i = 0; i < bufferByteCount; i++) { TraceLog(DEBUG, "Bytes on keysBuffer: %i", bufferByteCount); - + //printf("Key(s) bytes: "); //for (int i = 0; i < bufferByteCount; i++) printf("0x%02x ", keysBuffer[i]); //printf("\n"); @@ -2598,7 +2598,7 @@ static void ProcessKeyboard(void) case 0x34: currentKeyState[301] = 1; break; // raylib KEY_F12 default: break; } - + if (keysBuffer[i + 2] == 0x5b) i += 4; else if ((keysBuffer[i + 2] == 0x31) || (keysBuffer[i + 2] == 0x32)) i += 5; } @@ -2615,7 +2615,7 @@ static void ProcessKeyboard(void) i += 3; // Jump to next key } - + // NOTE: Some keys are not directly keymapped (CTRL, ALT, SHIFT) } } @@ -2625,7 +2625,7 @@ static void ProcessKeyboard(void) else { TraceLog(DEBUG, "Pressed key (ASCII): 0x%02x", keysBuffer[i]); - + // Translate lowercase a-z letters to A-Z if ((keysBuffer[i] >= 97) && (keysBuffer[i] <= 122)) { @@ -2634,10 +2634,10 @@ static void ProcessKeyboard(void) else currentKeyState[(int)keysBuffer[i]] = 1; } } - + // Check exit key (same functionality as GLFW3 KeyCallback()) if (currentKeyState[exitKey] == 1) windowShouldClose = true; - + // Check screen capture key if (currentKeyState[301] == 1) TakeScreenshot(); // raylib key: KEY_F12 (GLFW_KEY_F12) } @@ -2647,7 +2647,7 @@ static void RestoreKeyboard(void) { // Reset to default keyboard settings tcsetattr(STDIN_FILENO, TCSANOW, &defaultKeyboardSettings); - + // Reconfigure keyboard to default mode ioctl(STDIN_FILENO, KDSKBMODE, defaultKeyboardMode); } @@ -2677,14 +2677,14 @@ static void InitMouse(void) static void *MouseThread(void *arg) { const unsigned char XSIGN = 1<<4, YSIGN = 1<<5; - - typedef struct { + + typedef struct { char buttons; - char dx, dy; + char dx, dy; } MouseEvent; - + MouseEvent mouse; - + int mouseRelX = 0; int mouseRelY = 0; @@ -2693,7 +2693,7 @@ static void *MouseThread(void *arg) if (read(mouseStream, &mouse, sizeof(MouseEvent)) == (int)sizeof(MouseEvent)) { if ((mouse.buttons & 0x08) == 0) break; // This bit should always be set - + // Check Left button pressed if ((mouse.buttons & 0x01) > 0) currentMouseState[0] = 1; else currentMouseState[0] = 0; @@ -2701,27 +2701,27 @@ static void *MouseThread(void *arg) // Check Right button pressed if ((mouse.buttons & 0x02) > 0) currentMouseState[1] = 1; else currentMouseState[1] = 0; - + // Check Middle button pressed if ((mouse.buttons & 0x04) > 0) currentMouseState[2] = 1; else currentMouseState[2] = 0; - + mouseRelX = (int)mouse.dx; mouseRelY = (int)mouse.dy; - + if ((mouse.buttons & XSIGN) > 0) mouseRelX = -1*(255 - mouseRelX); if ((mouse.buttons & YSIGN) > 0) mouseRelY = -1*(255 - mouseRelY); - + // NOTE: Mouse movement is normalized to not be screen resolution dependant // We suppose 2*255 (max relative movement) is equivalent to screenWidth (max pixels width) // Result after normalization is multiplied by MOUSE_SENSITIVITY factor mousePosition.x += (float)mouseRelX*((float)screenWidth/(2*255))*MOUSE_SENSITIVITY; mousePosition.y -= (float)mouseRelY*((float)screenHeight/(2*255))*MOUSE_SENSITIVITY; - + if (mousePosition.x < 0) mousePosition.x = 0; if (mousePosition.y < 0) mousePosition.y = 0; - + if (mousePosition.x > screenWidth) mousePosition.x = screenWidth; if (mousePosition.y > screenHeight) mousePosition.y = screenHeight; } @@ -2735,12 +2735,12 @@ static void *MouseThread(void *arg) static void InitGamepad(void) { char gamepadDev[128] = ""; - + for (int i = 0; i < MAX_GAMEPADS; i++) { sprintf(gamepadDev, "%s%i", DEFAULT_GAMEPAD_DEV, i); - - if ((gamepadStream[i] = open(gamepadDev, O_RDONLY|O_NONBLOCK)) < 0) + + if ((gamepadStream[i] = open(gamepadDev, O_RDONLY|O_NONBLOCK)) < 0) { // NOTE: Only show message for first gamepad if (i == 0) TraceLog(WARNING, "Gamepad device could not be opened, no gamepad available"); @@ -2758,7 +2758,7 @@ static void InitGamepad(void) else TraceLog(INFO, "Gamepad device initialized successfully"); } } - } + } } // Process Gamepad (/dev/input/js0) @@ -2777,7 +2777,7 @@ static void *GamepadThread(void *arg) // Read gamepad event struct js_event gamepadEvent; - + while (!windowShouldClose) { for (int i = 0; i < MAX_GAMEPADS; i++) @@ -2785,22 +2785,22 @@ static void *GamepadThread(void *arg) if (read(gamepadStream[i], &gamepadEvent, sizeof(struct js_event)) == (int)sizeof(struct js_event)) { gamepadEvent.type &= ~JS_EVENT_INIT; // Ignore synthetic events - + // Process gamepad events by type - if (gamepadEvent.type == JS_EVENT_BUTTON) + if (gamepadEvent.type == JS_EVENT_BUTTON) { TraceLog(DEBUG, "Gamepad button: %i, value: %i", gamepadEvent.number, gamepadEvent.value); - - if (gamepadEvent.number < MAX_GAMEPAD_BUTTONS) + + if (gamepadEvent.number < MAX_GAMEPAD_BUTTONS) { // 1 - button pressed, 0 - button released gamepadButtons[i][gamepadEvent.number] = (int)gamepadEvent.value; } } - else if (gamepadEvent.type == JS_EVENT_AXIS) + else if (gamepadEvent.type == JS_EVENT_AXIS) { TraceLog(DEBUG, "Gamepad axis: %i, value: %i", gamepadEvent.number, gamepadEvent.value); - + if (gamepadEvent.number < MAX_GAMEPAD_AXIS) { // NOTE: Scaling of gamepadEvent.value to get values between -1..1 diff --git a/src/models.c b/src/models.c index 24238ed2..e9044e96 100644 --- a/src/models.c +++ b/src/models.c @@ -81,12 +81,12 @@ void DrawCircle3D(Vector3 center, float radius, float rotationAngle, Vector3 rot rlPushMatrix(); rlTranslatef(center.x, center.y, center.z); rlRotatef(rotationAngle, rotation.x, rotation.y, rotation.z); - + rlBegin(RL_LINES); for (int i = 0; i < 360; i += 10) { rlColor4ub(color.r, color.g, color.b, color.a); - + rlVertex3f(sin(DEG2RAD*i)*radius, cos(DEG2RAD*i)*radius, 0.0f); rlVertex3f(sin(DEG2RAD*(i + 10)) * radius, cos(DEG2RAD*(i + 10)) * radius, 0.0f); } @@ -583,13 +583,13 @@ void DrawLight(Light light) DrawCircle3D(light->position, light->radius, 90.0f, (Vector3){ 0, 1, 0 }, (light->enabled ? light->diffuse : BLACK)); } break; case LIGHT_DIRECTIONAL: - { + { DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); DrawSphereWires(light->position, 0.3f*light->intensity, 4, 8, (light->enabled ? light->diffuse : BLACK)); DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : BLACK)); } break; case LIGHT_SPOT: - { + { DrawLine3D(light->position, light->target, (light->enabled ? light->diffuse : BLACK)); DrawCylinderWires(light->position, 0.0f, 0.3f*light->coneAngle/50, 0.6f, 5, (light->enabled ? light->diffuse : BLACK)); DrawCubeWires(light->target, 0.3f, 0.3f, 0.3f, (light->enabled ? light->diffuse : BLACK)); @@ -602,7 +602,7 @@ void DrawLight(Light light) Model LoadModel(const char *fileName) { Model model = { 0 }; - + // TODO: Initialize default data for model in case loading fails, maybe a cube? if (strcmp(GetExtension(fileName), "obj") == 0) model.mesh = LoadOBJ(fileName); @@ -612,7 +612,7 @@ Model LoadModel(const char *fileName) else { rlglLoadMesh(&model.mesh, false); // Upload vertex data to GPU (static model) - + model.transform = MatrixIdentity(); model.material = LoadDefaultMaterial(); } @@ -626,12 +626,12 @@ Model LoadModelEx(Mesh data, bool dynamic) Model model = { 0 }; model.mesh = data; - + rlglLoadMesh(&model.mesh, dynamic); // Upload vertex data to GPU - + model.transform = MatrixIdentity(); model.material = LoadDefaultMaterial(); - + return model; } @@ -723,11 +723,11 @@ Model LoadModelFromRES(const char *rresName, int resId) Model LoadHeightmap(Image heightmap, Vector3 size) { Model model = { 0 }; - + model.mesh = GenMeshHeightmap(heightmap, size); - + rlglLoadMesh(&model.mesh, false); // Upload vertex data to GPU (static model) - + model.transform = MatrixIdentity(); model.material = LoadDefaultMaterial(); @@ -738,11 +738,11 @@ Model LoadHeightmap(Image heightmap, Vector3 size) Model LoadCubicmap(Image cubicmap) { Model model = { 0 }; - + model.mesh = GenMeshCubicmap(cubicmap, (Vector3){ 1.0f, 1.5f, 1.0f }); - + rlglLoadMesh(&model.mesh, false); // Upload vertex data to GPU (static model) - + model.transform = MatrixIdentity(); model.material = LoadDefaultMaterial(); @@ -755,7 +755,7 @@ void UnloadModel(Model model) rlglUnloadMesh(&model.mesh); UnloadMaterial(model.material); - + TraceLog(INFO, "Unloaded model data from RAM and VRAM"); } @@ -763,10 +763,10 @@ void UnloadModel(Model model) Material LoadMaterial(const char *fileName) { Material material = { 0 }; - + if (strcmp(GetExtension(fileName), "mtl") == 0) material = LoadMTL(fileName); else TraceLog(WARNING, "[%s] Material extension not recognized, it can't be loaded", fileName); - + return material; } @@ -774,7 +774,7 @@ Material LoadMaterial(const char *fileName) Material LoadDefaultMaterial(void) { Material material = { 0 }; - + material.shader = GetDefaultShader(); material.texDiffuse = GetDefaultTexture(); // White texture (1x1 pixel) //material.texNormal; // NOTE: By default, not set @@ -783,9 +783,9 @@ Material LoadDefaultMaterial(void) material.colDiffuse = WHITE; // Diffuse color material.colAmbient = WHITE; // Ambient color material.colSpecular = WHITE; // Specular color - + material.glossiness = 100.0f; // Glossiness level - + return material; } @@ -794,7 +794,7 @@ Material LoadDefaultMaterial(void) Material LoadStandardMaterial(void) { Material material = LoadDefaultMaterial(); - + material.shader = GetStandardShader(); return material; @@ -812,12 +812,12 @@ void UnloadMaterial(Material material) static Mesh GenMeshHeightmap(Image heightmap, Vector3 size) { #define GRAY_VALUE(c) ((c.r+c.g+c.b)/3) - + Mesh mesh = { 0 }; int mapX = heightmap.width; int mapZ = heightmap.height; - + Color *pixels = GetImageData(heightmap); // NOTE: One vertex per pixel @@ -908,7 +908,7 @@ static Mesh GenMeshHeightmap(Image heightmap, Vector3 size) trisCounter += 2; } } - + free(pixels); return mesh; @@ -919,7 +919,7 @@ static Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize) Mesh mesh = { 0 }; Color *cubicmapPixels = GetImageData(cubicmap); - + int mapWidth = cubicmap.width; int mapHeight = cubicmap.height; @@ -1262,9 +1262,9 @@ static Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize) free(mapVertices); free(mapNormals); free(mapTexcoords); - + free(cubicmapPixels); // Free image pixel data - + return mesh; } @@ -1273,7 +1273,7 @@ void DrawModel(Model model, Vector3 position, float scale, Color tint) { Vector3 vScale = { scale, scale, scale }; Vector3 rotationAxis = { 0.0f, 0.0f, 0.0f }; - + DrawModelEx(model, position, rotationAxis, 0.0f, vScale, tint); } @@ -1285,13 +1285,13 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota Matrix matRotation = MatrixRotate(rotationAxis, rotationAngle*DEG2RAD); Matrix matScale = MatrixScale(scale.x, scale.y, scale.z); Matrix matTranslation = MatrixTranslate(position.x, position.y, position.z); - + // Combine model transformation matrix (model.transform) with matrix generated by function parameters (matTransform) //Matrix matModel = MatrixMultiply(model.transform, matTransform); // Transform to world-space coordinates - + model.transform = MatrixMultiply(MatrixMultiply(matScale, matRotation), matTranslation); model.material.colDiffuse = tint; // TODO: Multiply tint color by diffuse color? - + rlglDrawMesh(model.mesh, model.material, model.transform); } @@ -1299,9 +1299,9 @@ void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rota void DrawModelWires(Model model, Vector3 position, float scale, Color tint) { rlEnableWireMode(); - + DrawModel(model, position, scale, tint); - + rlDisableWireMode(); } @@ -1309,9 +1309,9 @@ void DrawModelWires(Model model, Vector3 position, float scale, Color tint) void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint) { rlEnableWireMode(); - + DrawModelEx(model, position, rotationAxis, rotationAngle, scale, tint); - + rlDisableWireMode(); } @@ -1319,7 +1319,7 @@ void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint) { Rectangle sourceRec = { 0, 0, texture.width, texture.height }; - + DrawBillboardRec(camera, texture, sourceRec, center, size, tint); } @@ -1334,7 +1334,7 @@ void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vec Vector3 right = { viewMatrix.m0, viewMatrix.m4, viewMatrix.m8 }; //Vector3 up = { viewMatrix.m1, viewMatrix.m5, viewMatrix.m9 }; - + // NOTE: Billboard locked on axis-Y Vector3 up = { 0.0f, 1.0f, 0.0f }; /* @@ -1384,13 +1384,13 @@ void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vec void DrawBoundingBox(BoundingBox box, Color color) { Vector3 size; - + size.x = fabsf(box.max.x - box.min.x); size.y = fabsf(box.max.y - box.min.y); size.z = fabsf(box.max.z - box.min.z); - + Vector3 center = { box.min.x + size.x/2.0f, box.min.y + size.y/2.0f, box.min.z + size.z/2.0f }; - + DrawCubeWires(center, size.x, size.y, size.z, color); } @@ -1451,14 +1451,14 @@ bool CheckCollisionBoxSphere(BoundingBox box, Vector3 centerSphere, float radius bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius) { bool collision = false; - + Vector3 raySpherePos = VectorSubtract(spherePosition, ray.position); float distance = VectorLength(raySpherePos); float vector = VectorDotProduct(raySpherePos, ray.direction); float d = sphereRadius*sphereRadius - (distance*distance - vector*vector); - + if (d >= 0.0f) collision = true; - + return collision; } @@ -1466,29 +1466,29 @@ bool CheckCollisionRaySphere(Ray ray, Vector3 spherePosition, float sphereRadius bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadius, Vector3 *collisionPoint) { bool collision = false; - + Vector3 raySpherePos = VectorSubtract(spherePosition, ray.position); float distance = VectorLength(raySpherePos); float vector = VectorDotProduct(raySpherePos, ray.direction); float d = sphereRadius*sphereRadius - (distance*distance - vector*vector); - + if (d >= 0.0f) collision = true; - + // Calculate collision point Vector3 offset = ray.direction; float collisionDistance = 0; - + // Check if ray origin is inside the sphere to calculate the correct collision point if (distance < sphereRadius) collisionDistance = vector + sqrt(d); else collisionDistance = vector - sqrt(d); - + VectorScale(&offset, collisionDistance); Vector3 cPoint = VectorAdd(ray.position, offset); - + collisionPoint->x = cPoint.x; collisionPoint->y = cPoint.y; collisionPoint->z = cPoint.z; - + return collision; } @@ -1496,7 +1496,7 @@ bool CheckCollisionRaySphereEx(Ray ray, Vector3 spherePosition, float sphereRadi bool CheckCollisionRayBox(Ray ray, BoundingBox box) { bool collision = false; - + float t[8]; t[0] = (box.min.x - ray.position.x)/ray.direction.x; t[1] = (box.max.x - ray.position.x)/ray.direction.x; @@ -1506,9 +1506,9 @@ bool CheckCollisionRayBox(Ray ray, BoundingBox box) t[5] = (box.max.z - ray.position.z)/ray.direction.z; t[6] = fmax(fmax(fmin(t[0], t[1]), fmin(t[2], t[3])), fmin(t[4], t[5])); t[7] = fmin(fmin(fmax(t[0], t[1]), fmax(t[2], t[3])), fmax(t[4], t[5])); - + collision = !(t[7] < 0 || t[6] > t[7]); - + return collision; } @@ -1524,19 +1524,19 @@ BoundingBox CalculateBoundingBox(Mesh mesh) { minVertex = (Vector3){ mesh.vertices[0], mesh.vertices[1], mesh.vertices[2] }; maxVertex = (Vector3){ mesh.vertices[0], mesh.vertices[1], mesh.vertices[2] }; - + for (int i = 1; i < mesh.vertexCount; i++) { minVertex = VectorMin(minVertex, (Vector3){ mesh.vertices[i*3], mesh.vertices[i*3 + 1], mesh.vertices[i*3 + 2] }); maxVertex = VectorMax(maxVertex, (Vector3){ mesh.vertices[i*3], mesh.vertices[i*3 + 1], mesh.vertices[i*3 + 2] }); } } - + // Create the bounding box BoundingBox box; box.min = minVertex; box.max = maxVertex; - + return box; } @@ -1546,9 +1546,9 @@ BoundingBox CalculateBoundingBox(Mesh mesh) Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *playerPosition, float radius) { #define CUBIC_MAP_HALF_BLOCK_SIZE 0.5 - + Color *cubicmapPixels = GetImageData(cubicmap); - + // Detect the cell where the player is located Vector3 impactDirection = { 0.0f, 0.0f, 0.0f }; @@ -1784,7 +1784,7 @@ Vector3 ResolveCollisionCubicmap(Image cubicmap, Vector3 mapPosition, Vector3 *p playerPosition->y = (1.5f - radius) - 0.01f; impactDirection = (Vector3) { impactDirection.x, 1, impactDirection.z}; } - + free(cubicmapPixels); return impactDirection; @@ -2049,9 +2049,9 @@ static Mesh LoadOBJ(const char *fileName) static Material LoadMTL(const char *fileName) { #define MAX_BUFFER_SIZE 128 - + Material material = { 0 }; // LoadDefaultMaterial(); - + char buffer[MAX_BUFFER_SIZE]; Vector3 color = { 1.0f, 1.0f, 1.0f }; char *mapFileName = NULL; @@ -2069,14 +2069,14 @@ static Material LoadMTL(const char *fileName) while (!feof(mtlFile)) { fgets(buffer, MAX_BUFFER_SIZE, mtlFile); - + switch (buffer[0]) { case 'n': // newmtl string Material name. Begins a new material description. { // TODO: Support multiple materials in a single .mtl sscanf(buffer, "newmtl %s", mapFileName); - + TraceLog(INFO, "[%s] Loading material...", mapFileName); } case 'i': // illum int Illumination model @@ -2123,7 +2123,7 @@ static Material LoadMTL(const char *fileName) { int shininess = 0; sscanf(buffer, "Ns %i", &shininess); - + material.glossiness = (float)shininess; } else if (buffer[1] == 'i') // Ni int Refraction index. @@ -2192,7 +2192,7 @@ static Material LoadMTL(const char *fileName) float ialpha = 0.0f; sscanf(buffer, "Tr %f", &ialpha); material.colDiffuse.a = (unsigned char)((1.0f - ialpha)*255); - + } break; case 'r': // refl string Reflection texture map default: break; @@ -2203,6 +2203,6 @@ static Material LoadMTL(const char *fileName) // NOTE: At this point we have all material data TraceLog(INFO, "[%s] Material loaded successfully", fileName); - + return material; } diff --git a/src/raylib.h b/src/raylib.h index 22494aec..7b7348c8 100644 --- a/src/raylib.h +++ b/src/raylib.h @@ -930,8 +930,8 @@ RLAPI void SetMusicPitch(Music music, float pitch); // Set pit RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds) RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds) -RLAPI AudioStream InitAudioStream(unsigned int sampleRate, - unsigned int sampleSize, +RLAPI AudioStream InitAudioStream(unsigned int sampleRate, + unsigned int sampleSize, unsigned int channels); // Init audio stream (to stream audio pcm data) RLAPI void UpdateAudioStream(AudioStream stream, void *data, int numSamples); // Update audio stream buffers with data RLAPI void CloseAudioStream(AudioStream stream); // Close audio stream and free memory diff --git a/src/rlgl.h b/src/rlgl.h index bcb7c24f..3fc54219 100644 --- a/src/rlgl.h +++ b/src/rlgl.h @@ -107,7 +107,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; // byte type typedef unsigned char byte; - + // Color type, RGBA (32bit) typedef struct Color { unsigned char r; @@ -117,7 +117,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; } Color; // Texture formats (support depends on OpenGL version) - typedef enum { + typedef enum { UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha) UNCOMPRESSED_GRAY_ALPHA, UNCOMPRESSED_R5G6B5, // 16 bpp @@ -157,7 +157,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; // Shader type (generic shader) typedef struct Shader { unsigned int id; // Shader program id - + // Vertex attributes locations (default locations) int vertexLoc; // Vertex attribute location point (default-location = 0) int texcoordLoc; // Texcoord attribute location point (default-location = 1) @@ -169,7 +169,7 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; // Uniform locations int mvpLoc; // ModelView-Projection matrix uniform location point (vertex shader) int tintColorLoc; // Color uniform location point (fragment shader) - + // Texture map locations (generic for any kind of map) int mapTexture0Loc; // Map texture uniform location point (default-texture-unit = 0) int mapTexture1Loc; // Map texture uniform location point (default-texture-unit = 1) @@ -185,14 +185,14 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; int mipmaps; // Mipmap levels, 1 by default int format; // Data format (TextureFormat) } Texture2D; - + // RenderTexture2D type, for texture rendering typedef struct RenderTexture2D { unsigned int id; // Render texture (fbo) id Texture2D texture; // Color buffer attachment texture Texture2D depth; // Depth buffer attachment texture } RenderTexture2D; - + // Material type typedef struct Material { Shader shader; // Standard shader (supports 3 map types: diffuse, normal, specular) @@ -204,10 +204,10 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; Color colDiffuse; // Diffuse color Color colAmbient; // Ambient color Color colSpecular; // Specular color - + float glossiness; // Glossiness level (Ranges from 0 to 1000) } Material; - + // Camera type, defines a camera position/orientation in 3d space typedef struct Camera { Vector3 position; // Camera position @@ -225,22 +225,22 @@ typedef enum { OPENGL_11 = 1, OPENGL_21, OPENGL_33, OPENGL_ES_20 } GlVersion; Vector3 position; // Light position Vector3 target; // Light target: LIGHT_DIRECTIONAL and LIGHT_SPOT (cone direction target) float radius; // Light attenuation radius light intensity reduced with distance (world distance) - + Color diffuse; // Light diffuse color float intensity; // Light intensity level - + float coneAngle; // Light cone max angle: LIGHT_SPOT } LightData, *Light; - + // Light types typedef enum { LIGHT_POINT, LIGHT_DIRECTIONAL, LIGHT_SPOT } LightType; // Color blending modes (pre-defined) typedef enum { BLEND_ALPHA = 0, BLEND_ADDITIVE, BLEND_MULTIPLIED } BlendMode; - + // TraceLog message types typedef enum { INFO = 0, ERROR, WARNING, DEBUG, OTHER } TraceLogType; - + // VR Head Mounted Display devices typedef enum { HMD_DEFAULT_DEVICE = 0, diff --git a/src/rlua.h b/src/rlua.h index b100b06d..1c8c7b38 100644 --- a/src/rlua.h +++ b/src/rlua.h @@ -6,7 +6,7 @@ * The following types: * Color, Vector2, Vector3, Rectangle, Ray, Camera, Camera2D * are treated as objects with named fields, same as in C. -* +* * Lua defines utility functions for creating those objects. * Usage: * local cl = Color(255,255,255,255) @@ -27,7 +27,7 @@ * NOTE 02: * Some raylib functions take a pointer to an array, and the size of that array. * The equivalent Lua functions take only an array table of the specified type UNLESS -* it's a pointer to a large char array (e.g. for images), then it takes (and potentially returns) +* it's a pointer to a large char array (e.g. for images), then it takes (and potentially returns) * a Lua string (without the size argument, as Lua strings are sized by default). * * NOTE 03: @@ -362,7 +362,7 @@ static void LuaBuildOpaqueMetatables(void) lua_pushcfunction(L, &LuaIndexTexture2D); lua_setfield(L, -2, "__index"); lua_pop(L, 1); - + luaL_newmetatable(L, "RenderTexture2D"); lua_pushcfunction(L, &LuaIndexRenderTexture2D); lua_setfield(L, -2, "__index"); @@ -3112,7 +3112,7 @@ int lua_TraceLog(lua_State* L) lua_getfield(L, 1, "format"); /// fmt, args..., [string], format() lua_rotate(L, 1, 2); /// [string], format(), fmt, args... lua_call(L, num_args, 1); /// [string], formatted_string - + TraceLog(arg1, "%s", luaL_checkstring(L,-1)); return 0; } @@ -3525,7 +3525,7 @@ int lua_QuaternionTransform(lua_State* L) // raylib Functions (and data types) list static luaL_Reg raylib_functions[] = { - + // Register non-opaque data types REG(Color) REG(Vector2) @@ -3547,7 +3547,7 @@ static luaL_Reg raylib_functions[] = { REG(ToggleFullscreen) REG(GetScreenWidth) REG(GetScreenHeight) - + REG(ShowCursor) REG(HideCursor) REG(IsCursorHidden) @@ -3563,11 +3563,11 @@ static luaL_Reg raylib_functions[] = { REG(End3dMode) REG(BeginTextureMode) REG(EndTextureMode) - + REG(GetMouseRay) REG(GetWorldToScreen) REG(GetCameraMatrix) - + #if defined(PLATFORM_WEB) REG(SetDrawingLoop) #else @@ -3575,7 +3575,7 @@ static luaL_Reg raylib_functions[] = { #endif REG(GetFPS) REG(GetFrameTime) - + REG(GetColor) REG(GetHexValue) REG(ColorToFloat) @@ -3585,13 +3585,13 @@ static luaL_Reg raylib_functions[] = { REG(Fade) REG(SetConfigFlags) REG(ShowLogo) - + REG(IsFileDropped) REG(GetDroppedFiles) REG(ClearDroppedFiles) REG(StorageSaveValue) REG(StorageLoadValue) - + #if defined(PLATFORM_DESKTOP) || defined(PLATFORM_RPI) || defined(PLATFORM_WEB) REG(IsKeyPressed) REG(IsKeyDown) @@ -3599,7 +3599,7 @@ static luaL_Reg raylib_functions[] = { REG(IsKeyUp) REG(GetKeyPressed) REG(SetExitKey) - + REG(IsGamepadAvailable) REG(GetGamepadAxisMovement) REG(IsGamepadButtonPressed) @@ -3643,13 +3643,13 @@ static luaL_Reg raylib_functions[] = { REG(SetCameraPosition) REG(SetCameraTarget) REG(SetCameraFovy) - + REG(SetCameraPanControl) REG(SetCameraAltControl) REG(SetCameraSmoothZoomControl) REG(SetCameraMoveControls) REG(SetCameraMouseSensitivity) - + REG(DrawPixel) REG(DrawPixelV) REG(DrawLine) @@ -3668,7 +3668,7 @@ static luaL_Reg raylib_functions[] = { REG(DrawPoly) REG(DrawPolyEx) REG(DrawPolyExLines) - + REG(CheckCollisionRecs) REG(CheckCollisionCircles) REG(CheckCollisionCircleRec) @@ -3676,7 +3676,7 @@ static luaL_Reg raylib_functions[] = { REG(CheckCollisionPointRec) REG(CheckCollisionPointCircle) REG(CheckCollisionPointTriangle) - + REG(LoadImage) REG(LoadImageEx) REG(LoadImageRaw) @@ -3712,13 +3712,13 @@ static luaL_Reg raylib_functions[] = { REG(ImageColorBrightness) REG(GenTextureMipmaps) REG(UpdateTexture) - + REG(DrawTexture) REG(DrawTextureV) REG(DrawTextureEx) REG(DrawTextureRec) REG(DrawTexturePro) - + REG(GetDefaultFont) REG(LoadSpriteFont) REG(UnloadSpriteFont) @@ -3727,7 +3727,7 @@ static luaL_Reg raylib_functions[] = { REG(MeasureText) REG(MeasureTextEx) REG(DrawFPS) - + REG(DrawLine3D) REG(DrawCircle3D) REG(DrawCube) @@ -3744,7 +3744,7 @@ static luaL_Reg raylib_functions[] = { REG(DrawGrid) REG(DrawGizmo) REG(DrawLight) - + REG(LoadModel) REG(LoadModelEx) REG(LoadModelFromRES) @@ -3756,7 +3756,7 @@ static luaL_Reg raylib_functions[] = { REG(LoadStandardMaterial) REG(UnloadMaterial) //REG(GenMesh*) // Not ready yet... - + REG(DrawModel) REG(DrawModelEx) REG(DrawModelWires) @@ -3771,7 +3771,7 @@ static luaL_Reg raylib_functions[] = { REG(CheckCollisionRaySphereEx) REG(CheckCollisionRayBox) REG(ResolveCollisionCubicmap) - + REG(LoadShader) REG(UnloadShader) REG(GetDefaultShader) @@ -3789,13 +3789,13 @@ static luaL_Reg raylib_functions[] = { REG(EndBlendMode) REG(CreateLight) REG(DestroyLight) - + REG(InitVrDevice) REG(CloseVrDevice) REG(IsVrDeviceReady) REG(UpdateVrTracking) REG(ToggleVrMode) - + REG(InitAudioDevice) REG(CloseAudioDevice) REG(IsAudioDeviceReady) @@ -3810,7 +3810,7 @@ static luaL_Reg raylib_functions[] = { REG(IsSoundPlaying) REG(SetSoundVolume) REG(SetSoundPitch) - + REG(LoadMusicStream) REG(UnloadMusicStream) REG(UpdateMusicStream) @@ -3823,7 +3823,7 @@ static luaL_Reg raylib_functions[] = { REG(SetMusicPitch) REG(GetMusicTimeLength) REG(GetMusicTimePlayed) - + REG(InitAudioStream) REG(UpdateAudioStream) REG(CloseAudioStream) @@ -3906,7 +3906,7 @@ RLUADEF void InitLuaDevice(void) { mainLuaState = luaL_newstate(); L = mainLuaState; - + LuaStartEnum(); LuaSetEnum("FULLSCREEN_MODE", 1); LuaSetEnum("SHOW_LOGO", 2); @@ -4001,7 +4001,7 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("PS3_BUTTON_L2", 8); LuaSetEnum("PS3_BUTTON_SELECT", 9); LuaSetEnum("PS3_BUTTON_START", 10); - + LuaSetEnum("XBOX_BUTTON_A", 0); LuaSetEnum("XBOX_BUTTON_B", 1); LuaSetEnum("XBOX_BUTTON_X", 2); @@ -4086,9 +4086,9 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("ADDITIVE", BLEND_ADDITIVE); LuaSetEnum("MULTIPLIED", BLEND_MULTIPLIED); LuaEndEnum("BlendMode"); - + LuaStartEnum(); - LuaSetEnum("POINT", LIGHT_POINT); + LuaSetEnum("POINT", LIGHT_POINT); LuaSetEnum("DIRECTIONAL", LIGHT_DIRECTIONAL); LuaSetEnum("SPOT", LIGHT_SPOT); LuaEndEnum("LightType"); @@ -4114,7 +4114,7 @@ RLUADEF void InitLuaDevice(void) LuaSetEnum("FIRST_PERSON", CAMERA_FIRST_PERSON); LuaSetEnum("THIRD_PERSON", CAMERA_THIRD_PERSON); LuaEndEnum("CameraMode"); - + LuaStartEnum(); LuaSetEnum("DEFAULT_DEVICE", HMD_DEFAULT_DEVICE); LuaSetEnum("OCULUS_RIFT_DK2", HMD_OCULUS_RIFT_DK2); @@ -4138,9 +4138,9 @@ RLUADEF void InitLuaDevice(void) lua_pushboolean(L, true); #if defined(PLATFORM_DESKTOP) lua_setglobal(L, "PLATFORM_DESKTOP"); -#elif defined(PLATFORM_ANDROID) +#elif defined(PLATFORM_ANDROID) lua_setglobal(L, "PLATFORM_ANDROID"); -#elif defined(PLATFORM_RPI) +#elif defined(PLATFORM_RPI) lua_setglobal(L, "PLATFORM_RPI"); #elif defined(PLATFORM_WEB) lua_setglobal(L, "PLATFORM_WEB"); @@ -4148,7 +4148,7 @@ RLUADEF void InitLuaDevice(void) luaL_openlibs(L); LuaBuildOpaqueMetatables(); - + LuaRegisterRayLib(0); } @@ -4173,7 +4173,7 @@ RLUADEF void ExecuteLuaCode(const char *code) } int result = luaL_dostring(L, code); - + switch (result) { case LUA_OK: break; @@ -4193,7 +4193,7 @@ RLUADEF void ExecuteLuaFile(const char *filename) } int result = luaL_dofile(L, filename); - + switch (result) { case LUA_OK: break; diff --git a/src/text.c b/src/text.c index 2f347b5d..8dc55455 100644 --- a/src/text.c +++ b/src/text.c @@ -151,7 +151,7 @@ extern void LoadDefaultFont(void) //---------------------------------------------------------------------- int imWidth = 128; int imHeight = 128; - + Color *imagePixels = (Color *)malloc(imWidth*imHeight*sizeof(Color)); for (int i = 0; i < imWidth*imHeight; i++) imagePixels[i] = BLANK; // Initialize array @@ -174,7 +174,7 @@ extern void LoadDefaultFont(void) //FILE *myimage = fopen("default_font.raw", "wb"); //fwrite(image.pixels, 1, 128*128*4, myimage); //fclose(myimage); - + Image image = LoadImageEx(imagePixels, imWidth, imHeight); ImageFormat(&image, UNCOMPRESSED_GRAY_ALPHA); @@ -185,13 +185,13 @@ extern void LoadDefaultFont(void) // Reconstruct charSet using charsWidth[], charsHeight, charsDivisor, numChars //------------------------------------------------------------------------------ - defaultFont.charValues = (int *)malloc(defaultFont.numChars*sizeof(int)); + defaultFont.charValues = (int *)malloc(defaultFont.numChars*sizeof(int)); defaultFont.charRecs = (Rectangle *)malloc(defaultFont.numChars*sizeof(Rectangle)); // Allocate space for our character rectangle data // This memory should be freed at end! --> Done on CloseWindow() - + defaultFont.charOffsets = (Vector2 *)malloc(defaultFont.numChars*sizeof(Vector2)); defaultFont.charAdvanceX = (int *)malloc(defaultFont.numChars*sizeof(int)); - + int currentLine = 0; int currentPosX = charsDivisor; int testPosX = charsDivisor; @@ -199,7 +199,7 @@ extern void LoadDefaultFont(void) for (int i = 0; i < defaultFont.numChars; i++) { defaultFont.charValues[i] = FONT_FIRST_CHAR + i; // First char is 32 - + defaultFont.charRecs[i].x = currentPosX; defaultFont.charRecs[i].y = charsDivisor + currentLine * (charsHeight + charsDivisor); defaultFont.charRecs[i].width = charsWidth[i]; @@ -217,12 +217,12 @@ extern void LoadDefaultFont(void) defaultFont.charRecs[i].y = charsDivisor + currentLine*(charsHeight + charsDivisor); } else currentPosX = testPosX; - + // NOTE: On default font character offsets and xAdvance are not required defaultFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f }; defaultFont.charAdvanceX[i] = 0; } - + defaultFont.size = defaultFont.charRecs[0].height; TraceLog(INFO, "[TEX ID %i] Default font loaded successfully", defaultFont.texture.id); @@ -262,7 +262,7 @@ SpriteFont LoadSpriteFont(const char *fileName) if (image.data != NULL) spriteFont = LoadImageFont(image, MAGENTA, FONT_FIRST_CHAR); UnloadImage(image); } - + if (spriteFont.texture.id == 0) { TraceLog(WARNING, "[%s] SpriteFont could not be loaded, using default font", fileName); @@ -316,15 +316,15 @@ void DrawTextEx(SpriteFont spriteFont, const char *text, Vector2 position, float scaleFactor = fontSize/spriteFont.size; - // NOTE: Some ugly hacks are made to support Latin-1 Extended characters directly + // NOTE: Some ugly hacks are made to support Latin-1 Extended characters directly // written in C code files (codified by default as UTF-8) - + for(int i = 0; i < length; i++) { // TODO: Right now we are supposing characters that follow a continous order and start at FONT_FIRST_CHAR, // this sytem can be improved to support any characters order and init value... // An intermediate table could be created to link char values with predefined char position index in chars rectangle array - + if ((unsigned char)text[i] == 0xc2) // UTF-8 encoding identification HACK! { // Support UTF-8 encoded values from [0xc2 0x80] -> [0xc2 0xbf](¿) @@ -353,8 +353,8 @@ void DrawTextEx(SpriteFont spriteFont, const char *text, Vector2 position, float if (rec.x > 0) { - DrawTexturePro(spriteFont.texture, rec, (Rectangle){ position.x + textOffsetX + spriteFont.charOffsets[(int)text[i] - FONT_FIRST_CHAR].x*scaleFactor, - position.y + textOffsetY + spriteFont.charOffsets[(int)text[i] - FONT_FIRST_CHAR].y*scaleFactor, + DrawTexturePro(spriteFont.texture, rec, (Rectangle){ position.x + textOffsetX + spriteFont.charOffsets[(int)text[i] - FONT_FIRST_CHAR].x*scaleFactor, + position.y + textOffsetY + spriteFont.charOffsets[(int)text[i] - FONT_FIRST_CHAR].y*scaleFactor, rec.width*scaleFactor, rec.height*scaleFactor} , (Vector2){ 0, 0 }, 0.0f, tint); if (spriteFont.charAdvanceX[(int)text[i] - FONT_FIRST_CHAR] == 0) textOffsetX += (rec.width*scaleFactor + spacing); @@ -381,15 +381,15 @@ const char *SubText(const char *text, int position, int length) { static char buffer[MAX_SUBTEXT_LENGTH]; int textLength = strlen(text); - + if (position >= textLength) { position = textLength - 1; length = 0; } - + if (length >= textLength) length = textLength; - + for (int c = 0 ; c < length ; c++) { *(buffer+c) = *(text+position); @@ -421,17 +421,17 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, int fontSize, int int len = strlen(text); int tempLen = 0; // Used to count longer text line num chars int lenCounter = 0; - + int textWidth = 0; int tempTextWidth = 0; // Used to count longer text line width - + int textHeight = spriteFont.size; float scaleFactor; for (int i = 0; i < len; i++) { lenCounter++; - + if (text[i] != '\n') { if (spriteFont.charAdvanceX[(int)text[i] - FONT_FIRST_CHAR] != 0) textWidth += spriteFont.charAdvanceX[(int)text[i] - FONT_FIRST_CHAR]; @@ -444,10 +444,10 @@ Vector2 MeasureTextEx(SpriteFont spriteFont, const char *text, int fontSize, int textWidth = 0; textHeight += (spriteFont.size + spriteFont.size/2); // NOTE: Fixed line spacing of 1.5 lines } - + if (tempLen < lenCounter) tempLen = lenCounter; } - + if (tempTextWidth < textWidth) tempTextWidth = textWidth; if (fontSize <= spriteFont.size) scaleFactor = 1.0f; @@ -496,21 +496,21 @@ void DrawFPS(int posX, int posY) static SpriteFont LoadImageFont(Image image, Color key, int firstChar) { #define COLOR_EQUAL(col1, col2) ((col1.r == col2.r)&&(col1.g == col2.g)&&(col1.b == col2.b)&&(col1.a == col2.a)) - + int charSpacing = 0; int lineSpacing = 0; int x = 0; int y = 0; - + // Default number of characters expected supported #define MAX_FONTCHARS 128 - // We allocate a temporal arrays for chars data measures, + // We allocate a temporal arrays for chars data measures, // once we get the actual number of chars, we copy data to a sized arrays int tempCharValues[MAX_FONTCHARS]; Rectangle tempCharRecs[MAX_FONTCHARS]; - + Color *pixels = GetImageData(image); // Parse image data to get charSpacing and lineSpacing @@ -545,7 +545,7 @@ static SpriteFont LoadImageFont(Image image, Color key, int firstChar) !COLOR_EQUAL((pixels[(lineSpacing + (charHeight+lineSpacing)*lineToRead)*image.width + xPosToRead]), key)) { tempCharValues[index] = firstChar + index; - + tempCharRecs[index].x = xPosToRead; tempCharRecs[index].y = lineSpacing + lineToRead * (charHeight + lineSpacing); tempCharRecs[index].height = charHeight; @@ -564,14 +564,14 @@ static SpriteFont LoadImageFont(Image image, Color key, int firstChar) lineToRead++; xPosToRead = charSpacing; } - + free(pixels); - + TraceLog(DEBUG, "SpriteFont data parsed correctly from image"); - + // Create spritefont with all data parsed from image SpriteFont spriteFont = { 0 }; - + spriteFont.texture = LoadTextureFromImage(image); // Convert loaded image to OpenGL texture spriteFont.numChars = index; @@ -586,12 +586,12 @@ static SpriteFont LoadImageFont(Image image, Color key, int firstChar) { spriteFont.charValues[i] = tempCharValues[i]; spriteFont.charRecs[i] = tempCharRecs[i]; - + // NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0) spriteFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f }; spriteFont.charAdvanceX[i] = 0; } - + spriteFont.size = spriteFont.charRecs[0].height; return spriteFont; @@ -631,7 +631,7 @@ static SpriteFont LoadRBMF(const char *fileName) if (rbmfFile == NULL) { TraceLog(WARNING, "[%s] rBMF font file could not be opened, using default font", fileName); - + spriteFont = GetDefaultFont(); } else @@ -670,10 +670,10 @@ static SpriteFont LoadRBMF(const char *fileName) counter++; } - + Image image = LoadImageEx(imagePixels, rbmfHeader.imgWidth, rbmfHeader.imgHeight); ImageFormat(&image, UNCOMPRESSED_GRAY_ALPHA); - + free(imagePixels); TraceLog(DEBUG, "[%s] Image reconstructed correctly, now converting it to texture", fileName); @@ -685,7 +685,7 @@ static SpriteFont LoadRBMF(const char *fileName) //TraceLog(INFO, "[%s] Starting chars set reconstruction", fileName); // Get characters data using rbmfCharWidthData, rbmfHeader.charHeight, charsDivisor, rbmfHeader.numChars - spriteFont.charValues = (int *)malloc(spriteFont.numChars*sizeof(int)); + spriteFont.charValues = (int *)malloc(spriteFont.numChars*sizeof(int)); spriteFont.charRecs = (Rectangle *)malloc(spriteFont.numChars*sizeof(Rectangle)); spriteFont.charOffsets = (Vector2 *)malloc(spriteFont.numChars*sizeof(Vector2)); spriteFont.charAdvanceX = (int *)malloc(spriteFont.numChars*sizeof(int)); @@ -697,12 +697,12 @@ static SpriteFont LoadRBMF(const char *fileName) for (int i = 0; i < spriteFont.numChars; i++) { spriteFont.charValues[i] = (int)rbmfHeader.firstChar + i; - + spriteFont.charRecs[i].x = currentPosX; spriteFont.charRecs[i].y = charsDivisor + currentLine * ((int)rbmfHeader.charHeight + charsDivisor); spriteFont.charRecs[i].width = (int)rbmfCharWidthData[i]; spriteFont.charRecs[i].height = (int)rbmfHeader.charHeight; - + // NOTE: On image based fonts (XNA style), character offsets and xAdvance are not required (set to 0) spriteFont.charOffsets[i] = (Vector2){ 0.0f, 0.0f }; spriteFont.charAdvanceX[i] = 0; @@ -720,7 +720,7 @@ static SpriteFont LoadRBMF(const char *fileName) } else currentPosX = testPosX; } - + spriteFont.size = spriteFont.charRecs[0].height; TraceLog(INFO, "[%s] rBMF file loaded correctly as SpriteFont", fileName); @@ -738,20 +738,20 @@ static SpriteFont LoadRBMF(const char *fileName) static SpriteFont LoadBMFont(const char *fileName) { #define MAX_BUFFER_SIZE 256 - + SpriteFont font = { 0 }; font.texture.id = 0; - + char buffer[MAX_BUFFER_SIZE]; char *searchPoint = NULL; - + int fontSize = 0; int texWidth, texHeight; char texFileName[128]; int numChars = 0; int base; // Useless data - + FILE *fntFile; fntFile = fopen(fileName, "rt"); @@ -766,42 +766,42 @@ static SpriteFont LoadBMFont(const char *fileName) fgets(buffer, MAX_BUFFER_SIZE, fntFile); //searchPoint = strstr(buffer, "size"); //sscanf(searchPoint, "size=%i", &fontSize); - + fgets(buffer, MAX_BUFFER_SIZE, fntFile); searchPoint = strstr(buffer, "lineHeight"); sscanf(searchPoint, "lineHeight=%i base=%i scaleW=%i scaleH=%i", &fontSize, &base, &texWidth, &texHeight); - + TraceLog(DEBUG, "[%s] Font size: %i", fileName, fontSize); TraceLog(DEBUG, "[%s] Font texture scale: %ix%i", fileName, texWidth, texHeight); - + fgets(buffer, MAX_BUFFER_SIZE, fntFile); searchPoint = strstr(buffer, "file"); sscanf(searchPoint, "file=\"%128[^\"]\"", texFileName); - + TraceLog(DEBUG, "[%s] Font texture filename: %s", fileName, texFileName); - + fgets(buffer, MAX_BUFFER_SIZE, fntFile); searchPoint = strstr(buffer, "count"); sscanf(searchPoint, "count=%i", &numChars); - + TraceLog(DEBUG, "[%s] Font num chars: %i", fileName, numChars); - + // Compose correct path using route of .fnt file (fileName) and texFileName char *texPath = NULL; char *lastSlash = NULL; lastSlash = strrchr(fileName, '/'); - + // NOTE: We need some extra space to avoid memory corruption on next allocations! texPath = malloc(strlen(fileName) - strlen(lastSlash) + strlen(texFileName) + 4); - + // NOTE: strcat() and strncat() required a '\0' terminated string to work! *texPath = '\0'; strncat(texPath, fileName, strlen(fileName) - strlen(lastSlash) + 1); strncat(texPath, texFileName, strlen(texFileName)); TraceLog(DEBUG, "[%s] Font texture loading path: %s", fileName, texPath); - + font.texture = LoadTexture(texPath); font.size = fontSize; font.numChars = numChars; @@ -809,35 +809,35 @@ static SpriteFont LoadBMFont(const char *fileName) font.charRecs = (Rectangle *)malloc(numChars*sizeof(Rectangle)); font.charOffsets = (Vector2 *)malloc(numChars*sizeof(Vector2)); font.charAdvanceX = (int *)malloc(numChars*sizeof(int)); - + free(texPath); - + int charId, charX, charY, charWidth, charHeight, charOffsetX, charOffsetY, charAdvanceX; - + bool unorderedChars = false; int firstChar = 0; - + for (int i = 0; i < numChars; i++) { fgets(buffer, MAX_BUFFER_SIZE, fntFile); - sscanf(buffer, "char id=%i x=%i y=%i width=%i height=%i xoffset=%i yoffset=%i xadvance=%i", + sscanf(buffer, "char id=%i x=%i y=%i width=%i height=%i xoffset=%i yoffset=%i xadvance=%i", &charId, &charX, &charY, &charWidth, &charHeight, &charOffsetX, &charOffsetY, &charAdvanceX); - + if (i == 0) firstChar = charId; else if (i != (charId - firstChar)) unorderedChars = true; - + // Save data properly in sprite font font.charValues[i] = charId; font.charRecs[i] = (Rectangle){ charX, charY, charWidth, charHeight }; font.charOffsets[i] = (Vector2){ (float)charOffsetX, (float)charOffsetY }; font.charAdvanceX[i] = charAdvanceX; } - + fclose(fntFile); - + if (firstChar != FONT_FIRST_CHAR) TraceLog(WARNING, "BMFont not supported: expected SPACE(32) as first character, falling back to default font"); else if (unorderedChars) TraceLog(WARNING, "BMFont not supported: unordered chars data, falling back to default font"); - + // NOTE: Font data could be not ordered by charId: 32,33,34,35... raylib does not support unordered BMFonts if ((firstChar != FONT_FIRST_CHAR) || (unorderedChars) || (font.texture.id == 0)) { @@ -862,9 +862,9 @@ static SpriteFont LoadTTF(const char *fileName, int fontSize, int firstChar, int stbtt_bakedchar *charData = (stbtt_bakedchar *)malloc(sizeof(stbtt_bakedchar)*numChars); SpriteFont font = { 0 }; - + FILE *ttfFile = fopen(fileName, "rb"); - + if (ttfFile == NULL) { TraceLog(WARNING, "[%s] FNT file could not be opened", fileName); @@ -877,11 +877,11 @@ static SpriteFont LoadTTF(const char *fileName, int fontSize, int firstChar, int stbtt_BakeFontBitmap(ttfBuffer,0, fontSize, dataBitmap, FONT_TEXTURE_WIDTH, FONT_TEXTURE_HEIGHT, firstChar, numChars, charData); free(ttfBuffer); - + // Convert image data from grayscale to to UNCOMPRESSED_GRAY_ALPHA unsigned char *dataGrayAlpha = (unsigned char *)malloc(FONT_TEXTURE_WIDTH*FONT_TEXTURE_HEIGHT*sizeof(unsigned char)*2); // Two channels int k = 0; - + for (int i = 0; i < FONT_TEXTURE_WIDTH*FONT_TEXTURE_HEIGHT; i++) { dataGrayAlpha[k] = 255; @@ -889,9 +889,9 @@ static SpriteFont LoadTTF(const char *fileName, int fontSize, int firstChar, int k += 2; } - + free(dataBitmap); - + // Sprite font generation from TTF extracted data Image image; image.width = FONT_TEXTURE_WIDTH; @@ -909,7 +909,7 @@ static SpriteFont LoadTTF(const char *fileName, int fontSize, int firstChar, int font.charRecs = (Rectangle *)malloc(font.numChars*sizeof(Rectangle)); font.charOffsets = (Vector2 *)malloc(font.numChars*sizeof(Vector2)); font.charAdvanceX = (int *)malloc(font.numChars*sizeof(int)); - + for (int i = 0; i < font.numChars; i++) { font.charValues[i] = i + firstChar; @@ -918,11 +918,11 @@ static SpriteFont LoadTTF(const char *fileName, int fontSize, int firstChar, int font.charRecs[i].y = (int)charData[i].y0; font.charRecs[i].width = (int)charData[i].x1 - (int)charData[i].x0; font.charRecs[i].height = (int)charData[i].y1 - (int)charData[i].y0; - + font.charOffsets[i] = (Vector2){ charData[i].xoff, charData[i].yoff }; font.charAdvanceX[i] = (int)charData[i].xadvance; } - + free(charData); return font; diff --git a/src/textures.c b/src/textures.c index c6b7e0bb..8f4fa301 100644 --- a/src/textures.c +++ b/src/textures.c @@ -33,7 +33,7 @@ #include // Required for: strcmp(), strrchr(), strncmp() #include "rlgl.h" // raylib OpenGL abstraction layer to OpenGL 1.1, 3.3 or ES2 - // Required: rlglLoadTexture() rlDeleteTextures(), + // Required: rlglLoadTexture() rlDeleteTextures(), // rlglGenerateMipmaps(), some funcs for DrawTexturePro() #include "utils.h" // rRES data decompression utility function @@ -44,7 +44,7 @@ // NOTE: Used to read image data (multiple formats support) #define STB_IMAGE_RESIZE_IMPLEMENTATION -#include "external/stb_image_resize.h" // Required for: stbir_resize_uint8() +#include "external/stb_image_resize.h" // Required for: stbir_resize_uint8() // NOTE: Used for image scaling on ImageResize() //---------------------------------------------------------------------------------- @@ -103,14 +103,14 @@ Image LoadImage(const char *fileName) int imgWidth = 0; int imgHeight = 0; int imgBpp = 0; - + // NOTE: Using stb_image to load images (Supports: BMP, TGA, PNG, JPG, ...) image.data = stbi_load(fileName, &imgWidth, &imgHeight, &imgBpp, 0); image.width = imgWidth; image.height = imgHeight; image.mipmaps = 1; - + if (imgBpp == 1) image.format = UNCOMPRESSED_GRAYSCALE; else if (imgBpp == 2) image.format = UNCOMPRESSED_GRAY_ALPHA; else if (imgBpp == 3) image.format = UNCOMPRESSED_R8G8B8; @@ -121,12 +121,12 @@ Image LoadImage(const char *fileName) else if (strcmp(GetExtension(fileName),"ktx") == 0) image = LoadKTX(fileName); else if (strcmp(GetExtension(fileName),"pvr") == 0) image = LoadPVR(fileName); else if (strcmp(GetExtension(fileName),"astc") == 0) image = LoadASTC(fileName); - + if (image.data != NULL) - { + { TraceLog(INFO, "[%s] Image loaded successfully (%ix%i)", fileName, image.width, image.height); } - else TraceLog(WARNING, "[%s] Image could not be loaded, file not recognized", fileName); + else TraceLog(WARNING, "[%s] Image could not be loaded, file not recognized", fileName); return image; } @@ -141,11 +141,11 @@ Image LoadImageEx(Color *pixels, int width, int height) image.height = height; image.mipmaps = 1; image.format = UNCOMPRESSED_R8G8B8A8; - + int k = 0; image.data = (unsigned char *)malloc(image.width*image.height*4*sizeof(unsigned char)); - + for (int i = 0; i < image.width*image.height*4; i += 4) { ((unsigned char *)image.data)[i] = pixels[k].r; @@ -180,7 +180,7 @@ Image LoadImageRaw(const char *fileName, int width, int height, int format, int if (headerSize > 0) fseek(rawFile, headerSize, SEEK_SET); unsigned int size = width*height; - + switch (format) { case UNCOMPRESSED_GRAYSCALE: image.data = (unsigned char *)malloc(size); break; // 8 bit per pixel (no alpha) @@ -192,16 +192,16 @@ Image LoadImageRaw(const char *fileName, int width, int height, int format, int case UNCOMPRESSED_R8G8B8A8: image.data = (unsigned char *)malloc(size*4); size *= 4; break; // 32 bpp default: TraceLog(WARNING, "Image format not suported"); break; } - + fread(image.data, size, 1, rawFile); - + // TODO: Check if data have been read - + image.width = width; image.height = height; image.mipmaps = 0; image.format = format; - + fclose(rawFile); } @@ -326,9 +326,9 @@ Texture2D LoadTexture(const char *fileName) Texture2D texture; Image image = LoadImage(fileName); - + if (image.data != NULL) - { + { texture = LoadTextureFromImage(image); UnloadImage(image); } @@ -350,9 +350,9 @@ Texture2D LoadTextureEx(void *data, int width, int height, int textureFormat) texture.height = height; texture.mipmaps = 1; texture.format = textureFormat; - + texture.id = rlglLoadTexture(data, width, height, textureFormat, 1); - + return texture; } @@ -380,7 +380,7 @@ Texture2D LoadTextureFromImage(Image image) texture.height = 0; texture.mipmaps = 0; texture.format = 0; - + texture.id = rlglLoadTexture(image.data, image.width, image.height, image.format, image.mipmaps); texture.width = image.width; @@ -395,7 +395,7 @@ Texture2D LoadTextureFromImage(Image image) RenderTexture2D LoadRenderTexture(int width, int height) { RenderTexture2D target = rlglLoadRenderTexture(width, height); - + return target; } @@ -403,7 +403,7 @@ RenderTexture2D LoadRenderTexture(int width, int height) void UnloadImage(Image image) { free(image.data); - + // NOTE: It becomes anoying every time a texture is loaded //TraceLog(INFO, "Unloaded image data"); } @@ -414,7 +414,7 @@ void UnloadTexture(Texture2D texture) if (texture.id != 0) { rlDeleteTextures(texture.id); - + TraceLog(INFO, "[TEX ID %i] Unloaded texture data from VRAM (GPU)", texture.id); } } @@ -429,7 +429,7 @@ void UnloadRenderTexture(RenderTexture2D target) Color *GetImageData(Image image) { Color *pixels = (Color *)malloc(image.width*image.height*sizeof(Color)); - + int k = 0; for (int i = 0; i < image.width*image.height; i++) @@ -442,7 +442,7 @@ Color *GetImageData(Image image) pixels[i].g = ((unsigned char *)image.data)[k]; pixels[i].b = ((unsigned char *)image.data)[k]; pixels[i].a = 255; - + k++; } break; case UNCOMPRESSED_GRAY_ALPHA: @@ -451,7 +451,7 @@ Color *GetImageData(Image image) pixels[i].g = ((unsigned char *)image.data)[k]; pixels[i].b = ((unsigned char *)image.data)[k]; pixels[i].a = ((unsigned char *)image.data)[k + 1]; - + k += 2; } break; case UNCOMPRESSED_R5G5B5A1: @@ -462,7 +462,7 @@ Color *GetImageData(Image image) pixels[i].g = (unsigned char)((float)((pixel & 0b0000011111000000) >> 6)*(255/31)); pixels[i].b = (unsigned char)((float)((pixel & 0b0000000000111110) >> 1)*(255/31)); pixels[i].a = (unsigned char)((pixel & 0b0000000000000001)*255); - + k++; } break; case UNCOMPRESSED_R5G6B5: @@ -473,18 +473,18 @@ Color *GetImageData(Image image) pixels[i].g = (unsigned char)((float)((pixel & 0b0000011111100000) >> 5)*(255/63)); pixels[i].b = (unsigned char)((float)(pixel & 0b0000000000011111)*(255/31)); pixels[i].a = 255; - + k++; } break; case UNCOMPRESSED_R4G4B4A4: { unsigned short pixel = ((unsigned short *)image.data)[k]; - + pixels[i].r = (unsigned char)((float)((pixel & 0b1111000000000000) >> 12)*(255/15)); pixels[i].g = (unsigned char)((float)((pixel & 0b0000111100000000) >> 8)*(255/15)); pixels[i].b = (unsigned char)((float)((pixel & 0b0000000011110000) >> 4)*(255/15)); pixels[i].a = (unsigned char)((float)(pixel & 0b0000000000001111)*(255/15)); - + k++; } break; case UNCOMPRESSED_R8G8B8A8: @@ -493,7 +493,7 @@ Color *GetImageData(Image image) pixels[i].g = ((unsigned char *)image.data)[k + 1]; pixels[i].b = ((unsigned char *)image.data)[k + 2]; pixels[i].a = ((unsigned char *)image.data)[k + 3]; - + k += 4; } break; case UNCOMPRESSED_R8G8B8: @@ -502,11 +502,11 @@ Color *GetImageData(Image image) pixels[i].g = (unsigned char)((unsigned char *)image.data)[k + 1]; pixels[i].b = (unsigned char)((unsigned char *)image.data)[k + 2]; pixels[i].a = 255; - + k += 3; } break; default: TraceLog(WARNING, "Format not supported for pixel data retrieval"); break; - } + } } return pixels; @@ -522,7 +522,7 @@ Image GetTextureData(Texture2D texture) if (texture.format < 8) { image.data = rlglReadTexturePixels(texture); - + if (image.data != NULL) { image.width = texture.width; @@ -551,29 +551,29 @@ void ImageFormat(Image *image, int newFormat) if ((image->format < 8) && (newFormat < 8)) { Color *pixels = GetImageData(*image); - + free(image->data); - + image->format = newFormat; int k = 0; - + switch (image->format) { case UNCOMPRESSED_GRAYSCALE: { image->data = (unsigned char *)malloc(image->width*image->height*sizeof(unsigned char)); - + for (int i = 0; i < image->width*image->height; i++) { ((unsigned char *)image->data)[i] = (unsigned char)((float)pixels[i].r*0.299f + (float)pixels[i].g*0.587f + (float)pixels[i].b*0.114f); } - + } break; case UNCOMPRESSED_GRAY_ALPHA: { image->data = (unsigned char *)malloc(image->width*image->height*2*sizeof(unsigned char)); - + for (int i = 0; i < image->width*image->height*2; i += 2) { ((unsigned char *)image->data)[i] = (unsigned char)((float)pixels[k].r*0.299f + (float)pixels[k].g*0.587f + (float)pixels[k].b*0.114f); @@ -585,17 +585,17 @@ void ImageFormat(Image *image, int newFormat) case UNCOMPRESSED_R5G6B5: { image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short)); - + unsigned char r = 0; unsigned char g = 0; unsigned char b = 0; - + for (int i = 0; i < image->width*image->height; i++) { r = (unsigned char)(round((float)pixels[k].r*31/255)); g = (unsigned char)(round((float)pixels[k].g*63/255)); b = (unsigned char)(round((float)pixels[k].b*31/255)); - + ((unsigned short *)image->data)[i] = (unsigned short)r << 11 | (unsigned short)g << 5 | (unsigned short)b; } @@ -603,7 +603,7 @@ void ImageFormat(Image *image, int newFormat) case UNCOMPRESSED_R8G8B8: { image->data = (unsigned char *)malloc(image->width*image->height*3*sizeof(unsigned char)); - + for (int i = 0; i < image->width*image->height*3; i += 3) { ((unsigned char *)image->data)[i] = pixels[k].r; @@ -615,49 +615,49 @@ void ImageFormat(Image *image, int newFormat) case UNCOMPRESSED_R5G5B5A1: { #define ALPHA_THRESHOLD 50 - + image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short)); - + unsigned char r = 0; unsigned char g = 0; unsigned char b = 0; unsigned char a = 0; - + for (int i = 0; i < image->width*image->height; i++) { r = (unsigned char)(round((float)pixels[i].r*31/255)); g = (unsigned char)(round((float)pixels[i].g*31/255)); b = (unsigned char)(round((float)pixels[i].b*31/255)); a = (pixels[i].a > ALPHA_THRESHOLD) ? 1 : 0; - + ((unsigned short *)image->data)[i] = (unsigned short)r << 11 | (unsigned short)g << 6 | (unsigned short)b << 1 | (unsigned short)a; } - + } break; case UNCOMPRESSED_R4G4B4A4: { image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short)); - + unsigned char r = 0; unsigned char g = 0; unsigned char b = 0; unsigned char a = 0; - + for (int i = 0; i < image->width*image->height; i++) { r = (unsigned char)(round((float)pixels[i].r*15/255)); g = (unsigned char)(round((float)pixels[i].g*15/255)); b = (unsigned char)(round((float)pixels[i].b*15/255)); a = (unsigned char)(round((float)pixels[i].a*15/255)); - + ((unsigned short *)image->data)[i] = (unsigned short)r << 12 | (unsigned short)g << 8| (unsigned short)b << 4| (unsigned short)a; } - + } break; case UNCOMPRESSED_R8G8B8A8: { image->data = (unsigned char *)malloc(image->width*image->height*4*sizeof(unsigned char)); - + for (int i = 0; i < image->width*image->height*4; i += 4) { ((unsigned char *)image->data)[i] = pixels[k].r; @@ -669,7 +669,7 @@ void ImageFormat(Image *image, int newFormat) } break; default: break; } - + free(pixels); } else TraceLog(WARNING, "Image data format is compressed, can not be converted"); @@ -677,7 +677,7 @@ void ImageFormat(Image *image, int newFormat) } // Dither image data to 16bpp or lower (Floyd-Steinberg dithering) -// NOTE: In case selected bpp do not represent an known 16bit format, +// NOTE: In case selected bpp do not represent an known 16bit format, // dithered data is stored in the LSB part of the unsigned short void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) { @@ -694,14 +694,14 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) else { Color *pixels = GetImageData(*image); - + free(image->data); // free old image data - + if ((image->format != UNCOMPRESSED_R8G8B8) && (image->format != UNCOMPRESSED_R8G8B8A8)) { TraceLog(WARNING, "Image format is already 16bpp or lower, dithering could have no effect"); } - + // Define new image format, check if desired bpp match internal known format if ((rBpp == 5) && (gBpp == 6) && (bBpp == 5) && (aBpp == 0)) image->format = UNCOMPRESSED_R5G6B5; else if ((rBpp == 5) && (gBpp == 5) && (bBpp == 5) && (aBpp == 1)) image->format = UNCOMPRESSED_R5G5B5A1; @@ -714,13 +714,13 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) // NOTE: We will store the dithered data as unsigned short (16bpp) image->data = (unsigned short *)malloc(image->width*image->height*sizeof(unsigned short)); - + Color oldpixel = WHITE; Color newpixel = WHITE; - + int error_r, error_g, error_b; unsigned short pixel_r, pixel_g, pixel_b, pixel_a; // Used for 16bit pixel composition - + #define MIN(a,b) (((a)<(b))?(a):(b)) for (int y = 0; y < image->height; y++) @@ -728,7 +728,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) for (int x = 0; x < image->width; x++) { oldpixel = pixels[y*image->width + x]; - + // NOTE: New pixel obtained by bits truncate, it would be better to round values (check ImageFormat()) newpixel.r = oldpixel.r>>(8 - rBpp); // R bits newpixel.g = oldpixel.g>>(8 - gBpp); // G bits @@ -740,7 +740,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) error_r = (int)oldpixel.r - (int)(newpixel.r<<(8 - rBpp)); error_g = (int)oldpixel.g - (int)(newpixel.g<<(8 - gBpp)); error_b = (int)oldpixel.b - (int)(newpixel.b<<(8 - bBpp)); - + pixels[y*image->width + x] = newpixel; // NOTE: Some cases are out of the array and should be ignored @@ -750,21 +750,21 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) pixels[y*image->width + x+1].g = MIN((int)pixels[y*image->width + x+1].g + (int)((float)error_g*7.0f/16), 0xff); pixels[y*image->width + x+1].b = MIN((int)pixels[y*image->width + x+1].b + (int)((float)error_b*7.0f/16), 0xff); } - + if ((x > 0) && (y < (image->height - 1))) { pixels[(y+1)*image->width + x-1].r = MIN((int)pixels[(y+1)*image->width + x-1].r + (int)((float)error_r*3.0f/16), 0xff); pixels[(y+1)*image->width + x-1].g = MIN((int)pixels[(y+1)*image->width + x-1].g + (int)((float)error_g*3.0f/16), 0xff); pixels[(y+1)*image->width + x-1].b = MIN((int)pixels[(y+1)*image->width + x-1].b + (int)((float)error_b*3.0f/16), 0xff); } - + if (y < (image->height - 1)) { pixels[(y+1)*image->width + x].r = MIN((int)pixels[(y+1)*image->width + x].r + (int)((float)error_r*5.0f/16), 0xff); pixels[(y+1)*image->width + x].g = MIN((int)pixels[(y+1)*image->width + x].g + (int)((float)error_g*5.0f/16), 0xff); pixels[(y+1)*image->width + x].b = MIN((int)pixels[(y+1)*image->width + x].b + (int)((float)error_b*5.0f/16), 0xff); } - + if ((x < (image->width - 1)) && (y < (image->height - 1))) { pixels[(y+1)*image->width + x+1].r = MIN((int)pixels[(y+1)*image->width + x+1].r + (int)((float)error_r*1.0f/16), 0xff); @@ -776,7 +776,7 @@ void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp) pixel_g = (unsigned short)newpixel.g; pixel_b = (unsigned short)newpixel.b; pixel_a = (unsigned short)newpixel.a; - + ((unsigned short *)image->data)[y*image->width + x] = (pixel_r<<(gBpp + bBpp + aBpp)) | (pixel_g<<(bBpp + aBpp)) | (pixel_b<width); int potHeight = GetNextPOT(image->height); @@ -816,13 +816,13 @@ void ImageToPOT(Image *image, Color fillColor) free(pixels); // Free pixels data free(image->data); // Free old image data - + int format = image->format; // Store image data format to reconvert later - + // TODO: Image width and height changes... do we want to store new values or keep the old ones? // NOTE: Issues when using image.width and image.height for sprite animations... *image = LoadImageEx(pixelsPOT, potWidth, potHeight); - + free(pixelsPOT); // Free POT pixels data ImageFormat(image, format); // Reconvert image to previous format @@ -833,9 +833,9 @@ void ImageToPOT(Image *image, Color fillColor) Image ImageCopy(Image image) { Image newImage; - + int size = image.width*image.height; - + switch (image.format) { case UNCOMPRESSED_GRAYSCALE: newImage.data = (unsigned char *)malloc(size); break; // 8 bit per pixel (no alpha) @@ -847,24 +847,24 @@ Image ImageCopy(Image image) case UNCOMPRESSED_R8G8B8A8: newImage.data = (unsigned char *)malloc(size*4); size *= 4; break; // 32 bpp default: TraceLog(WARNING, "Image format not suported for copy"); break; } - + if (newImage.data != NULL) { // NOTE: Size must be provided in bytes memcpy(newImage.data, image.data, size); - + newImage.width = image.width; newImage.height = image.height; newImage.mipmaps = image.mipmaps; newImage.format = image.format; } - + return newImage; } // Crop an image to area defined by a rectangle // NOTE: Security checks are performed in case rectangle goes out of bounds -void ImageCrop(Image *image, Rectangle crop) +void ImageCrop(Image *image, Rectangle crop) { // Security checks to make sure cropping rectangle is inside margins if ((crop.x + crop.width) > image->width) @@ -872,13 +872,13 @@ void ImageCrop(Image *image, Rectangle crop) crop.width = image->width - crop.x; TraceLog(WARNING, "Crop rectangle width out of bounds, rescaled crop width: %i", crop.width); } - + if ((crop.y + crop.height) > image->height) { crop.height = image->height - crop.y; TraceLog(WARNING, "Crop rectangle height out of bounds, rescaled crop height: %i", crop.height); } - + if ((crop.x < image->width) && (crop.y < image->height)) { // Start the cropping process @@ -903,7 +903,7 @@ void ImageCrop(Image *image, Rectangle crop) free(cropPixels); - // Reformat 32bit RGBA image to original format + // Reformat 32bit RGBA image to original format ImageFormat(image, format); } else @@ -916,7 +916,7 @@ void ImageCrop(Image *image, Rectangle crop) // NOTE: Uses stb default scaling filters (both bicubic): // STBIR_DEFAULT_FILTER_UPSAMPLE STBIR_FILTER_CATMULLROM // STBIR_DEFAULT_FILTER_DOWNSAMPLE STBIR_FILTER_MITCHELL (high-quality Catmull-Rom) -void ImageResize(Image *image, int newWidth, int newHeight) +void ImageResize(Image *image, int newWidth, int newHeight) { // Get data as Color pixels array to work with it Color *pixels = GetImageData(*image); @@ -930,81 +930,81 @@ void ImageResize(Image *image, int newWidth, int newHeight) UnloadImage(*image); *image = LoadImageEx(output, newWidth, newHeight); - ImageFormat(image, format); // Reformat 32bit RGBA image to original format - + ImageFormat(image, format); // Reformat 32bit RGBA image to original format + free(output); free(pixels); } // Resize and image to new size using Nearest-Neighbor scaling algorithm -void ImageResizeNN(Image *image,int newWidth,int newHeight) +void ImageResizeNN(Image *image,int newWidth,int newHeight) { Color *pixels = GetImageData(*image); Color *output = (Color *)malloc(newWidth*newHeight*sizeof(Color)); - + // EDIT: added +1 to account for an early rounding problem int x_ratio = (int)((image->width<<16)/newWidth) + 1; int y_ratio = (int)((image->height<<16)/newHeight) + 1; - + int x2, y2; - for (int i = 0; i < newHeight; i++) + for (int i = 0; i < newHeight; i++) { - for (int j = 0; j < newWidth; j++) + for (int j = 0; j < newWidth; j++) { x2 = ((j*x_ratio) >> 16); y2 = ((i*y_ratio) >> 16); - + output[(i*newWidth) + j] = pixels[(y2*image->width) + x2] ; - } - } + } + } int format = image->format; UnloadImage(*image); *image = LoadImageEx(output, newWidth, newHeight); - ImageFormat(image, format); // Reformat 32bit RGBA image to original format - + ImageFormat(image, format); // Reformat 32bit RGBA image to original format + free(output); free(pixels); } // Draw an image (source) within an image (destination) -void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec) +void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec) { // Security checks to avoid size and rectangle issues (out of bounds) // Check that srcRec is inside src image if (srcRec.x < 0) srcRec.x = 0; if (srcRec.y < 0) srcRec.y = 0; - + if ((srcRec.x + srcRec.width) > src.width) { srcRec.width = src.width - srcRec.x; TraceLog(WARNING, "Source rectangle width out of bounds, rescaled width: %i", srcRec.width); } - + if ((srcRec.y + srcRec.height) > src.height) { srcRec.height = src.height - srcRec.y; TraceLog(WARNING, "Source rectangle height out of bounds, rescaled height: %i", srcRec.height); } - + // Check that dstRec is inside dst image if (dstRec.x < 0) dstRec.x = 0; if (dstRec.y < 0) dstRec.y = 0; - + if ((dstRec.x + dstRec.width) > dst->width) { dstRec.width = dst->width - dstRec.x; TraceLog(WARNING, "Destination rectangle width out of bounds, rescaled width: %i", dstRec.width); } - + if ((dstRec.y + dstRec.height) > dst->height) { dstRec.height = dst->height - dstRec.y; TraceLog(WARNING, "Destination rectangle height out of bounds, rescaled height: %i", dstRec.height); } - + // Get dstination image data as Color pixels array to work with it Color *dstPixels = GetImageData(*dst); @@ -1012,14 +1012,14 @@ void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec) ImageCrop(&srcCopy, srcRec); // Crop source image to desired source rectangle // Scale source image in case destination rec size is different than source rec size - if ((dstRec.width != srcRec.width) || (dstRec.height != srcRec.height)) + if ((dstRec.width != srcRec.width) || (dstRec.height != srcRec.height)) { ImageResize(&srcCopy, dstRec.width, dstRec.height); } // Get source image data as Color array Color *srcPixels = GetImageData(srcCopy); - + UnloadImage(srcCopy); // Blit pixels, copy source image into destination @@ -1030,7 +1030,7 @@ void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec) dstPixels[j*dst->width + i] = srcPixels[(j - dstRec.y)*dstRec.width + (i - dstRec.x)]; } } - + UnloadImage(*dst); // NOTE: Only dst->data is unloaded *dst = LoadImageEx(dstPixels, dst->width, dst->height); @@ -1046,9 +1046,9 @@ Image ImageText(const char *text, int fontSize, Color color) int defaultFontSize = 10; // Default Font chars height in pixel if (fontSize < defaultFontSize) fontSize = defaultFontSize; int spacing = fontSize / defaultFontSize; - + Image imText = ImageTextEx(GetDefaultFont(), text, fontSize, spacing, color); - + return imText; } @@ -1062,19 +1062,19 @@ Image ImageTextEx(SpriteFont font, const char *text, float fontSize, int spacing // NOTE: GetTextureData() not available in OpenGL ES Image imFont = GetTextureData(font.texture); - + ImageFormat(&imFont, UNCOMPRESSED_R8G8B8A8); // Required for color tint ImageColorTint(&imFont, tint); // Apply color tint to font Color *fontPixels = GetImageData(imFont); - + // Create image to store text Color *pixels = (Color *)malloc(sizeof(Color)*(int)imSize.x*(int)imSize.y); - + for (int i = 0; i < length; i++) { Rectangle letterRec = font.charRecs[(int)text[i] - 32]; - + for (int y = letterRec.y; y < (letterRec.y + letterRec.height); y++) { for (int x = posX; x < (posX + letterRec.width); x++) @@ -1082,28 +1082,28 @@ Image ImageTextEx(SpriteFont font, const char *text, float fontSize, int spacing pixels[(y - letterRec.y)*(int)imSize.x + x] = fontPixels[y*font.texture.width + (x - posX + letterRec.x)]; } } - + posX += letterRec.width + spacing; } - + UnloadImage(imFont); - + Image imText = LoadImageEx(pixels, (int)imSize.x, (int)imSize.y); - + // Scale image depending on text size if (fontSize > imSize.y) { float scaleFactor = fontSize/imSize.y; TraceLog(INFO, "Scalefactor: %f", scaleFactor); - + // Using nearest-neighbor scaling algorithm for default font if (font.texture.id == GetDefaultFont().texture.id) ImageResizeNN(&imText, (int)(imSize.x*scaleFactor), (int)(imSize.y*scaleFactor)); else ImageResize(&imText, (int)(imSize.x*scaleFactor), (int)(imSize.y*scaleFactor)); } - + free(pixels); free(fontPixels); - + return imText; } @@ -1117,12 +1117,12 @@ void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, void ImageDrawTextEx(Image *dst, Vector2 position, SpriteFont font, const char *text, float fontSize, int spacing, Color color) { Image imText = ImageTextEx(font, text, fontSize, spacing, color); - + Rectangle srcRec = { 0, 0, imText.width, imText.height }; Rectangle dstRec = { (int)position.x, (int)position.y, imText.width, imText.height }; - + ImageDraw(dst, imText, srcRec, dstRec); - + UnloadImage(imText); } @@ -1131,7 +1131,7 @@ void ImageFlipVertical(Image *image) { Color *srcPixels = GetImageData(*image); Color *dstPixels = (Color *)malloc(sizeof(Color)*image->width*image->height); - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1139,14 +1139,14 @@ void ImageFlipVertical(Image *image) dstPixels[y*image->width + x] = srcPixels[(image->height - 1 - y)*image->width + x]; } } - + Image processed = LoadImageEx(dstPixels, image->width, image->height); ImageFormat(&processed, image->format); UnloadImage(*image); - + free(srcPixels); free(dstPixels); - + image->data = processed.data; } @@ -1155,7 +1155,7 @@ void ImageFlipHorizontal(Image *image) { Color *srcPixels = GetImageData(*image); Color *dstPixels = (Color *)malloc(sizeof(Color)*image->width*image->height); - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1163,14 +1163,14 @@ void ImageFlipHorizontal(Image *image) dstPixels[y*image->width + x] = srcPixels[y*image->width + (image->width - 1 - x)]; } } - + Image processed = LoadImageEx(dstPixels, image->width, image->height); ImageFormat(&processed, image->format); UnloadImage(*image); - + free(srcPixels); free(dstPixels); - + image->data = processed.data; } @@ -1178,12 +1178,12 @@ void ImageFlipHorizontal(Image *image) void ImageColorTint(Image *image, Color color) { Color *pixels = GetImageData(*image); - + float cR = (float)color.r/255; float cG = (float)color.g/255; float cB = (float)color.b/255; float cA = (float)color.a/255; - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1204,7 +1204,7 @@ void ImageColorTint(Image *image, Color color) ImageFormat(&processed, image->format); UnloadImage(*image); free(pixels); - + image->data = processed.data; } @@ -1212,7 +1212,7 @@ void ImageColorTint(Image *image, Color color) void ImageColorInvert(Image *image) { Color *pixels = GetImageData(*image); - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1222,12 +1222,12 @@ void ImageColorInvert(Image *image) pixels[y*image->width + x].b = 255 - pixels[y*image->width + x].b; } } - + Image processed = LoadImageEx(pixels, image->width, image->height); ImageFormat(&processed, image->format); UnloadImage(*image); free(pixels); - + image->data = processed.data; } @@ -1243,12 +1243,12 @@ void ImageColorContrast(Image *image, float contrast) { if (contrast < -100) contrast = -100; if (contrast > 100) contrast = 100; - + contrast = (100.0 + contrast)/100.0; contrast *= contrast; - + Color *pixels = GetImageData(*image); - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1287,7 +1287,7 @@ void ImageColorContrast(Image *image, float contrast) ImageFormat(&processed, image->format); UnloadImage(*image); free(pixels); - + image->data = processed.data; } @@ -1297,9 +1297,9 @@ void ImageColorBrightness(Image *image, int brightness) { if (brightness < -255) brightness = -255; if (brightness > 255) brightness = 255; - + Color *pixels = GetImageData(*image); - + for (int y = 0; y < image->height; y++) { for (int x = 0; x < image->width; x++) @@ -1316,7 +1316,7 @@ void ImageColorBrightness(Image *image, int brightness) if (cB < 0) cB = 1; if (cB > 255) cB = 255; - + pixels[y*image->width + x].r = (unsigned char)cR; pixels[y*image->width + x].g = (unsigned char)cG; pixels[y*image->width + x].b = (unsigned char)cB; @@ -1327,7 +1327,7 @@ void ImageColorBrightness(Image *image, int brightness) ImageFormat(&processed, image->format); UnloadImage(*image); free(pixels); - + image->data = processed.data; } @@ -1396,7 +1396,7 @@ void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, V { if (sourceRec.width < 0) sourceRec.x -= sourceRec.width; if (sourceRec.height < 0) sourceRec.y -= sourceRec.height; - + rlEnableTexture(texture.id); rlPushMatrix(); @@ -1439,13 +1439,13 @@ static Image LoadDDS(const char *fileName) { // Required extension: // GL_EXT_texture_compression_s3tc - + // Supported tokens (defined by extensions) // GL_COMPRESSED_RGB_S3TC_DXT1_EXT 0x83F0 // GL_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1 // GL_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2 // GL_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3 - + #define FOURCC_DXT1 0x31545844 // Equivalent to "DXT1" in ASCII #define FOURCC_DXT3 0x33545844 // Equivalent to "DXT3" in ASCII #define FOURCC_DXT5 0x35545844 // Equivalent to "DXT5" in ASCII @@ -1508,7 +1508,7 @@ static Image LoadDDS(const char *fileName) else { ddsHeader header; - + // Get the image header fread(&header, sizeof(ddsHeader), 1, ddsFile); @@ -1537,9 +1537,9 @@ static Image LoadDDS(const char *fileName) { image.data = (unsigned short *)malloc(image.width*image.height*sizeof(unsigned short)); fread(image.data, image.width*image.height*sizeof(unsigned short), 1, ddsFile); - + unsigned char alpha = 0; - + // NOTE: Data comes as A1R5G5B5, it must be reordered to R5G5B5A1 for (int i = 0; i < image.width*image.height; i++) { @@ -1554,9 +1554,9 @@ static Image LoadDDS(const char *fileName) { image.data = (unsigned short *)malloc(image.width*image.height*sizeof(unsigned short)); fread(image.data, image.width*image.height*sizeof(unsigned short), 1, ddsFile); - + unsigned char alpha = 0; - + // NOTE: Data comes as A4R4G4B4, it must be reordered R4G4B4A4 for (int i = 0; i < image.width*image.height; i++) { @@ -1564,7 +1564,7 @@ static Image LoadDDS(const char *fileName) ((unsigned short *)image.data)[i] = ((unsigned short *)image.data)[i] << 4; ((unsigned short *)image.data)[i] += alpha; } - + image.format = UNCOMPRESSED_R4G4B4A4; } } @@ -1574,14 +1574,14 @@ static Image LoadDDS(const char *fileName) // NOTE: not sure if this case exists... image.data = (unsigned char *)malloc(image.width*image.height*3*sizeof(unsigned char)); fread(image.data, image.width*image.height*3, 1, ddsFile); - + image.format = UNCOMPRESSED_R8G8B8; } else if (header.ddspf.flags == 0x41 && header.ddspf.rgbBitCount == 32) // DDS_RGBA, no compressed { image.data = (unsigned char *)malloc(image.width*image.height*4*sizeof(unsigned char)); fread(image.data, image.width*image.height*4, 1, ddsFile); - + unsigned char blue = 0; // NOTE: Data comes as A8R8G8B8, it must be reordered R8G8B8A8 (view next comment) @@ -1593,7 +1593,7 @@ static Image LoadDDS(const char *fileName) ((unsigned char *)image.data)[i] = ((unsigned char *)image.data)[i + 2]; ((unsigned char *)image.data)[i + 2] = blue; } - + image.format = UNCOMPRESSED_R8G8B8A8; } else if (((header.ddspf.flags == 0x04) || (header.ddspf.flags == 0x05)) && (header.ddspf.fourCC > 0)) // Compressed @@ -1603,7 +1603,7 @@ static Image LoadDDS(const char *fileName) // Calculate data size, including all mipmaps if (header.mipmapCount > 1) bufsize = header.pitchOrLinearSize*2; else bufsize = header.pitchOrLinearSize; - + TraceLog(DEBUG, "Pitch or linear size: %i", header.pitchOrLinearSize); image.data = (unsigned char*)malloc(bufsize*sizeof(unsigned char)); @@ -1625,7 +1625,7 @@ static Image LoadDDS(const char *fileName) } } } - + fclose(ddsFile); // Close file pointer } @@ -1640,9 +1640,9 @@ static Image LoadPKM(const char *fileName) // Required extensions: // GL_OES_compressed_ETC1_RGB8_texture (ETC1) (OpenGL ES 2.0) // GL_ARB_ES3_compatibility (ETC2/EAC) (OpenGL ES 3.0) - + // Supported tokens (defined by extensions) - // GL_ETC1_RGB8_OES 0x8D64 + // GL_ETC1_RGB8_OES 0x8D64 // GL_COMPRESSED_RGB8_ETC2 0x9274 // GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 @@ -1656,7 +1656,7 @@ static Image LoadPKM(const char *fileName) unsigned short origWidth; // Original width (big-endian) unsigned short origHeight; // Original height (big-endian) } pkmHeader; - + // Formats list // version 10: format: 0=ETC1_RGB, [1=ETC1_RGBA, 2=ETC1_RGB_MIP, 3=ETC1_RGBA_MIP] (not used) // version 20: format: 0=ETC1_RGB, 1=ETC2_RGB, 2=ETC2_RGBA_OLD, 3=ETC2_RGBA, 4=ETC2_RGBA1, 5=ETC2_R, 6=ETC2_RG, 7=ETC2_SIGNED_R, 8=ETC2_SIGNED_R @@ -1665,7 +1665,7 @@ static Image LoadPKM(const char *fileName) // NOTE: ETC is always 4bit per pixel (64 bit for each 4x4 block of pixels) Image image; - + image.data = NULL; image.width = 0; image.height = 0; @@ -1695,18 +1695,18 @@ static Image LoadPKM(const char *fileName) header.format = ((header.format & 0x00FF) << 8) | ((header.format & 0xFF00) >> 8); header.width = ((header.width & 0x00FF) << 8) | ((header.width & 0xFF00) >> 8); header.height = ((header.height & 0x00FF) << 8) | ((header.height & 0xFF00) >> 8); - + TraceLog(DEBUG, "PKM (ETC) image width: %i", header.width); TraceLog(DEBUG, "PKM (ETC) image height: %i", header.height); TraceLog(DEBUG, "PKM (ETC) image format: %i", header.format); - + image.width = header.width; image.height = header.height; image.mipmaps = 1; - + int bpp = 4; if (header.format == 3) bpp = 8; - + int size = image.width*image.height*bpp/8; // Total data size in bytes image.data = (unsigned char*)malloc(size * sizeof(unsigned char)); @@ -1717,7 +1717,7 @@ static Image LoadPKM(const char *fileName) else if (header.format == 1) image.format = COMPRESSED_ETC2_RGB; else if (header.format == 3) image.format = COMPRESSED_ETC2_EAC_RGBA; } - + fclose(pkmFile); // Close file pointer } @@ -1730,12 +1730,12 @@ static Image LoadKTX(const char *fileName) // Required extensions: // GL_OES_compressed_ETC1_RGB8_texture (ETC1) // GL_ARB_ES3_compatibility (ETC2/EAC) - + // Supported tokens (defined by extensions) // GL_ETC1_RGB8_OES 0x8D64 // GL_COMPRESSED_RGB8_ETC2 0x9274 // GL_COMPRESSED_RGBA8_ETC2_EAC 0x9278 - + // KTX file Header (64 bytes) // https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/ typedef struct { @@ -1754,16 +1754,16 @@ static Image LoadKTX(const char *fileName) unsigned int mipmapLevels; // Non-mipmapped textures = 1 unsigned int keyValueDataSize; // Used to encode any arbitrary data... } ktxHeader; - + // NOTE: Before start of every mipmap data block, we have: unsigned int dataSize - + Image image; image.width = 0; image.height = 0; image.mipmaps = 0; image.format = 0; - + FILE *ktxFile = fopen(fileName, "rb"); if (ktxFile == NULL) @@ -1783,22 +1783,22 @@ static Image LoadKTX(const char *fileName) TraceLog(WARNING, "[%s] KTX file does not seem to be a valid file", fileName); } else - { + { image.width = header.width; image.height = header.height; image.mipmaps = header.mipmapLevels; - + TraceLog(DEBUG, "KTX (ETC) image width: %i", header.width); TraceLog(DEBUG, "KTX (ETC) image height: %i", header.height); TraceLog(DEBUG, "KTX (ETC) image format: 0x%x", header.glInternalFormat); - + unsigned char unused; - + if (header.keyValueDataSize > 0) { for (int i = 0; i < header.keyValueDataSize; i++) fread(&unused, 1, 1, ktxFile); } - + int dataSize; fread(&dataSize, sizeof(unsigned int), 1, ktxFile); @@ -1810,10 +1810,10 @@ static Image LoadKTX(const char *fileName) else if (header.glInternalFormat == 0x9274) image.format = COMPRESSED_ETC2_RGB; else if (header.glInternalFormat == 0x9278) image.format = COMPRESSED_ETC2_EAC_RGBA; } - + fclose(ktxFile); // Close file pointer } - + return image; } @@ -1823,11 +1823,11 @@ static Image LoadPVR(const char *fileName) { // Required extension: // GL_IMG_texture_compression_pvrtc - + // Supported tokens (defined by extensions) // GL_COMPRESSED_RGB_PVRTC_4BPPV1_IMG 0x8C00 // GL_COMPRESSED_RGBA_PVRTC_4BPPV1_IMG 0x8C02 - + #if 0 // Not used... // PVR file v2 Header (52 bytes) typedef struct { @@ -1864,7 +1864,7 @@ static Image LoadPVR(const char *fileName) unsigned int numMipmaps; unsigned int metaDataSize; } pvrHeaderV3; - + #if 0 // Not used... // Metadata (usually 15 bytes) typedef struct { @@ -1872,7 +1872,7 @@ static Image LoadPVR(const char *fileName) unsigned int key; unsigned int dataSize; // Not used? unsigned char *data; // Not used? - } pvrMetadata; + } pvrMetadata; #endif Image image; @@ -1895,15 +1895,15 @@ static Image LoadPVR(const char *fileName) unsigned char pvrVersion = 0; fread(&pvrVersion, sizeof(unsigned char), 1, pvrFile); fseek(pvrFile, 0, SEEK_SET); - + // Load different PVR data formats if (pvrVersion == 0x50) { pvrHeaderV3 header; - + // Get PVR image header fread(&header, sizeof(pvrHeaderV3), 1, pvrFile); - + if ((header.id[0] != 'P') || (header.id[1] != 'V') || (header.id[2] != 'R') || (header.id[3] != 3)) { TraceLog(WARNING, "[%s] PVR file does not seem to be a valid image", fileName); @@ -1913,7 +1913,7 @@ static Image LoadPVR(const char *fileName) image.width = header.width; image.height = header.height; image.mipmaps = header.numMipmaps; - + // Check data format if (((header.channels[0] == 'l') && (header.channels[1] == 0)) && (header.channelDepth[0] == 8)) image.format = UNCOMPRESSED_GRAYSCALE; else if (((header.channels[0] == 'l') && (header.channels[1] == 'a')) && ((header.channelDepth[0] == 8) && (header.channelDepth[1] == 8))) image.format = UNCOMPRESSED_GRAY_ALPHA; @@ -1933,14 +1933,14 @@ static Image LoadPVR(const char *fileName) } else if (header.channels[0] == 2) image.format = COMPRESSED_PVRT_RGB; else if (header.channels[0] == 3) image.format = COMPRESSED_PVRT_RGBA; - + // Skip meta data header unsigned char unused = 0; for (int i = 0; i < header.metaDataSize; i++) fread(&unused, sizeof(unsigned char), 1, pvrFile); - + // Calculate data size (depends on format) int bpp = 0; - + switch (image.format) { case UNCOMPRESSED_GRAYSCALE: bpp = 8; break; @@ -1954,7 +1954,7 @@ static Image LoadPVR(const char *fileName) case COMPRESSED_PVRT_RGBA: bpp = 4; break; default: break; } - + int dataSize = image.width*image.height*bpp/8; // Total data size in bytes image.data = (unsigned char*)malloc(dataSize*sizeof(unsigned char)); @@ -1976,11 +1976,11 @@ static Image LoadASTC(const char *fileName) // Required extensions: // GL_KHR_texture_compression_astc_hdr // GL_KHR_texture_compression_astc_ldr - + // Supported tokens (defined by extensions) // GL_COMPRESSED_RGBA_ASTC_4x4_KHR 0x93b0 // GL_COMPRESSED_RGBA_ASTC_8x8_KHR 0x93b7 - + // ASTC file Header (16 bytes) typedef struct { unsigned char id[4]; // Signature: 0x13 0xAB 0xA1 0x5C @@ -1999,7 +1999,7 @@ static Image LoadASTC(const char *fileName) image.height = 0; image.mipmaps = 0; image.format = 0; - + FILE *astcFile = fopen(fileName, "rb"); if (astcFile == NULL) @@ -2012,7 +2012,7 @@ static Image LoadASTC(const char *fileName) // Get ASTC image header fread(&header, sizeof(astcHeader), 1, astcFile); - + if ((header.id[3] != 0x5c) || (header.id[2] != 0xa1) || (header.id[1] != 0xab) || (header.id[0] != 0x13)) { TraceLog(WARNING, "[%s] ASTC file does not seem to be a valid image", fileName); @@ -2022,31 +2022,31 @@ static Image LoadASTC(const char *fileName) // NOTE: Assuming Little Endian (could it be wrong?) image.width = 0x00000000 | ((int)header.width[2] << 16) | ((int)header.width[1] << 8) | ((int)header.width[0]); image.height = 0x00000000 | ((int)header.height[2] << 16) | ((int)header.height[1] << 8) | ((int)header.height[0]); - + // NOTE: ASTC format only contains one mipmap level image.mipmaps = 1; - + TraceLog(DEBUG, "ASTC image width: %i", image.width); TraceLog(DEBUG, "ASTC image height: %i", image.height); TraceLog(DEBUG, "ASTC image blocks: %ix%i", header.blockX, header.blockY); - + // NOTE: Each block is always stored in 128bit so we can calculate the bpp int bpp = 128/(header.blockX*header.blockY); // NOTE: Currently we only support 2 blocks configurations: 4x4 and 8x8 - if ((bpp == 8) || (bpp == 2)) + if ((bpp == 8) || (bpp == 2)) { int dataSize = image.width*image.height*bpp/8; // Data size in bytes - + image.data = (unsigned char *)malloc(dataSize*sizeof(unsigned char)); fread(image.data, dataSize, 1, astcFile); - + if (bpp == 8) image.format = COMPRESSED_ASTC_4x4_RGBA; else if (bpp == 2) image.format = COMPRESSED_ASTC_4x4_RGBA; } else TraceLog(WARNING, "[%s] ASTC block size configuration not supported", fileName); } - + fclose(astcFile); } -- cgit v1.2.3