raylib.lua

local ffi = require("ffi")
local raylib = ffi.load("lib/osx/libraylib.2.6.0.dylib");

--[[
    LUAJIT 2.0.5
    Raylib 2.6.0
]]

-- https://csl.name/post/luajit-cpp/
-- Extract from https://github.com/raysan5/raylib/blob/master/src/raylib.h

--[[
    Raylib Structures
]]
ffi.cdef([[
    typedef struct Vector2 {
        float x;
        float y;
    } Vector2;
    
    
    typedef struct Vector3 {
        float x;
        float y;
        float z;
    } Vector3;
    
    
    typedef struct Vector4 {
        float x;
        float y;
        float z;
        float w;
    } Vector4;
    
    
    typedef Vector4 Quaternion;
    
    
    typedef struct Matrix {
        float m0, m4, m8, m12;
        float m1, m5, m9, m13;
        float m2, m6, m10, m14;
        float m3, m7, m11, m15;
    } Matrix;
    
    
    typedef struct Color {
        unsigned char r;
        unsigned char g;
        unsigned char b;
        unsigned char a;
    } Color;
    
    
    typedef struct Rectangle {
        float x;
        float y;
        float width;
        float height;
    } Rectangle;
    
    
    
    typedef struct Image {
        void *data;             
        int width;              
        int height;             
        int mipmaps;            
        int format;             
    } Image;
    
    
    
    typedef struct Texture2D {
        unsigned int id;        
        int width;              
        int height;             
        int mipmaps;            
        int format;             
    } Texture2D;
    
    
    typedef Texture2D Texture;
    
    
    typedef Texture2D TextureCubemap;
    
    
    typedef struct RenderTexture2D {
        unsigned int id;        
        Texture2D texture;      
        Texture2D depth;        
        bool depthTexture;      
    } RenderTexture2D;
    
    
    typedef RenderTexture2D RenderTexture;
    
    
    typedef struct NPatchInfo {
        Rectangle sourceRec;   
        int left;              
        int top;               
        int right;             
        int bottom;            
        int type;              
    } NPatchInfo;
    
    
    typedef struct CharInfo {
        int value;              
        int offsetX;            
        int offsetY;            
        int advanceX;           
        Image image;            
    } CharInfo;
    
    
    typedef struct Font {
        int baseSize;           
        int charsCount;         
        Texture2D texture;      
        Rectangle *recs;        
        CharInfo *chars;        
    } Font;
    
    typedef Font SpriteFont;     
    
    
    typedef struct Camera3D {
        Vector3 position;       
        Vector3 target;         
        Vector3 up;             
        float fovy;             
        int type;               
    } Camera3D;
    
    typedef Camera3D Camera;    
    
    
    typedef struct Camera2D {
        Vector2 offset;         
        Vector2 target;         
        float rotation;         
        float zoom;             
    } Camera2D;
    
    
    
    typedef struct Mesh {
        int vertexCount;        
        int triangleCount;      
    
        
        float *vertices;        
        float *texcoords;       
        float *texcoords2;      
        float *normals;         
        float *tangents;        
        unsigned char *colors;  
        unsigned short *indices;
    
        
        float *animVertices;    
        float *animNormals;     
        int *boneIds;           
        float *boneWeights;     
    
        
        unsigned int vaoId;     
        unsigned int *vboId;    
    } Mesh;
    
    
    typedef struct Shader {
        unsigned int id;        
        int *locs;              
    } Shader;
    
    
    typedef struct MaterialMap {
        Texture2D texture;      
        Color color;            
        float value;            
    } MaterialMap;
    
    
    typedef struct Material {
        Shader shader;          
        MaterialMap *maps;      
        float *params;          
    } Material;
    
    
    typedef struct Transform {
        Vector3 translation;    
        Quaternion rotation;    
        Vector3 scale;          
    } Transform;
    
    
    typedef struct BoneInfo {
        char name[32];          
        int parent;             
    } BoneInfo;
    
    
    typedef struct Model {
        Matrix transform;       
    
        int meshCount;          
        Mesh *meshes;           
    
        int materialCount;      
        Material *materials;    
        int *meshMaterial;      
    
        
        int boneCount;          
        BoneInfo *bones;        
        Transform *bindPose;    
    } Model;
    
    
    typedef struct ModelAnimation {
        int boneCount;          
        BoneInfo *bones;        
    
        int frameCount;         
        Transform **framePoses; 
    } ModelAnimation;
    
    
    typedef struct Ray {
        Vector3 position;       
        Vector3 direction;      
    } Ray;
    
    
    typedef struct RayHitInfo {
        bool hit;               
        float distance;         
        Vector3 position;       
        Vector3 normal;         
    } RayHitInfo;
    
    
    typedef struct BoundingBox {
        Vector3 min;            
        Vector3 max;            
    } BoundingBox;
    
    
    typedef struct Wave {
        unsigned int sampleCount;       
        unsigned int sampleRate;        
        unsigned int sampleSize;        
        unsigned int channels;          
        void *data;                     
    } Wave;
    
    typedef struct rAudioBuffer rAudioBuffer;
    
    
    
    typedef struct AudioStream {
        unsigned int sampleRate;        
        unsigned int sampleSize;        
        unsigned int channels;          
    
        rAudioBuffer *buffer;           
    } AudioStream;
    
    
    typedef struct Sound {
        unsigned int sampleCount;       
        AudioStream stream;             
    } Sound;
    
    
    
    typedef struct Music {
        int ctxType;                    
        void *ctxData;                  
    
        unsigned int sampleCount;       
        unsigned int loopCount;         
    
        AudioStream stream;             
    } Music;
    
    
    typedef struct VrDeviceInfo {
        int hResolution;                
        int vResolution;                
        float hScreenSize;              
        float vScreenSize;              
        float vScreenCenter;            
        float eyeToScreenDistance;      
        float lensSeparationDistance;   
        float interpupillaryDistance;   
        float lensDistortionValues[4];  
        float chromaAbCorrection[4];    
    } VrDeviceInfo;
    
    
    
    
    
    
    typedef enum {
        FLAG_RESERVED           = 1,    
        FLAG_FULLSCREEN_MODE    = 2,    
        FLAG_WINDOW_RESIZABLE   = 4,    
        FLAG_WINDOW_UNDECORATED = 8,    
        FLAG_WINDOW_TRANSPARENT = 16,   
        FLAG_WINDOW_HIDDEN      = 128,  
        FLAG_WINDOW_ALWAYS_RUN  = 256,  
        FLAG_MSAA_4X_HINT       = 32,   
        FLAG_VSYNC_HINT         = 64    
    } ConfigFlag;
    
    
    typedef enum {
        LOG_ALL = 0,        
        LOG_TRACE,
        LOG_DEBUG,
        LOG_INFO,
        LOG_WARNING,
        LOG_ERROR,
        LOG_FATAL,
        LOG_NONE            
    } TraceLogType;
    
    
    typedef enum {
        
        KEY_APOSTROPHE      = 39,
        KEY_COMMA           = 44,
        KEY_MINUS           = 45,
        KEY_PERIOD          = 46,
        KEY_SLASH           = 47,
        KEY_ZERO            = 48,
        KEY_ONE             = 49,
        KEY_TWO             = 50,
        KEY_THREE           = 51,
        KEY_FOUR            = 52,
        KEY_FIVE            = 53,
        KEY_SIX             = 54,
        KEY_SEVEN           = 55,
        KEY_EIGHT           = 56,
        KEY_NINE            = 57,
        KEY_SEMICOLON       = 59,
        KEY_EQUAL           = 61,
        KEY_A               = 65,
        KEY_B               = 66,
        KEY_C               = 67,
        KEY_D               = 68,
        KEY_E               = 69,
        KEY_F               = 70,
        KEY_G               = 71,
        KEY_H               = 72,
        KEY_I               = 73,
        KEY_J               = 74,
        KEY_K               = 75,
        KEY_L               = 76,
        KEY_M               = 77,
        KEY_N               = 78,
        KEY_O               = 79,
        KEY_P               = 80,
        KEY_Q               = 81,
        KEY_R               = 82,
        KEY_S               = 83,
        KEY_T               = 84,
        KEY_U               = 85,
        KEY_V               = 86,
        KEY_W               = 87,
        KEY_X               = 88,
        KEY_Y               = 89,
        KEY_Z               = 90,
    
        
        KEY_SPACE           = 32,
        KEY_ESCAPE          = 256,
        KEY_ENTER           = 257,
        KEY_TAB             = 258,
        KEY_BACKSPACE       = 259,
        KEY_INSERT          = 260,
        KEY_DELETE          = 261,
        KEY_RIGHT           = 262,
        KEY_LEFT            = 263,
        KEY_DOWN            = 264,
        KEY_UP              = 265,
        KEY_PAGE_UP         = 266,
        KEY_PAGE_DOWN       = 267,
        KEY_HOME            = 268,
        KEY_END             = 269,
        KEY_CAPS_LOCK       = 280,
        KEY_SCROLL_LOCK     = 281,
        KEY_NUM_LOCK        = 282,
        KEY_PRINT_SCREEN    = 283,
        KEY_PAUSE           = 284,
        KEY_F1              = 290,
        KEY_F2              = 291,
        KEY_F3              = 292,
        KEY_F4              = 293,
        KEY_F5              = 294,
        KEY_F6              = 295,
        KEY_F7              = 296,
        KEY_F8              = 297,
        KEY_F9              = 298,
        KEY_F10             = 299,
        KEY_F11             = 300,
        KEY_F12             = 301,
        KEY_LEFT_SHIFT      = 340,
        KEY_LEFT_CONTROL    = 341,
        KEY_LEFT_ALT        = 342,
        KEY_LEFT_SUPER      = 343,
        KEY_RIGHT_SHIFT     = 344,
        KEY_RIGHT_CONTROL   = 345,
        KEY_RIGHT_ALT       = 346,
        KEY_RIGHT_SUPER     = 347,
        KEY_KB_MENU         = 348,
        KEY_LEFT_BRACKET    = 91,
        KEY_BACKSLASH       = 92,
        KEY_RIGHT_BRACKET   = 93,
        KEY_GRAVE           = 96,
    
        
        KEY_KP_0            = 320,
        KEY_KP_1            = 321,
        KEY_KP_2            = 322,
        KEY_KP_3            = 323,
        KEY_KP_4            = 324,
        KEY_KP_5            = 325,
        KEY_KP_6            = 326,
        KEY_KP_7            = 327,
        KEY_KP_8            = 328,
        KEY_KP_9            = 329,
        KEY_KP_DECIMAL      = 330,
        KEY_KP_DIVIDE       = 331,
        KEY_KP_MULTIPLY     = 332,
        KEY_KP_SUBTRACT     = 333,
        KEY_KP_ADD          = 334,
        KEY_KP_ENTER        = 335,
        KEY_KP_EQUAL        = 336
    } KeyboardKey;
    
    
    typedef enum {
        KEY_BACK            = 4,
        KEY_MENU            = 82,
        KEY_VOLUME_UP       = 24,
        KEY_VOLUME_DOWN     = 25
    } AndroidButton;
    
    
    typedef enum {
        MOUSE_LEFT_BUTTON   = 0,
        MOUSE_RIGHT_BUTTON  = 1,
        MOUSE_MIDDLE_BUTTON = 2
    } MouseButton;
    
    
    typedef enum {
        GAMEPAD_PLAYER1     = 0,
        GAMEPAD_PLAYER2     = 1,
        GAMEPAD_PLAYER3     = 2,
        GAMEPAD_PLAYER4     = 3
    } GamepadNumber;
    
    
    typedef enum {
        
        GAMEPAD_BUTTON_UNKNOWN = 0,
    
        
        GAMEPAD_BUTTON_LEFT_FACE_UP,
        GAMEPAD_BUTTON_LEFT_FACE_RIGHT,
        GAMEPAD_BUTTON_LEFT_FACE_DOWN,
        GAMEPAD_BUTTON_LEFT_FACE_LEFT,
    
        
        
        
        
        GAMEPAD_BUTTON_RIGHT_FACE_UP,
        GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,
        GAMEPAD_BUTTON_RIGHT_FACE_DOWN,
        GAMEPAD_BUTTON_RIGHT_FACE_LEFT,
    
        
        GAMEPAD_BUTTON_LEFT_TRIGGER_1,
        GAMEPAD_BUTTON_LEFT_TRIGGER_2,
        GAMEPAD_BUTTON_RIGHT_TRIGGER_1,
        GAMEPAD_BUTTON_RIGHT_TRIGGER_2,
    
        
        GAMEPAD_BUTTON_MIDDLE_LEFT,     
        GAMEPAD_BUTTON_MIDDLE,          
        GAMEPAD_BUTTON_MIDDLE_RIGHT,    
    
        
        GAMEPAD_BUTTON_LEFT_THUMB,
        GAMEPAD_BUTTON_RIGHT_THUMB
    } GamepadButton;
    
    typedef enum {
        
        GAMEPAD_AXIS_UNKNOWN = 0,
    
        
        GAMEPAD_AXIS_LEFT_X,
        GAMEPAD_AXIS_LEFT_Y,
    
        
        GAMEPAD_AXIS_RIGHT_X,
        GAMEPAD_AXIS_RIGHT_Y,
    
        
        GAMEPAD_AXIS_LEFT_TRIGGER,      
        GAMEPAD_AXIS_RIGHT_TRIGGER      
    } GamepadAxis;
    
    
    typedef enum {
        LOC_VERTEX_POSITION = 0,
        LOC_VERTEX_TEXCOORD01,
        LOC_VERTEX_TEXCOORD02,
        LOC_VERTEX_NORMAL,
        LOC_VERTEX_TANGENT,
        LOC_VERTEX_COLOR,
        LOC_MATRIX_MVP,
        LOC_MATRIX_MODEL,
        LOC_MATRIX_VIEW,
        LOC_MATRIX_PROJECTION,
        LOC_VECTOR_VIEW,
        LOC_COLOR_DIFFUSE,
        LOC_COLOR_SPECULAR,
        LOC_COLOR_AMBIENT,
        LOC_MAP_ALBEDO,          
        LOC_MAP_METALNESS,       
        LOC_MAP_NORMAL,
        LOC_MAP_ROUGHNESS,
        LOC_MAP_OCCLUSION,
        LOC_MAP_EMISSION,
        LOC_MAP_HEIGHT,
        LOC_MAP_CUBEMAP,
        LOC_MAP_IRRADIANCE,
        LOC_MAP_PREFILTER,
        LOC_MAP_BRDF,
        LOC_MAP_DIFFUSE = LOC_MAP_ALBEDO,
        LOC_MAP_SPECULAR = LOC_MAP_METALNESS
    } ShaderLocationIndex;
    
    typedef enum {
        UNIFORM_FLOAT = 0,
        UNIFORM_VEC2,
        UNIFORM_VEC3,
        UNIFORM_VEC4,
        UNIFORM_INT,
        UNIFORM_IVEC2,
        UNIFORM_IVEC3,
        UNIFORM_IVEC4,
        UNIFORM_SAMPLER2D
    } ShaderUniformDataType;
    
    
    typedef enum {
        MAP_ALBEDO    = 0,       
        MAP_METALNESS = 1,       
        MAP_NORMAL    = 2,
        MAP_ROUGHNESS = 3,
        MAP_OCCLUSION,
        MAP_EMISSION,
        MAP_HEIGHT,
        MAP_CUBEMAP,             
        MAP_IRRADIANCE,          
        MAP_PREFILTER,           
        MAP_BRDF,
        MAP_DIFFUSE = MAP_ALBEDO,
        MAP_SPECULAR = MAP_METALNESS
    } MaterialMapType;
    
    
    typedef enum {
        UNCOMPRESSED_GRAYSCALE = 1,     
        UNCOMPRESSED_GRAY_ALPHA,        
        UNCOMPRESSED_R5G6B5,            
        UNCOMPRESSED_R8G8B8,            
        UNCOMPRESSED_R5G5B5A1,          
        UNCOMPRESSED_R4G4B4A4,          
        UNCOMPRESSED_R8G8B8A8,          
        UNCOMPRESSED_R32,               
        UNCOMPRESSED_R32G32B32,         
        UNCOMPRESSED_R32G32B32A32,      
        COMPRESSED_DXT1_RGB,            
        COMPRESSED_DXT1_RGBA,           
        COMPRESSED_DXT3_RGBA,           
        COMPRESSED_DXT5_RGBA,           
        COMPRESSED_ETC1_RGB,            
        COMPRESSED_ETC2_RGB,            
        COMPRESSED_ETC2_EAC_RGBA,       
        COMPRESSED_PVRT_RGB,            
        COMPRESSED_PVRT_RGBA,           
        COMPRESSED_ASTC_4x4_RGBA,       
        COMPRESSED_ASTC_8x8_RGBA        
    } PixelFormat;
    
    
    
    
    typedef enum {
        FILTER_POINT = 0,               
        FILTER_BILINEAR,                
        FILTER_TRILINEAR,               
        FILTER_ANISOTROPIC_4X,          
        FILTER_ANISOTROPIC_8X,          
        FILTER_ANISOTROPIC_16X,         
    } TextureFilterMode;
    
    
    typedef enum {
        CUBEMAP_AUTO_DETECT = 0,        
        CUBEMAP_LINE_VERTICAL,          
        CUBEMAP_LINE_HORIZONTAL,        
        CUBEMAP_CROSS_THREE_BY_FOUR,    
        CUBEMAP_CROSS_FOUR_BY_THREE,    
        CUBEMAP_PANORAMA                
    } CubemapLayoutType;
    
    
    typedef enum {
        WRAP_REPEAT = 0,        
        WRAP_CLAMP,             
        WRAP_MIRROR_REPEAT,     
        WRAP_MIRROR_CLAMP       
    } TextureWrapMode;
    
    
    typedef enum {
        FONT_DEFAULT = 0,       
        FONT_BITMAP,            
        FONT_SDF                
    } FontType;
    
    
    typedef enum {
        BLEND_ALPHA = 0,        
        BLEND_ADDITIVE,         
        BLEND_MULTIPLIED        
    } BlendMode;
    
    
    
    typedef enum {
        GESTURE_NONE        = 0,
        GESTURE_TAP         = 1,
        GESTURE_DOUBLETAP   = 2,
        GESTURE_HOLD        = 4,
        GESTURE_DRAG        = 8,
        GESTURE_SWIPE_RIGHT = 16,
        GESTURE_SWIPE_LEFT  = 32,
        GESTURE_SWIPE_UP    = 64,
        GESTURE_SWIPE_DOWN  = 128,
        GESTURE_PINCH_IN    = 256,
        GESTURE_PINCH_OUT   = 512
    } GestureType;
    
    
    typedef enum {
        CAMERA_CUSTOM = 0,
        CAMERA_FREE,
        CAMERA_ORBITAL,
        CAMERA_FIRST_PERSON,
        CAMERA_THIRD_PERSON
    } CameraMode;
    
    
    typedef enum {
        CAMERA_PERSPECTIVE = 0,
        CAMERA_ORTHOGRAPHIC
    } CameraType;
    
    
    typedef enum {
        NPT_9PATCH = 0,         
        NPT_3PATCH_VERTICAL,    
        NPT_3PATCH_HORIZONTAL   
    } NPatchType;

    typedef void (*TraceLogCallback)(int logType, const char *text, va_list args);
]])


