Fierelier
/
raylib-lua-legacy
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Update raylib binding. Improve ffi autogen.

This commit is contained in:
TSnake41 2020-04-30 22:20:48 +02:00
parent 7d1640c514
commit 650dd8ccdc
9 changed files with 622 additions and 612 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
.gitmodules vendored
View File

@ -4,7 +4,7 @@ url = https://github.com/moonjit/moonjit
[submodule "raylib"] [submodule "raylib"]
path = raylib path = raylib
url = https://github.com/raysan5/raylib url = https://github.com/TSnake41/raylib
[submodule "ragui"] [submodule "ragui"]
path = raygui path = raygui

2
raygui

@ -1 +1 @@
Subproject commit b2974f3d289631f4c1545d7fd2360a71f72697a5 Subproject commit feb1a6c874d533e639f3f0a02b0d96d995ea4648

2
raylib

@ -1 +1 @@
Subproject commit 91e36777625b6d808e31fc2eb46a5519054bd801 Subproject commit 26003f3cb736b89ad7b7e013d4bef48ea16efbb1

880
tools/api.h
View File

@ -1,439 +1,441 @@
void InitWindow(int width, int height, const char *title); void InitWindow(int width, int height, const char *title)
bool WindowShouldClose(void); bool WindowShouldClose(void)
void CloseWindow(void); void CloseWindow(void)
bool IsWindowReady(void); bool IsWindowReady(void)
bool IsWindowMinimized(void); bool IsWindowMinimized(void)
bool IsWindowResized(void); bool IsWindowFocused(void)
bool IsWindowHidden(void); bool IsWindowResized(void)
bool IsWindowFullscreen(void); bool IsWindowHidden(void)
void ToggleFullscreen(void); bool IsWindowFullscreen(void)
void UnhideWindow(void); void ToggleFullscreen(void)
void HideWindow(void); void UnhideWindow(void)
void SetWindowIcon(Image image); void HideWindow(void)
void SetWindowTitle(const char *title); void SetWindowIcon(Image image)
void SetWindowPosition(int x, int y); void SetWindowTitle(const char *title)
void SetWindowMonitor(int monitor); void SetWindowPosition(int x, int y)
void SetWindowMinSize(int width, int height); void SetWindowMonitor(int monitor)
void SetWindowSize(int width, int height); void SetWindowMinSize(int width, int height)
void *GetWindowHandle(void); void SetWindowSize(int width, int height)
int GetScreenWidth(void); void *GetWindowHandle(void)
int GetScreenHeight(void); int GetScreenWidth(void)
int GetMonitorCount(void); int GetScreenHeight(void)
int GetMonitorWidth(int monitor); int GetMonitorCount(void)
int GetMonitorHeight(int monitor); int GetMonitorWidth(int monitor)
int GetMonitorPhysicalWidth(int monitor); int GetMonitorHeight(int monitor)
int GetMonitorPhysicalHeight(int monitor); int GetMonitorPhysicalWidth(int monitor)
Vector2 GetWindowPosition(void); int GetMonitorPhysicalHeight(int monitor)
const char *GetMonitorName(int monitor); Vector2 GetWindowPosition(void)
const char *GetClipboardText(void); Vector2 GetWindowScaleDPI(void)
void SetClipboardText(const char *text); const char *GetMonitorName(int monitor)
void ShowCursor(void); const char *GetClipboardText(void)
void HideCursor(void); void SetClipboardText(const char *text)
bool IsCursorHidden(void); void ShowCursor(void)
void EnableCursor(void); void HideCursor(void)
void DisableCursor(void); bool IsCursorHidden(void)
void ClearBackground(Color color); void EnableCursor(void)
void BeginDrawing(void); void DisableCursor(void)
void EndDrawing(void); void ClearBackground(Color color)
void BeginMode2D(Camera2D camera); void BeginDrawing(void)
void EndMode2D(void); void EndDrawing(void)
void BeginMode3D(Camera3D camera); void BeginMode2D(Camera2D camera)
void EndMode3D(void); void EndMode2D(void)
void BeginTextureMode(RenderTexture2D target); void BeginMode3D(Camera3D camera)
void EndTextureMode(void); void EndMode3D(void)
void BeginScissorMode(int x, int y, int width, int height); void BeginTextureMode(RenderTexture2D target)
void EndScissorMode(void); void EndTextureMode(void)
Ray GetMouseRay(Vector2 mousePosition, Camera camera); void BeginScissorMode(int x, int y, int width, int height)
Matrix GetCameraMatrix(Camera camera); void EndScissorMode(void)
Matrix GetCameraMatrix2D(Camera2D camera); Ray GetMouseRay(Vector2 mousePosition, Camera camera)
Vector2 GetWorldToScreen(Vector3 position, Camera camera); Matrix GetCameraMatrix(Camera camera)
Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); Matrix GetCameraMatrix2D(Camera2D camera)
Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); Vector2 GetWorldToScreen(Vector3 position, Camera camera)
Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height)
void SetTargetFPS(int fps); Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera)
int GetFPS(void); Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera)
float GetFrameTime(void); void SetTargetFPS(int fps)
double GetTime(void); int GetFPS(void)
int ColorToInt(Color color); float GetFrameTime(void)
Vector4 ColorNormalize(Color color); double GetTime(void)
Color ColorFromNormalized(Vector4 normalized); int ColorToInt(Color color)
Vector3 ColorToHSV(Color color); Vector4 ColorNormalize(Color color)
Color ColorFromHSV(Vector3 hsv); Color ColorFromNormalized(Vector4 normalized)
Color GetColor(int hexValue); Vector3 ColorToHSV(Color color)
Color Fade(Color color, float alpha); Color ColorFromHSV(Vector3 hsv)
void SetConfigFlags(unsigned int flags); Color GetColor(int hexValue)
void SetTraceLogLevel(int logType); Color Fade(Color color, float alpha)
void SetTraceLogExit(int logType); void SetConfigFlags(unsigned int flags)
void SetTraceLogCallback(TraceLogCallback callback); void SetTraceLogLevel(int logType)
void TraceLog(int logType, const char *text, ...); void SetTraceLogExit(int logType)
void TakeScreenshot(const char *fileName); void SetTraceLogCallback(TraceLogCallback callback)
int GetRandomValue(int min, int max); void TraceLog(int logType, const char *text, ...)
unsigned char *LoadFileData(const char *fileName, int *bytesRead); void TakeScreenshot(const char *fileName)
void SaveFileData(const char *fileName, void *data, int bytesToWrite); int GetRandomValue(int min, int max)
char *LoadFileText(const char *fileName); unsigned char *LoadFileData(const char *fileName, int *bytesRead)
void SaveFileText(const char *fileName, char *text); void SaveFileData(const char *fileName, void *data, int bytesToWrite)
bool FileExists(const char *fileName); char *LoadFileText(const char *fileName)
bool IsFileExtension(const char *fileName, const char *ext); void SaveFileText(const char *fileName, char *text)
bool DirectoryExists(const char *dirPath); bool FileExists(const char *fileName)
const char *GetExtension(const char *fileName); bool IsFileExtension(const char *fileName, const char *ext)
const char *GetFileName(const char *filePath); bool DirectoryExists(const char *dirPath)
const char *GetFileNameWithoutExt(const char *filePath); const char *GetExtension(const char *fileName)
const char *GetDirectoryPath(const char *filePath); const char *GetFileName(const char *filePath)
const char *GetPrevDirectoryPath(const char *dirPath); const char *GetFileNameWithoutExt(const char *filePath)
const char *GetWorkingDirectory(void); const char *GetDirectoryPath(const char *filePath)
char **GetDirectoryFiles(const char *dirPath, int *count); const char *GetPrevDirectoryPath(const char *dirPath)
void ClearDirectoryFiles(void); const char *GetWorkingDirectory(void)
bool ChangeDirectory(const char *dir); char **GetDirectoryFiles(const char *dirPath, int *count)
bool IsFileDropped(void); void ClearDirectoryFiles(void)
char **GetDroppedFiles(int *count); bool ChangeDirectory(const char *dir)
void ClearDroppedFiles(void); bool IsFileDropped(void)
long GetFileModTime(const char *fileName); char **GetDroppedFiles(int *count)
unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength); void ClearDroppedFiles(void)
unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength); long GetFileModTime(const char *fileName)
void SaveStorageValue(int position, int value); unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength)
int LoadStorageValue(int position); unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength)
void OpenURL(const char *url); void SaveStorageValue(int position, int value)
bool IsKeyPressed(int key); int LoadStorageValue(int position)
bool IsKeyDown(int key); void OpenURL(const char *url)
bool IsKeyReleased(int key); bool IsKeyPressed(int key)
bool IsKeyUp(int key); bool IsKeyDown(int key)
void SetExitKey(int key); bool IsKeyReleased(int key)
int GetKeyPressed(void); bool IsKeyUp(int key)
bool IsGamepadAvailable(int gamepad); void SetExitKey(int key)
bool IsGamepadName(int gamepad, const char *name); int GetKeyPressed(void)
const char *GetGamepadName(int gamepad); bool IsGamepadAvailable(int gamepad)
bool IsGamepadButtonPressed(int gamepad, int button); bool IsGamepadName(int gamepad, const char *name)
bool IsGamepadButtonDown(int gamepad, int button); const char *GetGamepadName(int gamepad)
bool IsGamepadButtonReleased(int gamepad, int button); bool IsGamepadButtonPressed(int gamepad, int button)
bool IsGamepadButtonUp(int gamepad, int button); bool IsGamepadButtonDown(int gamepad, int button)
int GetGamepadButtonPressed(void); bool IsGamepadButtonReleased(int gamepad, int button)
int GetGamepadAxisCount(int gamepad); bool IsGamepadButtonUp(int gamepad, int button)
float GetGamepadAxisMovement(int gamepad, int axis); int GetGamepadButtonPressed(void)
bool IsMouseButtonPressed(int button); int GetGamepadAxisCount(int gamepad)
bool IsMouseButtonDown(int button); float GetGamepadAxisMovement(int gamepad, int axis)
bool IsMouseButtonReleased(int button); bool IsMouseButtonPressed(int button)
bool IsMouseButtonUp(int button); bool IsMouseButtonDown(int button)
int GetMouseX(void); bool IsMouseButtonReleased(int button)
int GetMouseY(void); bool IsMouseButtonUp(int button)
Vector2 GetMousePosition(void); int GetMouseX(void)
void SetMousePosition(int x, int y); int GetMouseY(void)
void SetMouseOffset(int offsetX, int offsetY); Vector2 GetMousePosition(void)
void SetMouseScale(float scaleX, float scaleY); void SetMousePosition(int x, int y)
int GetMouseWheelMove(void); void SetMouseOffset(int offsetX, int offsetY)
int GetTouchX(void); void SetMouseScale(float scaleX, float scaleY)
int GetTouchY(void); int GetMouseWheelMove(void)
Vector2 GetTouchPosition(int index); int GetTouchX(void)
void SetGesturesEnabled(unsigned int gestureFlags); int GetTouchY(void)
bool IsGestureDetected(int gesture); Vector2 GetTouchPosition(int index)
int GetGestureDetected(void); void SetGesturesEnabled(unsigned int gestureFlags)
int GetTouchPointsCount(void); bool IsGestureDetected(int gesture)
float GetGestureHoldDuration(void); int GetGestureDetected(void)
Vector2 GetGestureDragVector(void); int GetTouchPointsCount(void)
float GetGestureDragAngle(void); float GetGestureHoldDuration(void)
Vector2 GetGesturePinchVector(void); Vector2 GetGestureDragVector(void)
float GetGesturePinchAngle(void); float GetGestureDragAngle(void)
void SetCameraMode(Camera camera, int mode); Vector2 GetGesturePinchVector(void)
void UpdateCamera(Camera *camera); float GetGesturePinchAngle(void)
void SetCameraPanControl(int panKey); void SetCameraMode(Camera camera, int mode)
void SetCameraAltControl(int altKey); void UpdateCamera(Camera *camera)
void SetCameraSmoothZoomControl(int szKey); void SetCameraPanControl(int panKey)
void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey); void SetCameraAltControl(int altKey)
void DrawPixel(int posX, int posY, Color color); void SetCameraSmoothZoomControl(int szKey)
void DrawPixelV(Vector2 position, Color color); void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey)
void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); void DrawPixel(int posX, int posY, Color color)
void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); void DrawPixelV(Vector2 position, Color color)
void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color)
void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); void DrawLineV(Vector2 startPos, Vector2 endPos, Color color)
void DrawLineStrip(Vector2 *points, int numPoints, Color color); void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color)
void DrawCircle(int centerX, int centerY, float radius, Color color); void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color)
void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); void DrawLineStrip(Vector2 *points, int numPoints, Color color)
void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); void DrawCircle(int centerX, int centerY, float radius, Color color)
void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color)
void DrawCircleV(Vector2 center, float radius, Color color); void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color)
void DrawCircleLines(int centerX, int centerY, float radius, Color color); void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2)
void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); void DrawCircleV(Vector2 center, float radius, Color color)
void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); void DrawCircleLines(int centerX, int centerY, float radius, Color color)
void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color)
void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color)
void DrawRectangle(int posX, int posY, int width, int height, Color color); void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color)
void DrawRectangleV(Vector2 position, Vector2 size, Color color); void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color)
void DrawRectangleRec(Rectangle rec, Color color); void DrawRectangle(int posX, int posY, int width, int height, Color color)
void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); void DrawRectangleV(Vector2 position, Vector2 size, Color color)
void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2); void DrawRectangleRec(Rectangle rec, Color color)
void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2); void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color)
void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2)
void DrawRectangleLines(int posX, int posY, int width, int height, Color color); void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2)
void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color); void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4)
void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); void DrawRectangleLines(int posX, int posY, int width, int height, Color color)
void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color)
void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color)
void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color)
void DrawTriangleFan(Vector2 *points, int numPoints, Color color); void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color); void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color)
void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); void DrawTriangleFan(Vector2 *points, int numPoints, Color color)
void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color)
bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color)
bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color)
bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2)
Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2)
bool CheckCollisionPointRec(Vector2 point, Rectangle rec); bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec)
bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2)
bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); bool CheckCollisionPointRec(Vector2 point, Rectangle rec)
Image LoadImage(const char *fileName); bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius)
Image LoadImageEx(Color *pixels, int width, int height); bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3)
Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); Image LoadImage(const char *fileName)
void ExportImage(Image image, const char *fileName); Image LoadImageEx(Color *pixels, int width, int height)
void ExportImageAsCode(Image image, const char *fileName); Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize)
Texture2D LoadTexture(const char *fileName); void ExportImage(Image image, const char *fileName)
Texture2D LoadTextureFromImage(Image image); void ExportImageAsCode(Image image, const char *fileName)
TextureCubemap LoadTextureCubemap(Image image, int layoutType); Texture2D LoadTexture(const char *fileName)
RenderTexture2D LoadRenderTexture(int width, int height); Texture2D LoadTextureFromImage(Image image)
void UnloadImage(Image image); TextureCubemap LoadTextureCubemap(Image image, int layoutType)
void UnloadTexture(Texture2D texture); RenderTexture2D LoadRenderTexture(int width, int height)
void UnloadRenderTexture(RenderTexture2D target); void UnloadImage(Image image)
Color *GetImageData(Image image); void UnloadTexture(Texture2D texture)
Vector4 *GetImageDataNormalized(Image image); void UnloadRenderTexture(RenderTexture2D target)
Rectangle GetImageAlphaBorder(Image image, float threshold); Color *GetImageData(Image image)
int GetPixelDataSize(int width, int height, int format); Vector4 *GetImageDataNormalized(Image image)
Image GetTextureData(Texture2D texture); Rectangle GetImageAlphaBorder(Image image, float threshold)
Image GetScreenData(void); int GetPixelDataSize(int width, int height, int format)
void UpdateTexture(Texture2D texture, const void *pixels); Image GetTextureData(Texture2D texture)
Image ImageCopy(Image image); Image GetScreenData(void)
Image ImageFromImage(Image image, Rectangle rec); void UpdateTexture(Texture2D texture, const void *pixels)
void ImageToPOT(Image *image, Color fillColor); Image ImageCopy(Image image)
void ImageFormat(Image *image, int newFormat); Image ImageFromImage(Image image, Rectangle rec)
void ImageAlphaMask(Image *image, Image alphaMask); void ImageToPOT(Image *image, Color fillColor)
void ImageAlphaClear(Image *image, Color color, float threshold); void ImageFormat(Image *image, int newFormat)
void ImageAlphaCrop(Image *image, float threshold); void ImageAlphaMask(Image *image, Image alphaMask)
void ImageAlphaPremultiply(Image *image); void ImageAlphaClear(Image *image, Color color, float threshold)
void ImageCrop(Image *image, Rectangle crop); void ImageAlphaCrop(Image *image, float threshold)
void ImageResize(Image *image, int newWidth, int newHeight); void ImageAlphaPremultiply(Image *image)
void ImageResizeNN(Image *image, int newWidth,int newHeight); void ImageCrop(Image *image, Rectangle crop)
void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color); void ImageResize(Image *image, int newWidth, int newHeight)
void ImageMipmaps(Image *image); void ImageResizeNN(Image *image, int newWidth,int newHeight)
void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color)
Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount); void ImageMipmaps(Image *image)
Image ImageText(const char *text, int fontSize, Color color); void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp)
Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount)
void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); Image ImageText(const char *text, int fontSize, Color color)
void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint)
void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint)
void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color)
void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color)
void ImageClearBackground(Image *dst, Color color); void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color)
void ImageDrawPixel(Image *dst, int posX, int posY, Color color); void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color)
void ImageDrawPixelV(Image *dst, Vector2 position, Color color); void ImageClearBackground(Image *dst, Color color)
void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); void ImageDrawPixel(Image *dst, int posX, int posY, Color color)
void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); void ImageDrawPixelV(Image *dst, Vector2 position, Color color)
void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color)
void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color)
void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color); void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color)
void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color)
void ImageFlipVertical(Image *image); void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color)
void ImageFlipHorizontal(Image *image); void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint)
void ImageRotateCW(Image *image); void ImageFlipVertical(Image *image)
void ImageRotateCCW(Image *image); void ImageFlipHorizontal(Image *image)
void ImageColorTint(Image *image, Color color); void ImageRotateCW(Image *image)
void ImageColorInvert(Image *image); void ImageRotateCCW(Image *image)
void ImageColorGrayscale(Image *image); void ImageColorTint(Image *image, Color color)
void ImageColorContrast(Image *image, float contrast); void ImageColorInvert(Image *image)
void ImageColorBrightness(Image *image, int brightness); void ImageColorGrayscale(Image *image)
void ImageColorReplace(Image *image, Color color, Color replace); void ImageColorContrast(Image *image, float contrast)
Image GenImageColor(int width, int height, Color color); void ImageColorBrightness(Image *image, int brightness)
Image GenImageGradientV(int width, int height, Color top, Color bottom); void ImageColorReplace(Image *image, Color color, Color replace)
Image GenImageGradientH(int width, int height, Color left, Color right); Image GenImageColor(int width, int height, Color color)
Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); Image GenImageGradientV(int width, int height, Color top, Color bottom)
Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); Image GenImageGradientH(int width, int height, Color left, Color right)
Image GenImageWhiteNoise(int width, int height, float factor); Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer)
Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2)
Image GenImageCellular(int width, int height, int tileSize); Image GenImageWhiteNoise(int width, int height, float factor)
void GenTextureMipmaps(Texture2D *texture); Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale)
void SetTextureFilter(Texture2D texture, int filterMode); Image GenImageCellular(int width, int height, int tileSize)
void SetTextureWrap(Texture2D texture, int wrapMode); void GenTextureMipmaps(Texture2D *texture)
void DrawTexture(Texture2D texture, int posX, int posY, Color tint); void SetTextureFilter(Texture2D texture, int filterMode)
void DrawTextureV(Texture2D texture, Vector2 position, Color tint); void SetTextureWrap(Texture2D texture, int wrapMode)
void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); void DrawTexture(Texture2D texture, int posX, int posY, Color tint)
void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint); void DrawTextureV(Texture2D texture, Vector2 position, Color tint)
void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint); void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint)
void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint)
void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint); void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint)
Font GetFontDefault(void); void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint)
Font LoadFont(const char *fileName); void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint)
Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount); Font GetFontDefault(void)
Font LoadFontFromImage(Image image, Color key, int firstChar); Font LoadFont(const char *fileName)
CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type); Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount)
Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod); Font LoadFontFromImage(Image image, Color key, int firstChar)
void UnloadFont(Font font); CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type)
void DrawFPS(int posX, int posY); Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod)
void DrawText(const char *text, int posX, int posY, int fontSize, Color color); void UnloadFont(Font font)
void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); void DrawFPS(int posX, int posY)
void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint); void DrawText(const char *text, int posX, int posY, int fontSize, Color color)
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 DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint)
void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint); void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint)
int MeasureText(const char *text, int fontSize); 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)
Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint)
int GetGlyphIndex(Font font, int codepoint); int MeasureText(const char *text, int fontSize)
int TextCopy(char *dst, const char *src); Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing)
bool TextIsEqual(const char *text1, const char *text2); int GetGlyphIndex(Font font, int codepoint)
unsigned int TextLength(const char *text); int TextCopy(char *dst, const char *src)
const char *TextFormat(const char *text, ...); bool TextIsEqual(const char *text1, const char *text2)
const char *TextSubtext(const char *text, int position, int length); unsigned int TextLength(const char *text)
char *TextReplace(char *text, const char *replace, const char *by); const char *TextFormat(const char *text, ...)
char *TextInsert(const char *text, const char *insert, int position); const char *TextSubtext(const char *text, int position, int length)
const char *TextJoin(const char **textList, int count, const char *delimiter); char *TextReplace(char *text, const char *replace, const char *by)
const char **TextSplit(const char *text, char delimiter, int *count); char *TextInsert(const char *text, const char *insert, int position)
void TextAppend(char *text, const char *append, int *position); const char *TextJoin(const char **textList, int count, const char *delimiter)
int TextFindIndex(const char *text, const char *find); const char **TextSplit(const char *text, char delimiter, int *count)
const char *TextToUpper(const char *text); void TextAppend(char *text, const char *append, int *position)
const char *TextToLower(const char *text); int TextFindIndex(const char *text, const char *find)
const char *TextToPascal(const char *text); const char *TextToUpper(const char *text)
int TextToInteger(const char *text); const char *TextToLower(const char *text)
char *TextToUtf8(int *codepoints, int length); const char *TextToPascal(const char *text)
int *GetCodepoints(const char *text, int *count); int TextToInteger(const char *text)
int GetCodepointsCount(const char *text); char *TextToUtf8(int *codepoints, int length)
int GetNextCodepoint(const char *text, int *bytesProcessed); int *GetCodepoints(const char *text, int *count)
const char *CodepointToUtf8(int codepoint, int *byteLength); int GetCodepointsCount(const char *text)
void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); int GetNextCodepoint(const char *text, int *bytesProcessed)
void DrawPoint3D(Vector3 position, Color color); const char *CodepointToUtf8(int codepoint, int *byteLength)
void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color)
void DrawCube(Vector3 position, float width, float height, float length, Color color); void DrawPoint3D(Vector3 position, Color color)
void DrawCubeV(Vector3 position, Vector3 size, Color color); void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color)
void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); void DrawCube(Vector3 position, float width, float height, float length, Color color)
void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); void DrawCubeV(Vector3 position, Vector3 size, Color color)
void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); void DrawCubeWires(Vector3 position, float width, float height, float length, Color color)
void DrawSphere(Vector3 centerPos, float radius, Color color); void DrawCubeWiresV(Vector3 position, Vector3 size, Color color)
void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color)
void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); void DrawSphere(Vector3 centerPos, float radius, Color color)
void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color)
void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color)
void DrawPlane(Vector3 centerPos, Vector2 size, Color color); void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color)
void DrawRay(Ray ray, Color color); void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color)
void DrawGrid(int slices, float spacing); void DrawPlane(Vector3 centerPos, Vector2 size, Color color)
void DrawGizmo(Vector3 position); void DrawRay(Ray ray, Color color)
Model LoadModel(const char *fileName); void DrawGrid(int slices, float spacing)
Model LoadModelFromMesh(Mesh mesh); void DrawGizmo(Vector3 position)
void UnloadModel(Model model); Model LoadModel(const char *fileName)
Mesh *LoadMeshes(const char *fileName, int *meshCount); Model LoadModelFromMesh(Mesh mesh)
void ExportMesh(Mesh mesh, const char *fileName); void UnloadModel(Model model)
void UnloadMesh(Mesh mesh); Mesh *LoadMeshes(const char *fileName, int *meshCount)
Material *LoadMaterials(const char *fileName, int *materialCount); void ExportMesh(Mesh mesh, const char *fileName)
Material LoadMaterialDefault(void); void UnloadMesh(Mesh mesh)
void UnloadMaterial(Material material); Material *LoadMaterials(const char *fileName, int *materialCount)
void SetMaterialTexture(Material *material, int mapType, Texture2D texture); Material LoadMaterialDefault(void)
void SetModelMeshMaterial(Model *model, int meshId, int materialId); void UnloadMaterial(Material material)
ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount); void SetMaterialTexture(Material *material, int mapType, Texture2D texture)
void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); void SetModelMeshMaterial(Model *model, int meshId, int materialId)
void UnloadModelAnimation(ModelAnimation anim); ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount)
bool IsModelAnimationValid(Model model, ModelAnimation anim); void UpdateModelAnimation(Model model, ModelAnimation anim, int frame)
Mesh GenMeshPoly(int sides, float radius); void UnloadModelAnimation(ModelAnimation anim)
Mesh GenMeshPlane(float width, float length, int resX, int resZ); bool IsModelAnimationValid(Model model, ModelAnimation anim)
Mesh GenMeshCube(float width, float height, float length); Mesh GenMeshPoly(int sides, float radius)
Mesh GenMeshSphere(float radius, int rings, int slices); Mesh GenMeshPlane(float width, float length, int resX, int resZ)
Mesh GenMeshHemiSphere(float radius, int rings, int slices); Mesh GenMeshCube(float width, float height, float length)
Mesh GenMeshCylinder(float radius, float height, int slices); Mesh GenMeshSphere(float radius, int rings, int slices)
Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); Mesh GenMeshHemiSphere(float radius, int rings, int slices)
Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); Mesh GenMeshCylinder(float radius, float height, int slices)
Mesh GenMeshHeightmap(Image heightmap, Vector3 size); Mesh GenMeshTorus(float radius, float size, int radSeg, int sides)
Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); Mesh GenMeshKnot(float radius, float size, int radSeg, int sides)
BoundingBox MeshBoundingBox(Mesh mesh); Mesh GenMeshHeightmap(Image heightmap, Vector3 size)
void MeshTangents(Mesh *mesh); Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize)
void MeshBinormals(Mesh *mesh); BoundingBox MeshBoundingBox(Mesh mesh)
void DrawModel(Model model, Vector3 position, float scale, Color tint); void MeshTangents(Mesh *mesh)
void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); void MeshBinormals(Mesh *mesh)
void DrawModelWires(Model model, Vector3 position, float scale, Color tint); void DrawModel(Model model, Vector3 position, float scale, Color tint)
void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
void DrawBoundingBox(BoundingBox box, Color color); void DrawModelWires(Model model, Vector3 position, float scale, Color tint)
void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint); void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint)
void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); void DrawBoundingBox(BoundingBox box, Color color)
bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB); void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint)
bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint)
bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB)
bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint); bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2)
bool CheckCollisionRayBox(Ray ray, BoundingBox box); bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius)
RayHitInfo GetCollisionRayModel(Ray ray, Model model); bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint)
RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); bool CheckCollisionRayBox(Ray ray, BoundingBox box)
RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight); RayHitInfo GetCollisionRayModel(Ray ray, Model model)
Shader LoadShader(const char *vsFileName, const char *fsFileName); RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3)
Shader LoadShaderCode(const char *vsCode, const char *fsCode); RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight)
void UnloadShader(Shader shader); Shader LoadShader(const char *vsFileName, const char *fsFileName)
Shader GetShaderDefault(void); Shader LoadShaderCode(const char *vsCode, const char *fsCode)
Texture2D GetTextureDefault(void); void UnloadShader(Shader shader)
Texture2D GetShapesTexture(void); Shader GetShaderDefault(void)
Rectangle GetShapesTextureRec(void); Texture2D GetTextureDefault(void)
void SetShapesTexture(Texture2D texture, Rectangle source); Texture2D GetShapesTexture(void)
int GetShaderLocation(Shader shader, const char *uniformName); Rectangle GetShapesTextureRec(void)
void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType); void SetShapesTexture(Texture2D texture, Rectangle source)
void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count); int GetShaderLocation(Shader shader, const char *uniformName)
void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType)
void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture); void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count)
void SetMatrixProjection(Matrix proj); void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat)
void SetMatrixModelview(Matrix view); void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture)
Matrix GetMatrixModelview(void); void SetMatrixProjection(Matrix proj)
Matrix GetMatrixProjection(void); void SetMatrixModelview(Matrix view)
Texture2D GenTextureCubemap(Shader shader, Texture2D map, int size); Matrix GetMatrixModelview(void)
Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size); Matrix GetMatrixProjection(void)
Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size); Texture2D GenTextureCubemap(Shader shader, Texture2D map, int size)
Texture2D GenTextureBRDF(Shader shader, int size); Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size)
void BeginShaderMode(Shader shader); Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size)
void EndShaderMode(void); Texture2D GenTextureBRDF(Shader shader, int size)
void BeginBlendMode(int mode); void BeginShaderMode(Shader shader)
void EndBlendMode(void); void EndShaderMode(void)
void InitVrSimulator(void); void BeginBlendMode(int mode)
void CloseVrSimulator(void); void EndBlendMode(void)
void UpdateVrTracking(Camera *camera); void InitVrSimulator(void)
void SetVrConfiguration(VrDeviceInfo info, Shader distortion); void CloseVrSimulator(void)
bool IsVrSimulatorReady(void); void UpdateVrTracking(Camera *camera)
void ToggleVrMode(void); void SetVrConfiguration(VrDeviceInfo info, Shader distortion)
void BeginVrDrawing(void); bool IsVrSimulatorReady(void)
void EndVrDrawing(void); void ToggleVrMode(void)
void InitAudioDevice(void); void BeginVrDrawing(void)
void CloseAudioDevice(void); void EndVrDrawing(void)
bool IsAudioDeviceReady(void); void InitAudioDevice(void)
void SetMasterVolume(float volume); void CloseAudioDevice(void)
Wave LoadWave(const char *fileName); bool IsAudioDeviceReady(void)
Sound LoadSound(const char *fileName); void SetMasterVolume(float volume)
Sound LoadSoundFromWave(Wave wave); Wave LoadWave(const char *fileName)
void UpdateSound(Sound sound, const void *data, int samplesCount); Sound LoadSound(const char *fileName)
void UnloadWave(Wave wave); Sound LoadSoundFromWave(Wave wave)
void UnloadSound(Sound sound); void UpdateSound(Sound sound, const void *data, int samplesCount)
void ExportWave(Wave wave, const char *fileName); void UnloadWave(Wave wave)
void ExportWaveAsCode(Wave wave, const char *fileName); void UnloadSound(Sound sound)
void PlaySound(Sound sound); void ExportWave(Wave wave, const char *fileName)
void StopSound(Sound sound); void ExportWaveAsCode(Wave wave, const char *fileName)
void PauseSound(Sound sound); void PlaySound(Sound sound)
void ResumeSound(Sound sound); void StopSound(Sound sound)
void PlaySoundMulti(Sound sound); void PauseSound(Sound sound)
void StopSoundMulti(void); void ResumeSound(Sound sound)
int GetSoundsPlaying(void); void PlaySoundMulti(Sound sound)
bool IsSoundPlaying(Sound sound); void StopSoundMulti(void)
void SetSoundVolume(Sound sound, float volume); int GetSoundsPlaying(void)
void SetSoundPitch(Sound sound, float pitch); bool IsSoundPlaying(Sound sound)
void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); void SetSoundVolume(Sound sound, float volume)
Wave WaveCopy(Wave wave); void SetSoundPitch(Sound sound, float pitch)
void WaveCrop(Wave *wave, int initSample, int finalSample); void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels)
float *GetWaveData(Wave wave); Wave WaveCopy(Wave wave)
Music LoadMusicStream(const char *fileName); void WaveCrop(Wave *wave, int initSample, int finalSample)
void UnloadMusicStream(Music music); float *GetWaveData(Wave wave)
void PlayMusicStream(Music music); Music LoadMusicStream(const char *fileName)
void UpdateMusicStream(Music music); void UnloadMusicStream(Music music)
void StopMusicStream(Music music); void PlayMusicStream(Music music)
void PauseMusicStream(Music music); void UpdateMusicStream(Music music)
void ResumeMusicStream(Music music); void StopMusicStream(Music music)
bool IsMusicPlaying(Music music); void PauseMusicStream(Music music)
void SetMusicVolume(Music music, float volume); void ResumeMusicStream(Music music)
void SetMusicPitch(Music music, float pitch); bool IsMusicPlaying(Music music)
void SetMusicLoopCount(Music music, int count); void SetMusicVolume(Music music, float volume)
float GetMusicTimeLength(Music music); void SetMusicPitch(Music music, float pitch)
float GetMusicTimePlayed(Music music); void SetMusicLoopCount(Music music, int count)
AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); float GetMusicTimeLength(Music music)
void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); float GetMusicTimePlayed(Music music)
void CloseAudioStream(AudioStream stream); AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels)
bool IsAudioStreamProcessed(AudioStream stream); void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount)
void PlayAudioStream(AudioStream stream); void CloseAudioStream(AudioStream stream)
void PauseAudioStream(AudioStream stream); bool IsAudioStreamProcessed(AudioStream stream)
void ResumeAudioStream(AudioStream stream); void PlayAudioStream(AudioStream stream)
bool IsAudioStreamPlaying(AudioStream stream); void PauseAudioStream(AudioStream stream)
void StopAudioStream(AudioStream stream); void ResumeAudioStream(AudioStream stream)
void SetAudioStreamVolume(AudioStream stream, float volume); bool IsAudioStreamPlaying(AudioStream stream)
void SetAudioStreamPitch(AudioStream stream, float pitch); void StopAudioStream(AudioStream stream)
void SetAudioStreamBufferSizeDefault(int size); void SetAudioStreamVolume(AudioStream stream, float volume)
void SetAudioStreamPitch(AudioStream stream, float pitch)
void SetAudioStreamBufferSizeDefault(int size)

