local ffi = require "ffi"
local raylib = {}
local raylib_so = ffi.load("raylib")

-- ffi cdef, based on raylib.h
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 SpriteFont Font;
  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
  } ShaderLocationIndex;

  #define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
  #define LOC_MAP_SPECULAR LOC_MAP_METALNESS

  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
  } MaterialMapType;

  #define MAP_DIFFUSE MAP_ALBEDO
  #define MAP_SPECULAR MAP_METALNESS

  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);

  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);
  void StorageSaveValue(int position, int value);
  int StorageLoadValue(int position);

  void OpenURL(const char *url);
  bool IsKeyPressed(int key);
  bool IsKeyDown(int key);
  bool IsKeyReleased(int key);
  bool IsKeyUp(int key);
  void SetExitKey(int key);
  int GetKeyPressed(void);
  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);
  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);
  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);
  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);
  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);
  char *LoadText(const char *fileName);
  Shader LoadShader(const char *vsFileName, const char *fsFileName);
  Shader LoadShaderCode(const char *vsCode, const char *fsCode);
  void UnloadShader(Shader shader);
  Shader GetShaderDefault(void);
  Texture2D GetTextureDefault(void);
  Texture2D GetShapesTexture(void);
  Rectangle GetShapesTextureRec(void);
  void SetShapesTexture(Texture2D texture, Rectangle source);
  int GetShaderLocation(Shader shader, const char *uniformName);
  void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType);
  void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count);
  void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat);
  void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture);
  void SetMatrixProjection(Matrix proj);
  void SetMatrixModelview(Matrix view);
  Matrix GetMatrixModelview(void);
  Matrix GetMatrixProjection(void);
  Texture2D GenTextureCubemap(Shader shader, Texture2D map, int size);
  Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size);
  Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size);
  Texture2D GenTextureBRDF(Shader shader, int size);
  void BeginShaderMode(Shader shader);
  void EndShaderMode(void);
  void BeginBlendMode(int mode);
  void EndBlendMode(void);
  void InitVrSimulator(void);
  void CloseVrSimulator(void);
  void UpdateVrTracking(Camera *camera);
  void SetVrConfiguration(VrDeviceInfo info, Shader distortion);
  bool IsVrSimulatorReady(void);
  void ToggleVrMode(void);
  void BeginVrDrawing(void);
  void EndVrDrawing(void);
  void InitAudioDevice(void);
  void CloseAudioDevice(void);
  bool IsAudioDeviceReady(void);
  void SetMasterVolume(float volume);
  Wave LoadWave(const char *fileName);
  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 IsAudioStreamProcessed(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);
  void SetAudioStreamBufferSizeDefault(int size);
]]

-- colors
local function new_color(r, g, b, a)
  local c = ffi.new("Color")
  c.r = r
  c.g = g
  c.b = b
  c.a = a
  return c
end

raylib.LIGHTGRAY = new_color(200, 200, 200, 255)
raylib.GRAY = new_color(130, 130, 130, 255)
raylib.DARKGRAY = new_color(80, 80, 80, 255)
raylib.YELLOW = new_color(253, 249, 0, 255)
raylib.GOLD = new_color(255, 203, 0, 255)
raylib.ORANGE = new_color(255, 161, 0, 255)
raylib.PINK = new_color(255, 109, 194, 255)
raylib.RED = new_color(230, 41, 55, 255)
raylib.MAROON = new_color(190, 33, 55, 255)
raylib.GREEN = new_color(0, 228, 48, 255)
raylib.LIME = new_color(0, 158, 47, 255)
raylib.DARKGREEN = new_color(0, 117, 44, 255)
raylib.SKYBLUE = new_color(102, 191, 255, 255)
raylib.BLUE = new_color(0, 121, 241, 255)
raylib.DARKBLUE = new_color(0, 82, 172, 255)
raylib.PURPLE = new_color(200, 122, 255, 255)
raylib.VIOLET = new_color(135, 60, 190, 255)
raylib.DARKPURPLE = new_color(112, 31, 126, 255)
raylib.BEIGE = new_color(211, 176, 131, 255)
raylib.BROWN = new_color(127, 106, 79, 255)
raylib.DARKBROWN = new_color(76, 63, 47, 255)
raylib.WHITE = new_color(255, 255, 255, 255)
raylib.BLACK = new_color(0, 0, 0, 255)
raylib.BLANK = new_color(0, 0, 0, 0)
raylib.MAGENTA = new_color(255, 0, 255, 255)
raylib.RAYWHITE = new_color(245, 245, 245, 255)

raylib.__index = function (self, key)
  return raylib_so[key]
end

raylib.__newindex = function ()
  error "raylib table is readonly"
end

rl = setmetatable(raylib, raylib)
raylib = rl