--[[
    Colours
]]
LIGHTGRAY = ffi.new("Color", { 200, 200, 200, 255 })
GRAY = ffi.new("Color", { 130, 130, 130, 255 })
DARKGRAY = ffi.new("Color", { 80, 80, 80, 255 })
YELLOW = ffi.new("Color", { 253, 249, 0, 255 }     )
GOLD = ffi.new("Color", { 255, 203, 0, 255 }     )
ORANGE = ffi.new("Color", { 255, 161, 0, 255 }     )
PINK = ffi.new("Color", { 255, 109, 194, 255 }   )
RED = ffi.new("Color", { 230, 41, 55, 255 }     )
MAROON = ffi.new("Color", { 190, 33, 55, 255 }     )
GREEN = ffi.new("Color", { 0, 228, 48, 255 }      )
LIME = ffi.new("Color", { 0, 158, 47, 255 }      )
DARKGREEN = ffi.new("Color", { 0, 117, 44, 255 }      )
SKYBLUE = ffi.new("Color", { 102, 191, 255, 255 }   )
BLUE = ffi.new("Color", { 0, 121, 241, 255 }     )
DARKBLUE = ffi.new("Color", { 0, 82, 172, 255 }      )
PURPLE = ffi.new("Color", { 200, 122, 255, 255 }   )
VIOLET = ffi.new("Color", { 135, 60, 190, 255 }    )
DARKPURPLE = ffi.new("Color", { 112, 31, 126, 255 }    )
BEIGE = ffi.new("Color", { 211, 176, 131, 255 }   )
BROWN = ffi.new("Color", { 127, 106, 79, 255 }    )
DARKBROWN = ffi.new("Color", { 76, 63, 47, 255 }      )