2
tools/genbind.lua
View File

@ -81,7 +81,7 @@ for _,modname in ipairs(modules) do
line = line:gsub("([(),*.])%s+(%w)", function (a, b) return a .. b end) line = line:gsub("([(),*.])%s+(%w)", function (a, b) return a .. b end)
line = line:gsub("(%w)%s+([(),*.])", function (a, b) return a .. b end) line = line:gsub("(%w)%s+([(),*.])", function (a, b) return a .. b end)
proto[#proto + 1] = line:gsub(";", "") proto[#proto + 1] = line
end end
end end

40
tools/physac.h
View File

@ -1,20 +1,20 @@
void InitPhysics(void); void InitPhysics(void)
void RunPhysicsStep(void); void RunPhysicsStep(void)
void SetPhysicsTimeStep(double delta); void SetPhysicsTimeStep(double delta)
bool IsPhysicsEnabled(void); bool IsPhysicsEnabled(void)
void SetPhysicsGravity(float x, float y); void SetPhysicsGravity(float x, float y)
PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density)
PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density)
PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density)
void PhysicsAddForce(PhysicsBody body, Vector2 force); void PhysicsAddForce(PhysicsBody body, Vector2 force)
void PhysicsAddTorque(PhysicsBody body, float amount); void PhysicsAddTorque(PhysicsBody body, float amount)
void PhysicsShatter(PhysicsBody body, Vector2 position, float force); void PhysicsShatter(PhysicsBody body, Vector2 position, float force)
int GetPhysicsBodiesCount(void); int GetPhysicsBodiesCount(void)
PhysicsBody GetPhysicsBody(int index); PhysicsBody GetPhysicsBody(int index)
int GetPhysicsShapeType(int index); int GetPhysicsShapeType(int index)
int GetPhysicsShapeVerticesCount(int index); int GetPhysicsShapeVerticesCount(int index)
Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex)
void SetPhysicsBodyRotation(PhysicsBody body, float radians); void SetPhysicsBodyRotation(PhysicsBody body, float radians)
void DestroyPhysicsBody(PhysicsBody body); void DestroyPhysicsBody(PhysicsBody body)
void ResetPhysics(void); void ResetPhysics(void)
void ClosePhysics(void); void ClosePhysics(void)