WHITE = ffi.new("Color", { 255, 255, 255, 255 }   )
BLACK = ffi.new("Color", { 0, 0, 0, 255 }         )
BLANK = ffi.new("Color", { 0, 0, 0, 0 }  )
MAGENTA = ffi.new("Color", { 255, 0, 255, 255 } )
RAYWHITE = ffi.new("Color", { 245, 245, 245, 255 } )

--]]

--[[
    Module: core
]]
ffi.cdef([[
    void InitWindow(int width, int height, const char *title);              
    bool WindowShouldClose(void);                                           
    void CloseWindow(void);                                                 
    bool IsWindowReady(void);                                               
    bool IsWindowMinimized(void);                                           
    bool IsWindowResized(void);                                             
    bool IsWindowHidden(void);                                              
    void ToggleFullscreen(void);                                            
    void UnhideWindow(void);                                                
    void HideWindow(void);                                                  
    void SetWindowIcon(Image image);                                        
    void SetWindowTitle(const char *title);                                 
    void SetWindowPosition(int x, int y);                                   
    void SetWindowMonitor(int monitor);                                     
    void SetWindowMinSize(int width, int height);                           
    void SetWindowSize(int width, int height);                              
    void *GetWindowHandle(void);                                            
    int GetScreenWidth(void);                                               
    int GetScreenHeight(void);                                              
    int GetMonitorCount(void);                                              
    int GetMonitorWidth(int monitor);                                       
    int GetMonitorHeight(int monitor);                                      
    int GetMonitorPhysicalWidth(int monitor);                               
    int GetMonitorPhysicalHeight(int monitor);                              
    Vector2 GetWindowPosition(void);                                        
    const char *GetMonitorName(int monitor);                                
    const char *GetClipboardText(void);                                     
    void SetClipboardText(const char *text);                                
                
    
    void ShowCursor(void);                                                  
    void HideCursor(void);                                                  
    bool IsCursorHidden(void);                                              
    void EnableCursor(void);                                                
    void DisableCursor(void);                                               
                
    
    void ClearBackground(Color color);                                      
    void BeginDrawing(void);                                                
    void EndDrawing(void);                                                  
    void BeginMode2D(Camera2D camera);                                      
    void EndMode2D(void);                                                   
    void BeginMode3D(Camera3D camera);                                      
    void EndMode3D(void);                                                   
    void BeginTextureMode(RenderTexture2D target);                          
    void EndTextureMode(void);                                              
    void BeginScissorMode(int x, int y, int width, int height);             
    void EndScissorMode(void);                                              
                
    
    Ray GetMouseRay(Vector2 mousePosition, Camera camera);                  
    Matrix GetCameraMatrix(Camera camera);                                  
    Matrix GetCameraMatrix2D(Camera2D camera);                              
    Vector2 GetWorldToScreen(Vector3 position, Camera camera);              
    Vector2 GetWorldToScreenEx(Vector3 position, Camera camera,             int width, int height); 
    Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera            ); 
    Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera            ); 
                
    
    void SetTargetFPS(int fps);                                             
    int GetFPS(void);                                                       
    float GetFrameTime(void);                                               
    double GetTime(void);                                                   
                
    
    int ColorToInt(Color color);                                            
    Vector4 ColorNormalize(Color color);                                    
    Color ColorFromNormalized(Vector4 normalized);                          
    Vector3 ColorToHSV(Color color);                                        
    Color ColorFromHSV(Vector3 hsv);                                        
    Color GetColor(int hexValue);                                           
    Color Fade(Color color, float alpha);                                   
                
    
    void SetConfigFlags(unsigned int flags);                                
    void SetTraceLogLevel(int logType);                                     
    void SetTraceLogExit(int logType);                                      
    void SetTraceLogCallback(TraceLogCallback callback);                    
    void TraceLog(int logType, const char *text, ...);                      
    void TakeScreenshot(const char *fileName);                              
    int GetRandomValue(int min, int max);                                   
                
    
    unsigned char *LoadFileData(const char *fileName, int *bytesRead);      
    void SaveFileData(const char *fileName, void *data, int bytesToWrite);  
    bool FileExists(const char *fileName);                                  
    bool IsFileExtension(const char *fileName, const char *ext);            
    bool DirectoryExists(const char *dirPath);                              
    const char *GetExtension(const char *fileName);                         
    const char *GetFileName(const char *filePath);                          
    const char *GetFileNameWithoutExt(const char *filePath);                
    const char *GetDirectoryPath(const char *filePath);                     
    const char *GetPrevDirectoryPath(const char *dirPath);                  
    const char *GetWorkingDirectory(void);                                  
    char **GetDirectoryFiles(const char *dirPath, int *count);              
    void ClearDirectoryFiles(void);                                         
    bool ChangeDirectory(const char *dir);                                  
    bool IsFileDropped(void);                                               
    char **GetDroppedFiles(int *count);                                     
    void ClearDroppedFiles(void);                                           
    long GetFileModTime(const char *fileName);                              
    
    unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength);        
    unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength);  
    
    
    int LoadStorageValue(int position);                                     
    void SaveStorageValue(int position, int value);                         
    
    void OpenURL(const char *url);                                          

    
    
    

    
    bool IsKeyPressed(int key);                                             
    bool IsKeyDown(int key);                                                
    bool IsKeyReleased(int key);                                            
    bool IsKeyUp(int key);                                                  
    int GetKeyPressed(void);                                                
    void SetExitKey(int key);                                               
                
    
    bool IsGamepadAvailable(int gamepad);                                   
    bool IsGamepadName(int gamepad, const char *name);                      
    const char *GetGamepadName(int gamepad);                                
    bool IsGamepadButtonPressed(int gamepad, int button);                   
    bool IsGamepadButtonDown(int gamepad, int button);                      
    bool IsGamepadButtonReleased(int gamepad, int button);                  
    bool IsGamepadButtonUp(int gamepad, int button);                        
    int GetGamepadButtonPressed(void);                                      
    int GetGamepadAxisCount(int gamepad);                                   
    float GetGamepadAxisMovement(int gamepad, int axis);                    
                
    
    bool IsMouseButtonPressed(int button);                                  
    bool IsMouseButtonDown(int button);                                     
    bool IsMouseButtonReleased(int button);                                 
    bool IsMouseButtonUp(int button);                                       
    int GetMouseX(void);                                                    
    int GetMouseY(void);                                                    
    Vector2 GetMousePosition(void);                                         
    void SetMousePosition(int x, int y);                                    
    void SetMouseOffset(int offsetX, int offsetY);                          
    void SetMouseScale(float scaleX, float scaleY);                         
    int GetMouseWheelMove(void);                                            

    
    int GetTouchX(void);                                                    
    int GetTouchY(void);                                                    
    Vector2 GetTouchPosition(int index);                                    

    
    
    
    void SetGesturesEnabled(unsigned int gestureFlags);                     
    bool IsGestureDetected(int gesture);                                    
    int GetGestureDetected(void);                                           
    int GetTouchPointsCount(void);                                          
    float GetGestureHoldDuration(void);                                     
    Vector2 GetGestureDragVector(void);                                     
    float GetGestureDragAngle(void);                                        
    Vector2 GetGesturePinchVector(void);                                    
    float GetGesturePinchAngle(void);                                       

    
    
    
    void SetCameraMode(Camera camera, int mode);                            
    void UpdateCamera(Camera *camera);                                      
            
    void SetCameraPanControl(int panKey);                                   
    void SetCameraAltControl(int altKey);                                   
    void SetCameraSmoothZoomControl(int szKey);                             
    void SetCameraMoveControls(int frontKey, int backKey, 
                               int rightKey, int leftKey, 
                               int upKey, int downKey);                     
]])

--[[
    Module: Shapes
]]
ffi.cdef([[

    void DrawPixel(int posX, int posY, Color color);                                                    
    void DrawPixelV(Vector2 position, Color color);                                                     
    void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                 
    void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                      
    void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                        
    void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                    
    void DrawLineStrip(Vector2 *points, int numPoints, Color color);                                    
    void DrawCircle(int centerX, int centerY, float radius, Color color);                               
    void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);     
    void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color);    
    void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);        
    void DrawCircleV(Vector2 center, float radius, Color color);                                        
    void DrawCircleLines(int centerX, int centerY, float radius, Color color);                          
    void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);              
    void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);         
    void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); 
    void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color);    
    void DrawRectangle(int posX, int posY, int width, int height, Color color);                         
    void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                   
    void DrawRectangleRec(Rectangle rec, Color color);                                                  
    void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                  
    void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); 
    void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2); 
    void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);        
    void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                    
    void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color);                               
    void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);               
    void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); 
    void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                 
    void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                            
    void DrawTriangleFan(Vector2 *points, int numPoints, Color color);                                  
    void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color);                              
    void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);                
    void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);           

    
    bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                            
    bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);         
    bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                          
    Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                          
    bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                          
    bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                        
    bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);                
]])

--[[
    Module: textures
]]
ffi.cdef([[
    Image LoadImage(const char *fileName);                                                              
    Image LoadImageEx(Color *pixels, int width, int height);                                            
    Image LoadImagePro(void *data, int width, int height, int format);                                  
    Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);        
    void ExportImage(Image image, const char *fileName);                                                
    void ExportImageAsCode(Image image, const char *fileName);                                          
    Texture2D LoadTexture(const char *fileName);                                                        
    Texture2D LoadTextureFromImage(Image image);                                                        
    TextureCubemap LoadTextureCubemap(Image image, int layoutType);                                     
    RenderTexture2D LoadRenderTexture(int width, int height);                                           
    void UnloadImage(Image image);                                                                      
    void UnloadTexture(Texture2D texture);                                                              
    void UnloadRenderTexture(RenderTexture2D target);                                                   
    Color *GetImageData(Image image);                                                                   
    Vector4 *GetImageDataNormalized(Image image);                                                       
    Rectangle GetImageAlphaBorder(Image image, float threshold);                                        
    int GetPixelDataSize(int width, int height, int format);                                            
    Image GetTextureData(Texture2D texture);                                                            
    Image GetScreenData(void);                                                                          
    void UpdateTexture(Texture2D texture, const void *pixels);                                          
                                                                                                        
    
    Image ImageCopy(Image image);                                                                       
    Image ImageFromImage(Image image, Rectangle rec);                                                   
    void ImageToPOT(Image *image, Color fillColor);                                                     
    void ImageFormat(Image *image, int newFormat);                                                      
    void ImageAlphaMask(Image *image, Image alphaMask);                                                 
    void ImageAlphaClear(Image *image, Color color, float threshold);                                   
    void ImageAlphaCrop(Image *image, float threshold);                                                 
    void ImageAlphaPremultiply(Image *image);                                                           
    void ImageCrop(Image *image, Rectangle crop);                                                       
    void ImageResize(Image *image, int newWidth, int newHeight);                                        
    void ImageResizeNN(Image *image, int newWidth,int newHeight);                                       
    void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color);  
    void ImageMipmaps(Image *image);                                                                    
    void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                             
    Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount);                     
    Image ImageText(const char *text, int fontSize, Color color);                                       
    Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);          
    void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint);              
    void ImageDrawRectangle(Image *dst, Rectangle rec, Color color);                                    
    void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                    
    void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color);      
    void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, float fontSize, float spacing, Color color); 
    void ImageFlipVertical(Image *image);                                                               
    void ImageFlipHorizontal(Image *image);                                                             
    void ImageRotateCW(Image *image);                                                                   
    void ImageRotateCCW(Image *image);                                                                  
    void ImageColorTint(Image *image, Color color);                                                     
    void ImageColorInvert(Image *image);                                                                
    void ImageColorGrayscale(Image *image);                                                             
    void ImageColorContrast(Image *image, float contrast);                                              
    void ImageColorBrightness(Image *image, int brightness);                                            
    void ImageColorReplace(Image *image, Color color, Color replace);                                   
                                                                                                        
    
    Image GenImageColor(int width, int height, Color color);                                            
    Image GenImageGradientV(int width, int height, Color top, Color bottom);                            
    Image GenImageGradientH(int width, int height, Color left, Color right);                            
    Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);       
    Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);     
    Image GenImageWhiteNoise(int width, int height, float factor);                                      
    Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);            
    Image GenImageCellular(int width, int height, int tileSize);                                        
                                                                                                        
    
    void GenTextureMipmaps(Texture2D *texture);                                                         
    void SetTextureFilter(Texture2D texture, int filterMode);                                           
    void SetTextureWrap(Texture2D texture, int wrapMode);                                               

    
    void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                                
    void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                 
    void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);   
    void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint);          
    void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint);  
    void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint);       
    void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint);   
]])