2
tools/raygui.h
View File

@ -50,7 +50,7 @@ float GuiColorBarHue(Rectangle bounds, float value)
void GuiLoadStyle(const char *fileName) void GuiLoadStyle(const char *fileName)
void GuiLoadStyleDefault(void) void GuiLoadStyleDefault(void)
const char *GuiIconText(int iconId, const char *text) const char *GuiIconText(int iconId, const char *text)
void GuiDrawIcon(int iconId, Vector2 position, int pixelSize, Color color); void GuiDrawIcon(int iconId, Vector2 position, int pixelSize, Color color)
unsigned int *GuiGetIcons(void) unsigned int *GuiGetIcons(void)
unsigned int *GuiGetIconData(int iconId) unsigned int *GuiGetIconData(int iconId)
void GuiSetIconData(int iconId, unsigned int *data) void GuiSetIconData(int iconId, unsigned int *data)

166
tools/raymath.h
View File

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

138
tools/rlgl.h
View File

@ -1,69 +1,69 @@
void rlMatrixMode(int mode); void rlMatrixMode(int mode)
void rlPushMatrix(void); void rlPushMatrix(void)
void rlPopMatrix(void); void rlPopMatrix(void)
void rlLoadIdentity(void); void rlLoadIdentity(void)
void rlTranslatef(float x, float y, float z); void rlTranslatef(float x, float y, float z)
void rlRotatef(float angleDeg, float x, float y, float z); void rlRotatef(float angleDeg, float x, float y, float z)
void rlScalef(float x, float y, float z); void rlScalef(float x, float y, float z)
void rlMultMatrixf(float *matf); void rlMultMatrixf(float *matf)
void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar); void rlFrustum(double left, double right, double bottom, double top, double znear, double zfar)
void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar); void rlOrtho(double left, double right, double bottom, double top, double znear, double zfar)
void rlViewport(int x, int y, int width, int height); void rlViewport(int x, int y, int width, int height)
void rlBegin(int mode); void rlBegin(int mode)
void rlEnd(void); void rlEnd(void)
void rlVertex2i(int x, int y); void rlVertex2i(int x, int y)
void rlVertex2f(float x, float y); void rlVertex2f(float x, float y)
void rlVertex3f(float x, float y, float z); void rlVertex3f(float x, float y, float z)
void rlTexCoord2f(float x, float y); void rlTexCoord2f(float x, float y)
void rlNormal3f(float x, float y, float z); void rlNormal3f(float x, float y, float z)
void rlColor4ub(uint8_t r, uint8_t g, uint8_t b, uint8_t a); void rlColor4ub(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
void rlColor3f(float x, float y, float z); void rlColor3f(float x, float y, float z)
void rlColor4f(float x, float y, float z, float w); void rlColor4f(float x, float y, float z, float w)
void rlEnableTexture(unsigned int id); void rlEnableTexture(unsigned int id)
void rlDisableTexture(void); void rlDisableTexture(void)
void rlTextureParameters(unsigned int id, int param, int value); void rlTextureParameters(unsigned int id, int param, int value)
void rlEnableRenderTexture(unsigned int id); void rlEnableRenderTexture(unsigned int id)
void rlDisableRenderTexture(void); void rlDisableRenderTexture(void)
void rlEnableDepthTest(void); void rlEnableDepthTest(void)
void rlDisableDepthTest(void); void rlDisableDepthTest(void)
void rlEnableBackfaceCulling(void); void rlEnableBackfaceCulling(void)
void rlDisableBackfaceCulling(void); void rlDisableBackfaceCulling(void)
void rlEnableScissorTest(void); void rlEnableScissorTest(void)
void rlDisableScissorTest(void); void rlDisableScissorTest(void)
void rlScissor(int x, int y, int width, int height); void rlScissor(int x, int y, int width, int height)
void rlEnableWireMode(void); void rlEnableWireMode(void)
void rlDisableWireMode(void); void rlDisableWireMode(void)
void rlDeleteTextures(unsigned int id); void rlDeleteTextures(unsigned int id)
void rlDeleteRenderTextures(RenderTexture2D target); void rlDeleteRenderTextures(RenderTexture2D target)
void rlDeleteShader(unsigned int id); void rlDeleteShader(unsigned int id)
void rlDeleteVertexArrays(unsigned int id); void rlDeleteVertexArrays(unsigned int id)
void rlDeleteBuffers(unsigned int id); void rlDeleteBuffers(unsigned int id)
void rlClearColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a); void rlClearColor(uint8_t r, uint8_t g, uint8_t b, uint8_t a)
void rlClearScreenBuffers(void); void rlClearScreenBuffers(void)
void rlUpdateBuffer(int bufferId, void *data, int dataSize); void rlUpdateBuffer(int bufferId, void *data, int dataSize)
unsigned int rlLoadAttribBuffer(unsigned int vaoId, int shaderLoc, void *buffer, int size, bool dynamic); unsigned int rlLoadAttribBuffer(unsigned int vaoId, int shaderLoc, void *buffer, int size, bool dynamic)
void rlglInit(int width, int height); void rlglInit(int width, int height)
void rlglClose(void); void rlglClose(void)
void rlglDraw(void); void rlglDraw(void)
int rlGetVersion(void); int rlGetVersion(void)
bool rlCheckBufferLimit(int vCount); bool rlCheckBufferLimit(int vCount)
void rlSetDebugMarker(const char *text); void rlSetDebugMarker(const char *text)
void rlLoadExtensions(void *loader); void rlLoadExtensions(void *loader)
Vector3 rlUnproject(Vector3 source, Matrix proj, Matrix view); Vector3 rlUnproject(Vector3 source, Matrix proj, Matrix view)
unsigned int rlLoadTexture(void *data, int width, int height, int format, int mipmapCount); unsigned int rlLoadTexture(void *data, int width, int height, int format, int mipmapCount)
unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderBuffer); unsigned int rlLoadTextureDepth(int width, int height, int bits, bool useRenderBuffer)
unsigned int rlLoadTextureCubemap(void *data, int size, int format); unsigned int rlLoadTextureCubemap(void *data, int size, int format)
void rlUpdateTexture(unsigned int id, int width, int height, int format, const void *data); void rlUpdateTexture(unsigned int id, int width, int height, int format, const void *data)
void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType); void rlGetGlTextureFormats(int format, unsigned int *glInternalFormat, unsigned int *glFormat, unsigned int *glType)
void rlUnloadTexture(unsigned int id); void rlUnloadTexture(unsigned int id)
void rlGenerateMipmaps(Texture2D *texture); void rlGenerateMipmaps(Texture2D *texture)
void *rlReadTexturePixels(Texture2D texture); void *rlReadTexturePixels(Texture2D texture)
unsigned char *rlReadScreenPixels(int width, int height); unsigned char *rlReadScreenPixels(int width, int height)
RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depthBits, bool useDepthTexture); RenderTexture2D rlLoadRenderTexture(int width, int height, int format, int depthBits, bool useDepthTexture)
void rlRenderTextureAttach(RenderTexture target, unsigned int id, int attachType); void rlRenderTextureAttach(RenderTexture target, unsigned int id, int attachType)
bool rlRenderTextureComplete(RenderTexture target); bool rlRenderTextureComplete(RenderTexture target)
void rlLoadMesh(Mesh *mesh, bool dynamic); void rlLoadMesh(Mesh *mesh, bool dynamic)
void rlUpdateMesh(Mesh mesh, int buffer, int num); void rlUpdateMesh(Mesh mesh, int buffer, int num)
void rlUpdateMeshAt(Mesh mesh, int buffer, int num, int index); void rlUpdateMeshAt(Mesh mesh, int buffer, int num, int index)
void rlDrawMesh(Mesh mesh, Material material, Matrix transform); void rlDrawMesh(Mesh mesh, Material material, Matrix transform)
void rlUnloadMesh(Mesh mesh); void rlUnloadMesh(Mesh mesh)