--[[
    module: text
]]
ffi.cdef([[
 
    Font GetFontDefault(void);                                                                        
    Font LoadFont(const char *fileName);                                                              
    Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount);              
    Font LoadFontFromImage(Image image, Color key, int firstChar);                                    
    CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type); 
    Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod);  
    void UnloadFont(Font font);                                                                       
    
    
    void DrawFPS(int posX, int posY);                                                                 
    void DrawText(const char *text, int posX, int posY, int fontSize, Color color);                   
    void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint);                
    void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint);   
    void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint,
                    int selectStart, int selectLength, Color selectTint, Color selectBackTint);       
    void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint);      
    
    
    int MeasureText(const char *text, int fontSize);                                                  
    Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);                
    int GetGlyphIndex(Font font, int codepoint);                                                      
    
    
    
    int TextCopy(char *dst, const char *src);                                                         
    bool TextIsEqual(const char *text1, const char *text2);                                           
    unsigned int TextLength(const char *text);                                                        
    const char *TextFormat(const char *text, ...);                                                    
    const char *TextSubtext(const char *text, int position, int length);                              
    char *TextReplace(char *text, const char *replace, const char *by);                               
    char *TextInsert(const char *text, const char *insert, int position);                             
    const char *TextJoin(const char **textList, int count, const char *delimiter);                    
    const char **TextSplit(const char *text, char delimiter, int *count);                             
    void TextAppend(char *text, const char *append, int *position);                                   
    int TextFindIndex(const char *text, const char *find);                                            
    const char *TextToUpper(const char *text);                                                        
    const char *TextToLower(const char *text);                                                        
    const char *TextToPascal(const char *text);                                                       
    int TextToInteger(const char *text);                                                              
    char *TextToUtf8(int *codepoints, int length);                                                    
                                                                                                      
    
    int *GetCodepoints(const char *text, int *count);                                                 
    int GetCodepointsCount(const char *text);                                                         
    int GetNextCodepoint(const char *text, int *bytesProcessed);                                      
    const char *CodepointToUtf8(int codepoint, int *byteLength);                                      
]])

--[[
    module: models
]]
ffi.cdef([[
     
    void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    
    void DrawPoint3D(Vector3 position, Color color);                                                   
    void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); 
    void DrawCube(Vector3 position, float width, float height, float length, Color color);             
    void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       
    void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        
    void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  
    void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); 
    void DrawSphere(Vector3 centerPos, float radius, Color color);                                     
    void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            
    void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         
    void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); 
    void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); 
    void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      
    void DrawRay(Ray ray, Color color);                                                                
    void DrawGrid(int slices, float spacing);                                                          
    void DrawGizmo(Vector3 position);                                                                  
    
    
    Model LoadModel(const char *fileName);                                                             
    Model LoadModelFromMesh(Mesh mesh);                                                                
    void UnloadModel(Model model);                                                                     
    
    
    Mesh *LoadMeshes(const char *fileName, int *meshCount);                                            
    void ExportMesh(Mesh mesh, const char *fileName);                                                  
    void UnloadMesh(Mesh mesh);                                                                        
    
    
    Material *LoadMaterials(const char *fileName, int *materialCount);                                 
    Material LoadMaterialDefault(void);                                                                
    void UnloadMaterial(Material material);                                                            
    void SetMaterialTexture(Material *material, int mapType, Texture2D texture);                       
    void SetModelMeshMaterial(Model *model, int meshId, int materialId);                               
    
    
    ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount);                        
    void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);                            
    void UnloadModelAnimation(ModelAnimation anim);                                                    
    bool IsModelAnimationValid(Model model, ModelAnimation anim);                                      
    
    
    Mesh GenMeshPoly(int sides, float radius);                                                         
    Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                  
    Mesh GenMeshCube(float width, float height, float length);                                         
    Mesh GenMeshSphere(float radius, int rings, int slices);                                           
    Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                       
    Mesh GenMeshCylinder(float radius, float height, int slices);                                      
    Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                                
    Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                 
    Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                              
    Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                            
    
    
    BoundingBox MeshBoundingBox(Mesh mesh);                                                            
    void MeshTangents(Mesh *mesh);                                                                     
    void MeshBinormals(Mesh *mesh);                                                                    
    
    
    void DrawModel(Model model, Vector3 position, float scale, Color tint);                            
    void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); 
    void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                       
    void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); 
    void DrawBoundingBox(BoundingBox box, Color color);                                                
    void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint);      
    void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); 
    
    
    bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);        
    bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                      
    bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                       
    bool CheckCollisionRaySphere(Ray ray, Vector3 center, float radius);                               
    bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint);    
    bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                               
    RayHitInfo GetCollisionRayModel(Ray ray, Model model);                                             
    RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                   
    RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                     
]])

--[[
    module: shaders
]]
ffi.cdef([[
     
    void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    
    void DrawPoint3D(Vector3 position, Color color);                                                   
    void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); 
    void DrawCube(Vector3 position, float width, float height, float length, Color color);             
    void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       
    void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        
    void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  
    void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); 
    void DrawSphere(Vector3 centerPos, float radius, Color color);                                     
    void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            
    void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         
    void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); 
    void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); 
    void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      
    void DrawRay(Ray ray, Color color);                                                                
    void DrawGrid(int slices, float spacing);                                                          
    void DrawGizmo(Vector3 position);                                                                  
    
    
    Model LoadModel(const char *fileName);                                                             
    Model LoadModelFromMesh(Mesh mesh);                                                                
    void UnloadModel(Model model);                                                                     
    
    
    Mesh *LoadMeshes(const char *fileName, int *meshCount);                                            
    void ExportMesh(Mesh mesh, const char *fileName);                                                  
    void UnloadMesh(Mesh mesh);                                                                        
    
    
    Material *LoadMaterials(const char *fileName, int *materialCount);                                 
    Material LoadMaterialDefault(void);                                                                
    void UnloadMaterial(Material material);                                                            
    void SetMaterialTexture(Material *material, int mapType, Texture2D texture);                       
    void SetModelMeshMaterial(Model *model, int meshId, int materialId);                               
    
    
    ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount);                        
    void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);                            
    void UnloadModelAnimation(ModelAnimation anim);                                                    
    bool IsModelAnimationValid(Model model, ModelAnimation anim);                                      
    
    
    Mesh GenMeshPoly(int sides, float radius);                                                         
    Mesh GenMeshPlane(float width, float length, int resX, int resZ);                                  
    Mesh GenMeshCube(float width, float height, float length);                                         
    Mesh GenMeshSphere(float radius, int rings, int slices);                                           
    Mesh GenMeshHemiSphere(float radius, int rings, int slices);                                       
    Mesh GenMeshCylinder(float radius, float height, int slices);                                      
    Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                                
    Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                                 
    Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                              
    Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                                            
    
    
    BoundingBox MeshBoundingBox(Mesh mesh);                                                            
    void MeshTangents(Mesh *mesh);                                                                     
    void MeshBinormals(Mesh *mesh);                                                                    
    
    
    void DrawModel(Model model, Vector3 position, float scale, Color tint);                            
    void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); 
    void DrawModelWires(Model model, Vector3 position, float scale, Color tint);                       
    void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); 
    void DrawBoundingBox(BoundingBox box, Color color);                                                
    void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint);      
    void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); 
    
    
    bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB);        
    bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                      
    bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                       
    bool CheckCollisionRaySphere(Ray ray, Vector3 center, float radius);                               
    bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint);    
    bool CheckCollisionRayBox(Ray ray, BoundingBox box);                                               
    RayHitInfo GetCollisionRayModel(Ray ray, Model model);                                             
    RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);                   
    RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight);                                     
]])

--[[
    module: audio
]]
ffi.cdef([[
  
    void InitAudioDevice(void);                                                     
    void CloseAudioDevice(void);                                                    
    bool IsAudioDeviceReady(void);                                                  
    void SetMasterVolume(float volume);                                             

    
    Wave LoadWave(const char *fileName);                                            
    Wave LoadWaveEx(void *data, int sampleCount, int sampleRate, int sampleSize, int channels); 
    Sound LoadSound(const char *fileName);                                          
    Sound LoadSoundFromWave(Wave wave);                                             
    void UpdateSound(Sound sound, const void *data, int samplesCount);              
    void UnloadWave(Wave wave);                                                     
    void UnloadSound(Sound sound);                                                  
    void ExportWave(Wave wave, const char *fileName);                               
    void ExportWaveAsCode(Wave wave, const char *fileName);                         

    
    void PlaySound(Sound sound);                                                    
    void StopSound(Sound sound);                                                    
    void PauseSound(Sound sound);                                                   
    void ResumeSound(Sound sound);                                                  
    void PlaySoundMulti(Sound sound);                                               
    void StopSoundMulti(void);                                                      
    int GetSoundsPlaying(void);                                                     
    bool IsSoundPlaying(Sound sound);                                               
    void SetSoundVolume(Sound sound, float volume);                                 
    void SetSoundPitch(Sound sound, float pitch);                                   
    void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels);      
    Wave WaveCopy(Wave wave);                                                       
    void WaveCrop(Wave *wave, int initSample, int finalSample);                     
    float *GetWaveData(Wave wave);                                                  

    
    Music LoadMusicStream(const char *fileName);                                    
    void UnloadMusicStream(Music music);                                            
    void PlayMusicStream(Music music);                                              
    void UpdateMusicStream(Music music);                                            
    void StopMusicStream(Music music);                                              
    void PauseMusicStream(Music music);                                             
    void ResumeMusicStream(Music music);                                            
    bool IsMusicPlaying(Music music);                                               
    void SetMusicVolume(Music music, float volume);                                 
    void SetMusicPitch(Music music, float pitch);                                   
    void SetMusicLoopCount(Music music, int count);                                 
    float GetMusicTimeLength(Music music);                                          
    float GetMusicTimePlayed(Music music);                                          

    
    AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); 
    void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); 
    void CloseAudioStream(AudioStream stream);                                      
    bool IsAudioBufferProcessed(AudioStream stream);                                
    void PlayAudioStream(AudioStream stream);                                       
    void PauseAudioStream(AudioStream stream);                                      
    void ResumeAudioStream(AudioStream stream);                                     
    bool IsAudioStreamPlaying(AudioStream stream);                                  
    void StopAudioStream(AudioStream stream);                                       
    void SetAudioStreamVolume(AudioStream stream, float volume);                    
    void SetAudioStreamPitch(AudioStream stream, float pitch);                         
]])


PI = ffi.new("double", 3.14159265358979323846)
DEG2RAD = ffi.new("float", PI/180.0)
RAD2DEG = ffi.new("float", 180.0/PI)

--[[
    Module: raymath
]]
ffi.cdef([[
    typedef struct float3 { float v[3]; } float3;
    typedef struct float16 { float v[16]; } float16;

    extern float Clamp(float value, float min, float max);
    extern float Lerp(float start, float end, float amount);
    
    extern Vector2 Vector2Zero(void);
    extern Vector2 Vector2One(void);
    extern Vector2 Vector2Add(Vector2 v1, Vector2 v2);
    extern Vector2 Vector2Subtract(Vector2 v1, Vector2 v2);
    extern float Vector2Length(Vector2 v);
    extern float Vector2DotProduct(Vector2 v1, Vector2 v2);
    extern float Vector2Distance(Vector2 v1, Vector2 v2);
    extern float Vector2Angle(Vector2 v1, Vector2 v2);
    extern Vector2 Vector2Scale(Vector2 v, float scale);
    extern Vector2 Vector2MultiplyV(Vector2 v1, Vector2 v2);
    extern Vector2 Vector2Negate(Vector2 v);
    extern Vector2 Vector2Divide(Vector2 v, float div);
    extern Vector2 Vector2DivideV(Vector2 v1, Vector2 v2);
    extern Vector2 Vector2Normalize(Vector2 v);
    extern Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount);
    
    extern Vector3 Vector3Zero(void);
    extern Vector3 Vector3One(void);
    extern Vector3 Vector3Add(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Subtract(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Scale(Vector3 v, float scalar);
    extern Vector3 Vector3Multiply(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Perpendicular(Vector3 v);
    extern float Vector3Length(const Vector3 v);
    extern float Vector3DotProduct(Vector3 v1, Vector3 v2);
    extern float Vector3Distance(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Negate(Vector3 v);
    extern Vector3 Vector3Divide(Vector3 v, float div);
    extern Vector3 Vector3DivideV(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Normalize(Vector3 v);
    extern void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2);
    extern Vector3 Vector3Transform(Vector3 v, Matrix mat);
    extern Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q);
    extern Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount);
    extern Vector3 Vector3Reflect(Vector3 v, Vector3 normal);
    extern Vector3 Vector3Min(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Max(Vector3 v1, Vector3 v2);
    extern Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c);
    extern float3 Vector3ToFloatV(Vector3 v);
    
    
    extern float MatrixDeterminant(Matrix mat);
    extern float MatrixTrace(Matrix mat);
    extern Matrix MatrixTranspose(Matrix mat);
    extern Matrix MatrixInvert(Matrix mat);
    extern Matrix MatrixNormalize(Matrix mat);
    extern Matrix MatrixIdentity(void);
    extern Matrix MatrixAdd(Matrix left, Matrix right);
    extern Matrix MatrixSubtract(Matrix left, Matrix right);
    extern Matrix MatrixTranslate(float x, float y, float z);
    extern Matrix MatrixRotate(Vector3 axis, float angle);
    extern Matrix MatrixRotateXYZ(Vector3 ang);
    extern Matrix MatrixRotateX(float angle);
    extern Matrix MatrixRotateY(float angle);
    extern Matrix MatrixRotateZ(float angle);
    extern Matrix MatrixScale(float x, float y, float z);
    extern Matrix MatrixMultiply(Matrix left, Matrix right);
    extern Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far);
    extern Matrix MatrixPerspective(double fovy, double aspect, double near, double far);
    extern Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far);
    extern Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up);
    extern float16 MatrixToFloatV(Matrix mat);
    
    
    extern Quaternion QuaternionIdentity(void);
    extern float QuaternionLength(Quaternion q);
    extern Quaternion QuaternionNormalize(Quaternion q);
    extern Quaternion QuaternionInvert(Quaternion q);
    extern Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2);
    extern Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount);
    extern Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount);
    extern Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount);
    extern Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to);
    extern Quaternion QuaternionFromMatrix(Matrix mat);
    extern Matrix QuaternionToMatrix(Quaternion q);
    extern Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle);
    extern void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle);
    extern Quaternion QuaternionFromEuler(float roll, float pitch, float yaw);
    extern Vector3 QuaternionToEuler(Quaternion q);
    extern Quaternion QuaternionTransform(Quaternion q, Matrix mat);
]])
return raylib