Suppress lsan glfw leak

.gitignore

@@ -9,3 +9,6 @@
 /libboids.so
 /game.fasl
 /writeimage
+*.fasl
+*.so
+/.emacs.desktop*

Makefile

@@ -0,0 +1,22 @@
+CFLAGS=--std=c++23 -Wall -Wextra -pedantic -O0 -DDEBUG
+DEBUGFLAGS=-g3 -gdwarf-4 -fsanitize=address -fno-omit-frame-pointer -DDEBUG
+LDFLAGS=-L./lib -lraylib -lm -ldl
+INCLUDES=-I./include
+CC=g++
+
+.PHONY: build clean run all
+
+all: game.so main
+
+main: main.cpp game.h Makefile
+	$(CC) $(CFLAGS) $(INCLUDES) $(DEBUGFLAGS) main.cpp $(LDFLAGS) -o main
+
+game.so: game.cpp game.h lib.h sprites.h game_data.h Makefile 
+	$(CC) $(CFLAGS) $(INCLUDES) $(DEBUGFLAGS) -shared -fPIC game.cpp -L./lib -lraylib -lm -o game.so.tmp
+	mv game.so.tmp game.so
+
+run: all
+	LSAN_OPTIONS=suppressions=./lsan.supp LD_LIBRARY_PATH=lib ./main
+
+clean:
+	rm -vf *.so *.o main

c-version/Makefile

@@ -1,27 +0,0 @@
-CFLAGS=-g -fsanitize=address -fno-omit-frame-pointer -Wall -Wextra -pedantic -O0
-CC=gcc
-
-.PHONY: build clean run all
-
-all: main dod boids_main
-
-main: main.c lib.h sprites.o sprites.h game_data.h ./lib/libraylib.a
-	$(CC) $(CFLAGS) -Iinclude/ -lm main.c -o main sprites.o ./lib/libraylib.a
-
-sprites.o: sprites.c sprites.h lib.h
-	$(CC) $(CFLAGS) -c sprites.c -o sprites.o
-
-dod: dod.c ./lib/libraylib.a
-	$(CC) $(CFLAGS) -Iinclude/ -lm dod.c -o dod ./lib/libraylib.a
-
-boids_main: boids_main.c lib.h libboids.so
-	$(CC) $(CFLAGS) -Iinclude/ -ldl -lm -lraylib $< -o $@ -L./lib -Wl,-rpath,./lib/
-
-libboids.so: boids_game.c boids_game.h lib.h
-	$(CC) $(CFLAGS) -shared -fPIC -Iinclude/ -lm $< -o $@
-
-run: all
-	./main
-
-clean:
-	rm -vf *.so *.o main boids_main dod

c-version/base.c

@@ -1,29 +0,0 @@
-#include "include/raylib.h"
-#include "include/raymath.h"
-#include <stdio.h>
-#include "lib.h"
-
-#define SCREEN_WIDTH 1300
-#define SCREEN_HEIGHT 1000
-#define TARGET_FPS 60
-
-
-int main(void) {
-    InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Boids");
-
-    SetTargetFPS(TARGET_FPS);
-
-    while (!WindowShouldClose()) {
-        float dt = GetFrameTime();
-
-        // Update
-
-        BeginDrawing();
-        {
-            ClearBackground(RAYWHITE);
-        }
-        EndDrawing();
-    }
-
-    CloseWindow();
-}

c-version/game_data.h

@@ -1,83 +0,0 @@
-#pragma once
-
-#define TEX_GROUND         0
-#define TEX_KNIGHT         1
-#define TEX_MOUSE_CURSOR   2
-#define TEX_TARGET_RETICLE 3
-
-#define ANIM_KNIGHT_IDLE         0
-#define ANIM_KNIGHT_RUN          1
-#define ANIM_KNIGHT_ATTACK_SIDE1 2
-#define ANIM_KNIGHT_ATTACK_SIDE2 3
-#define ANIM_KNIGHT_ATTACK_TOP1  4
-#define ANIM_KNIGHT_ATTACK_TOP2  5
-#define ANIM_KNIGHT_ATTACK_BACK1 6
-#define ANIM_KNIGHT_ATTACK_BACK2 7
-
-// SpriteSheet knight_spritesheet = {
-//     .name = "blue_knight",
-//     .texture = {0},
-//     // .anim_count = 8,
-//     .size = { 1152, 1536 },
-// };
-
-const u16 knight_sprite_size = 192;
-const Vector2 knight_origin = {knight_sprite_size / 2, knight_sprite_size / 2 + 35};
-const Size knight_col_size = {50, 75};
-// TODO: We probably want this as a helper function somewhere
-const Rectangle knight_colrect_select = {
-    -knight_col_size.width / 2,
-    -knight_col_size.height / 2 - 35,
-    knight_col_size.width,
-    knight_col_size.height,
-};
-
-SpriteAnimation knight_idle = {
-    .total_frames = 6,
-    .loop = true,
-};
-
-SpriteAnimation knight_run = {
-    .total_frames = 6,
-    .loop = true,
-};
-
-SpriteAnimation knight_attack_side1 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_attack_side2 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_attack_front1 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_attack_front2 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_attack_back1 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_attack_back2 = {
-    .total_frames = 6,
-    .loop = false,
-};
-
-SpriteAnimation knight_anims[8];
-// knight_anims[ANIM_KNIGHT_IDLE] = knight_idle;
-// knight_anims[ANIM_KNIGHT_RUN] = knight_run;
-// knight_anims[ANIM_KNIGHT_ATTACK_SIDE1] = knight_attack_side1;
-// knight_anims[ANIM_KNIGHT_ATTACK_SIDE2] = knight_attack_side2;
-// knight_anims[ANIM_KNIGHT_ATTACK_TOP1] = knight_attack_front1;
-// knight_anims[ANIM_KNIGHT_ATTACK_TOP2] = knight_attack_front2;
-// knight_anims[ANIM_KNIGHT_ATTACK_BACK1] = knight_attack_back1;
-// knight_anims[ANIM_KNIGHT_ATTACK_BACK2] = knight_attack_back2;

c-version/lib/libraylib.so

@@ -1 +0,0 @@
-/home/joe/Development/tinyswords/lib/libraylib.so.500

c-version/lib/libraylib.so.500

@@ -1 +0,0 @@
-/home/joe/Development/tinyswords/lib/libraylib.so.5.0.0

c-version/main.c

@@ -1,411 +0,0 @@
-#include "include/raylib.h"
-#include "include/raymath.h"
-#include <stdlib.h>
-#include <stdbool.h>
-#include <stdio.h>
-
-#define TEXTURES_BUF_SIZE 16
-#define TARGET_FPS 60
-#define MAX_KNIGHTS 10000
-#define SCREEN_WIDTH 1300
-#define SCREEN_HEIGHT 1080
-
-#define DEBUG_MODE_ENABLED
-
-bool global_debug_mode = false;
-
-#define ENNIX_LIB_IMPLEMENTATION
-#include "lib.h"
-#include "sprites.h"
-#include "game_data.h"
-
-typedef enum KnightState {
-    KNIGHT_IDLE = 0,
-    KNIGHT_RUNNING = 1,
-    KNIGHT_ATTACKING = 2,
-} KnightState;
-
-typedef enum Direction {
-    DIR_UP = 0,
-    DIR_DOWN = 1,
-    DIR_LEFT = 2,
-    DIR_RIGHT = 3,
-    // DIR_UP_LEFT = 4,
-    // DIR_UP_RIGHT = 5,
-    // DIR_DOWN_LEFT = 6,
-    // DIR_DOWN_RIGHT = 7,
-} Direction;
-
-typedef struct Knight {
-    Point position;
-    Point move_target_point;
-    u8 look_dir;
-    u8 state;
-    u8 selected;
-    u8 ordered_to_move;
-} Knight;
-
-typedef struct GameState {
-    int frame_count;
-    Point camera_position;
-
-    PointOption selected_point;
-    Knight *knights;
-    SpriteAnimationPlayback* anim_playbacks;
-    Knight *selected_knights;
-
-    PointOption selection_mouse_start_pos;
-
-    int entity_count;
-} GameState;
-
-typedef struct Assets {
-    Texture2D *textures;
-} Assets;
-
-Assets Init() {
-    knight_anims[ANIM_KNIGHT_IDLE]         = knight_idle;
-    knight_anims[ANIM_KNIGHT_RUN]          = knight_run;
-    knight_anims[ANIM_KNIGHT_ATTACK_SIDE1] = knight_attack_side1;
-    knight_anims[ANIM_KNIGHT_ATTACK_SIDE2] = knight_attack_side2;
-    knight_anims[ANIM_KNIGHT_ATTACK_TOP1]  = knight_attack_front1;
-    knight_anims[ANIM_KNIGHT_ATTACK_TOP2]  = knight_attack_front2;
-    knight_anims[ANIM_KNIGHT_ATTACK_BACK1] = knight_attack_back1;
-    knight_anims[ANIM_KNIGHT_ATTACK_BACK2] = knight_attack_back2;
-
-    Assets assets = {0};
-    assets.textures = malloc(sizeof(Texture2D) * TEXTURES_BUF_SIZE);
-    assets.textures[TEX_GROUND] = LoadTexture(../"assets/Terrain/Ground/Tilemap_Flat.png");
-    assets.textures[TEX_KNIGHT] =
-        LoadTexture("../assets/Factions/Knights/Troops/Warrior/Blue/Warrior_Blue.png");
-    assets.textures[TEX_MOUSE_CURSOR] = LoadTexture("../assets/UI/Pointers/01.png");
-    assets.textures[TEX_TARGET_RETICLE] = LoadTexture("../assets/UI/Pointers/02.png");
-    return assets;
-}
-
-void Update(GameState *game, Camera2D *cam, float dt) {
-    if (IsMouseButtonPressed(0)) {
-        Point mouse_pos = GetScreenToWorld2D(GetMousePosition(), *cam);
-        game->selection_mouse_start_pos = (PointOption){ .tag = SOME, .some.point = mouse_pos };
-    }
-
-    if (game->selection_mouse_start_pos.tag == SOME) {
-        Point start_pos = game->selection_mouse_start_pos.some.point;
-        Point current_pos = GetScreenToWorld2D(GetMousePosition(), *cam);
-
-        if (Vector2DistanceSqr(current_pos, start_pos) >= 100.0f) {
-            f32 width = current_pos.x - start_pos.x;
-            f32 height = current_pos.y - start_pos.y;
-            f32 x = width >= 0.0f ? start_pos.x : current_pos.x;
-            f32 y = height >= 0.0f ? start_pos.y : current_pos.y;
-            Rectangle rect = {x, y, fabs(width), fabs(height)};
-            for (int i = 0; i < game->entity_count; i++) {
-                Rectangle mouse_select_area = {
-                    game->knights[i].position.x + knight_colrect_select.x,
-                    game->knights[i].position.y + knight_colrect_select.y,
-                    knight_colrect_select.width,
-                    knight_colrect_select.height,
-                };
-                game->knights[i].selected =
-                    CheckCollisionRecs(rect, mouse_select_area);
-            }
-        }
-    }
-    if (IsMouseButtonReleased(0)) {
-        // TODO: This is what should happen when the distance is too small
-        // Point start_pos = game->selection_mouse_start_pos.some.point;
-        Point start_pos = game->selection_mouse_start_pos.some.point;
-        Point current_pos = GetScreenToWorld2D(GetMousePosition(), *cam);
-
-        if (Vector2DistanceSqr(current_pos, start_pos) >= 100.0f) {
-            f32 width = current_pos.x - start_pos.x;
-            f32 height = current_pos.y - start_pos.y;
-            f32 x = width >= 0.0f ? start_pos.x : current_pos.x;
-            f32 y = height >= 0.0f ? start_pos.y : current_pos.y;
-            Rectangle rect = {x, y, fabs(width), fabs(height)};
-            for (int i = 0; i < game->entity_count; i++) {
-                Rectangle mouse_select_area = {
-                    game->knights[i].position.x + knight_colrect_select.x,
-                    game->knights[i].position.y + knight_colrect_select.y,
-                    knight_colrect_select.width,
-                    knight_colrect_select.height,
-                };
-                game->knights[i].selected =
-                    CheckCollisionRecs(rect, mouse_select_area);
-            }
-        } else {
-            // TODO: This kind of sucks that we're doing all the math here to calculate
-            // the position of the collider, we need a helper that calculates origin offset
-            int k_idx = -1;
-            for (int i = 0; i < game->entity_count; i++) {
-                Rectangle mouse_select_area = {
-                    game->knights[i].position.x + knight_colrect_select.x,
-                    game->knights[i].position.y + knight_colrect_select.y,
-                    knight_colrect_select.width,
-                    knight_colrect_select.height,
-                };
-                if (CheckCollisionPointRec(current_pos, mouse_select_area)) {
-                    k_idx = i;
-                }
-                game->knights[i].selected = false;
-            }
-            if (k_idx != -1) {
-                game->knights[k_idx].selected = true;
-            }
-        }
-        game->selection_mouse_start_pos = (PointOption){ .tag = NONE, };
-    }
-
-    if (IsMouseButtonPressed(1)) {
-        Point target_pos = GetScreenToWorld2D(GetMousePosition(), *cam);
-        bool any = false;
-        for (int i = 0; i < game->entity_count; i++) {
-            if (game->knights[i].selected) {
-                game->knights[i].move_target_point = target_pos;
-                game->knights[i].ordered_to_move = true;
-                any = true;
-            }
-        }
-        if (any) {
-            game->selected_point = (PointOption){ .tag = SOME, .some.point = target_pos };
-        }
-    }
-
-    const float cam_move_speed = 1050.0f * dt;
-    Vector2 cam_vel = {0};
-    if (IsKeyDown(KEY_D)) {
-        cam_vel.x = -1;
-    }
-    if (IsKeyDown(KEY_A)) {
-        cam_vel.x = 1;
-    }
-    if (IsKeyDown(KEY_W)) {
-        cam_vel.y = 1;
-    }
-    if (IsKeyDown(KEY_S)) {
-        cam_vel.y = -1;
-    }
-    cam_vel = Vector2Normalize(cam_vel);
-    game->camera_position = Vector2Scale(cam_vel, cam_move_speed);
-    cam->offset = Vector2Add(cam->offset, game->camera_position);
-    // if (IsKeyPressed(KEY_SPACE) && game->selected_knight != -1) {
-    //     int k_idx = game->selected_knight;
-    //     if (game->knights[k_idx].state != KNIGHT_ATTACKING) {
-    //         game->knights[k_idx].state = KNIGHT_ATTACKING;
-    //         PlayAnimation(ANIM_KNIGHT_ATTACK_SIDE1, knight_anims, &game->anim_playbacks[k_idx]);
-    //     }
-    // }
-    if (IsKeyPressed(KEY_F1)) {
-        global_debug_mode = !global_debug_mode;
-    }
-
-    // Process animation data
-    TickSpriteAnimations(game->anim_playbacks, game->entity_count);
-
-    // Handle knight movement if they are moving somewhere
-    for (int i = 0; i < game->entity_count; i++) {
-        Vector2 input_vel = {0};
-        Knight *knight = &game->knights[i];
-        if (knight->ordered_to_move) {
-            Vector2 target = knight->move_target_point;
-            if (Vector2DistanceSqr(target, knight->position) < 2.5f) {
-                knight->ordered_to_move = false;
-            } else {
-                input_vel.x = knight->position.x - target.x < 0.0f ? 1 : -1;
-                knight->position = Vector2MoveTowards(knight->position, target, 4.0f);
-            }
-        }
-
-        // Handle the attacking state, if not handle state transitions
-        if (knight->state == KNIGHT_ATTACKING) {
-            if (IsAnimationFinished(game->anim_playbacks[i])) {
-                knight->state = KNIGHT_IDLE;
-                PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &game->anim_playbacks[i]);
-            }
-        } else {
-            if (input_vel.x != 0) {
-                knight->look_dir = input_vel.x == -1 ? DIR_LEFT : DIR_RIGHT;
-            }
-            if (input_vel.x != 0 || input_vel.y != 0) {
-                if (knight->state == KNIGHT_IDLE) {
-                    PlayAnimation(ANIM_KNIGHT_RUN, knight_anims, &game->anim_playbacks[i]);
-                    knight->state = KNIGHT_RUNNING;
-                }
-            } else {
-                if (knight->state == KNIGHT_RUNNING) {
-                    PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &game->anim_playbacks[i]);
-                    knight->state = KNIGHT_IDLE;
-                }
-            }
-        }
-        if (i == 0) continue;
-        // Sort the entities by y position using Insertion Sort
-        int j = i;
-        while (j > 0 && game->knights[j].position.y < game->knights[j - 1].position.y) {
-            // Swap position
-            Knight temp_k = game->knights[j - 1];
-            game->knights[j - 1] = game->knights[j];
-            game->knights[j] = temp_k;
-            // Swap animations
-            SpriteAnimationPlayback temp_a = game->anim_playbacks[j - 1];
-            game->anim_playbacks[j - 1] = game->anim_playbacks[j];
-            game->anim_playbacks[j] = temp_a;
-            j--;
-        }
-    }
-}
-
-void Draw(GameState *game, Assets assets, Camera2D cam, float dt) {
-    (void)cam;
-    (void)dt;
-    ClearBackground((Color){100, 149, 237, 255});
-
-    int size = 32;
-    int topx = SCREEN_WIDTH / 2 - size * 32 / 2;
-    int topy = SCREEN_HEIGHT / 2 - size * 32 / 2;
-    for (int col = 0; col < size; col++) {
-        for (int row = 0; row < size; row++) {
-            int atlas_col = 0;
-            int atlas_row = 0;
-            if (col == size - 1) {
-                atlas_col = 5;
-            } else if (col > 0) {
-                atlas_col = (col % 4) + 1;
-            }
-            if (row == size - 1) {
-                atlas_row = 5;
-            } else if (row > 0) {
-                atlas_row = (row % 4) + 1;
-            }
-            Vector2 pos = {32 * col + topx, 32 * row + topy};
-            Rectangle src_rect = {32 * atlas_col, 32 * atlas_row, 32, 32};
-            D_DrawTextureRec(assets.textures[TEX_GROUND], src_rect, pos, WHITE);
-        }
-    }
-
-    if (game->selected_point.tag == SOME) {
-        Vector2 marker_pos = game->selected_point.some.point;
-        marker_pos.x -= assets.textures[TEX_TARGET_RETICLE].width / 2;
-        marker_pos.y -= assets.textures[TEX_TARGET_RETICLE].height / 2;
-        D_DrawTextureV(assets.textures[TEX_TARGET_RETICLE], marker_pos, WHITE);
-    }
-
-    // for (int i = 0; i < game->anim_playbacks_count; i++) {
-    for (int i = 0; i < game->entity_count; i++) {
-        Knight *knight = &game->knights[i];
-        SpriteAnimationPlayback *playback = &game->anim_playbacks[i];
-        Rectangle src_rect = {
-            playback->current_frame * knight_sprite_size,
-            playback->row * knight_sprite_size,
-            knight_sprite_size,
-            knight_sprite_size,
-        };
-        // TODO: This might be a nice place to optimize
-        if (knight->look_dir == DIR_LEFT) {
-            src_rect.width = -abs((int)src_rect.width);
-        }
-        Rectangle dest_rect = {knight->position.x, knight->position.y, 192, 192};
-        Texture2D tex = assets.textures[TEX_KNIGHT];
-        D_DrawTexturePro(tex, src_rect, dest_rect, knight_origin, 0.0f, WHITE);
-        if (knight->selected == true) {
-            Rectangle knight_col_area = {
-                knight->position.x + knight_colrect_select.x,
-                knight->position.y + knight_colrect_select.y,
-                knight_colrect_select.width,
-                knight_colrect_select.height,
-            };
-            // Color color = game->selected_knight == NULL ? RED : GREEN;
-            DrawRectangleLinesEx(knight_col_area, 2.0f, GREEN);
-        }
-    }
-
-    if (game->selection_mouse_start_pos.tag == SOME) {
-        Point start_pos = game->selection_mouse_start_pos.some.point;
-        Point current_pos = GetScreenToWorld2D(GetMousePosition(), cam);
-
-        if (Vector2DistanceSqr(current_pos, start_pos) >= 100.0f) {
-            f32 width = current_pos.x - start_pos.x;
-            f32 height = current_pos.y - start_pos.y;
-            f32 x = width >= 0.0f ? start_pos.x : current_pos.x;
-            f32 y = height >= 0.0f ? start_pos.y : current_pos.y;
-            Rectangle rect = {x, y, fabs(width), fabs(height)};
-            DrawRectangleLinesEx(rect, 4.0f, WHITE);
-        }
-    }
-
-    Vector2 world = GetScreenToWorld2D(GetMousePosition(), cam);
-    Vector2 pointer_pos = Vector2Subtract(world, (Vector2){24, 19});
-    D_DrawTextureV(assets.textures[TEX_MOUSE_CURSOR], pointer_pos, WHITE);
-
-    DrawRectangle(SCREEN_WIDTH - 106, 4, 88, 30, WHITE);
-    DrawFPS(SCREEN_WIDTH - 100, 10);
-}
-
-int main(void) {
-    printf("Knight Size: %ld \n", sizeof(Knight));
-    printf("SpriteAnimationPlayback Size: %ld \n", sizeof(SpriteAnimationPlayback));
-    printf("Point Size: %ld \n", sizeof(Point));
-    printf("Point Option Size: %ld \n", sizeof(PointOption));
-    printf("Direction Size: %ld \n", sizeof(Direction));
-    printf("KnightState Size: %ld \n", sizeof(KnightState));
-
-    InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Tiny Knights");
-
-    int monitor = GetCurrentMonitor();
-    int monitor_width = GetMonitorWidth(monitor);
-    int monitor_height = GetMonitorHeight(monitor);
-    int win_pos_x = monitor_width / 2 - SCREEN_WIDTH / 2;
-    int win_pos_y = monitor_height / 2 - SCREEN_HEIGHT / 2;
-    SetWindowPosition(win_pos_x, win_pos_y);
-
-    SetTargetFPS(TARGET_FPS);
-
-    HideCursor();
-
-    Camera2D cam = {0};
-    cam.zoom = 1.0f;
-
-    Assets assets = Init();
-
-    GameState game = {0};
-    game.knights = calloc(MAX_KNIGHTS, sizeof(Knight));
-    game.anim_playbacks = calloc(MAX_KNIGHTS, sizeof(SpriteAnimationPlayback));
-    const int entities = MAX_KNIGHTS;
-    for (int i = 0; i < entities; i++) {
-
-        int rand_x = GetRandomValue(165, 1130);
-        int rand_y = 100 + ((float)950 / (float)entities) * i;
-        game.knights[i].position = (Vector2){rand_x,rand_y};
-
-        PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &game.anim_playbacks[i]);
-        int rand_frame = GetRandomValue(0, knight_anims[ANIM_KNIGHT_IDLE].total_frames);
-        game.anim_playbacks[i].current_frame = rand_frame;
-    }
-    game.entity_count = entities;
-
-    while (!WindowShouldClose()) {
-        game.frame_count++;
-        float dt = GetFrameTime();
-
-        Update(&game, &cam, dt);
-
-        BeginDrawing();
-        {
-            BeginMode2D(cam);
-            {
-                Draw(&game, assets, cam, dt);
-            }
-            EndMode2D();
-        }
-        EndDrawing();
-    }
-
-    free(game.knights);
-    free(game.anim_playbacks);
-    for (int i = 0; i < TEXTURES_BUF_SIZE; i++) {
-        UnloadTexture(assets.textures[i]);
-    }
-    free(assets.textures);
-    CloseWindow();
-    return 0;
-}

c-version/sprites.h

@@ -1,22 +0,0 @@
-// sprites.h
-#pragma once
-
-#include "lib.h"
-#include "include/raylib.h"
-
-typedef struct {
-    u8 loop;
-    u8 total_frames;
-} SpriteAnimation;
-
-typedef struct {
-    f32 time_elapsed;
-    u8 row;
-    u8 total_frames;
-    u8 current_frame;
-    u8 loop;
-} SpriteAnimationPlayback;
-
-void PlayAnimation(int animation, SpriteAnimation *anims, SpriteAnimationPlayback *playback);
-void TickSpriteAnimations(SpriteAnimationPlayback *playbacks, int len);
-bool IsAnimationFinished(SpriteAnimationPlayback playback);

game.cpp

@@ -0,0 +1,324 @@
+#include <cstdlib>
+#include <cstdio>
+#include <cstring>
+#include <optional>
+#include <iostream>
+
+using namespace std;
+
+#define ENNIX_LIB_IMPLEMENTATION
+#include "lib.h"
+#include "sprites.h"
+#include "game.h"
+#include "game_data.h"
+
+GameState *InitState() {
+    Assets assets = {};
+    assets.textures = (Texture*)malloc(sizeof(Texture2D) * TEXTURES_BUF_SIZE);
+    assets.textures[TEX_GROUND] = LoadTexture("./assets/Terrain/Ground/Tilemap_Flat.png");
+    assets.textures[TEX_KNIGHT] =
+        LoadTexture("./assets/Factions/Knights/Troops/Warrior/Blue/Warrior_Blue.png");
+    assets.textures[TEX_MOUSE_CURSOR] = LoadTexture("./assets/UI/Pointers/01.png");
+    assets.textures[TEX_TARGET_RETICLE] = LoadTexture("./assets/UI/Pointers/02.png");
+
+    auto game = new GameState;
+    game->should_reset = false;
+    game->assets = assets;
+    // TODO: Probably want to use idiomatic C++ here?
+    game->knights = (Knight*)calloc(MAX_KNIGHTS, sizeof(Knight));
+    game->anim_playbacks = (SpriteAnimationPlayback*)calloc(MAX_KNIGHTS, sizeof(SpriteAnimationPlayback));
+    const int entities = MAX_KNIGHTS;
+    for (int i = 0; i < entities; i++) {
+        f32 rand_x = GetRandomValue(165, 1130);
+        f32 rand_y = 100 + ((float)950 / (float)entities) * i;
+        game->knights[i].position = {rand_x,rand_y};
+
+        PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &game->anim_playbacks[i]);
+        int rand_frame = GetRandomValue(0, knight_anims[ANIM_KNIGHT_IDLE].total_frames - 1);
+        game->anim_playbacks[i].current_frame = rand_frame;
+    }
+    game->entity_count = entities;
+
+    game->camera = Camera2D{.offset = {0, 0}, .target = {0, 0}, .rotation = 0.0f, .zoom = 1.0f};
+
+    return game;
+}
+
+GameState *Init() {
+    SetTraceLogLevel(LOG_WARNING);
+    InitWindow(SCREEN_WIDTH, SCREEN_HEIGHT, "Tiny Knights");
+
+    int monitor = GetCurrentMonitor();
+    int monitor_width = GetMonitorWidth(monitor);
+    int monitor_height = GetMonitorHeight(monitor);
+    int win_pos_x = monitor_width / 2 - SCREEN_WIDTH / 2;
+    int win_pos_y = monitor_height / 2 - SCREEN_HEIGHT / 2;
+    SetWindowPosition(win_pos_x, win_pos_y);
+
+    SetTargetFPS(TARGET_FPS);
+
+    HideCursor();
+
+    return InitState();
+}
+
+void Input(GameState *state) {
+    if (IsMouseButtonPressed(0)) {
+        if (IsKeyDown(KEY_LEFT_CONTROL)) {
+            state->drag_camera_start_pos = optional<Point>{GetMousePosition()};
+            state->camera_target_start_pos = state->camera.target;
+        } else {
+            auto point = GetScreenToWorld2D(GetMousePosition(), state->camera);
+            state->selection_mouse_start_pos = optional<Point>{point};
+        }
+    }
+    if (IsMouseButtonReleased(0)) {
+        state->selection_mouse_start_pos = optional<Point>{};
+        state->drag_camera_start_pos = optional<Point>{};
+    }
+
+    if (IsMouseButtonPressed(1)) {
+        Point target_pos = GetScreenToWorld2D(GetMousePosition(), state->camera);
+        bool any = false;
+        for (int i = 0; i < state->entity_count; i++) {
+            if (state->knights[i].selected) {
+                state->knights[i].move_target_point = target_pos;
+                state->knights[i].ordered_to_move = true;
+                any = true;
+            }
+        }
+        if (any) {
+            state->selected_point = optional<Point>{target_pos};
+        }
+    }
+
+    if (IsKeyPressed(KEY_SPACE)) {
+        for (int i = 0; i < state->entity_count; i++) {
+            auto& knight = state->knights[i];
+            if (knight.selected && knight.state != KnightState::ATTACKING) {
+                knight.ordered_to_move = false;
+                knight.state = KnightState::ATTACKING;
+                PlayAnimation(ANIM_KNIGHT_ATTACK_SIDE1, knight_anims, &state->anim_playbacks[i]);
+            }
+        }
+    }
+    if (IsKeyPressed(KEY_F1)) {
+        global_debug_mode = !global_debug_mode;
+    }
+    if (IsKeyPressed(KEY_F2)) {
+        state->should_reset = true;
+        printf("Resetting GameState\n");
+    }
+}
+
+void Update(GameState *state) {
+    // cout << "Cool" << endl;
+    if (state->selection_mouse_start_pos.has_value()) {
+        Point start_pos = state->selection_mouse_start_pos.value();
+        Point current_pos = GetScreenToWorld2D(GetMousePosition(), state->camera);
+
+        f32 width = current_pos.x - start_pos.x;
+        f32 height = current_pos.y - start_pos.y;
+        f32 x = width >= 0.0f ? start_pos.x : current_pos.x;
+        f32 y = height >= 0.0f ? start_pos.y : current_pos.y;
+        Rectangle rect = {x, y, fabs(width), fabs(height)};
+        for (int i = 0; i < state->entity_count; i++) {
+            Rectangle mouse_select_area = {
+                state->knights[i].position.x + knight_colrect_select.x,
+                state->knights[i].position.y + knight_colrect_select.y,
+                knight_colrect_select.width,
+                knight_colrect_select.height,
+            };
+            state->knights[i].selected = CheckCollisionRecs(rect, mouse_select_area);
+        }
+    }
+    if (state->drag_camera_start_pos.has_value()) {
+        Point start_pos = state->drag_camera_start_pos.value();
+        state->camera.target = state->camera_target_start_pos + (start_pos - GetMousePosition());
+    }
+    float dt = 0.33;
+    const float cam_move_speed = 1050.0f * dt;
+    // TODO: This was moved out of Input
+    Vector2 cam_vel = {};
+    cam_vel = Vector2Normalize(cam_vel);
+    state->camera_position = Vector2Scale(cam_vel, cam_move_speed);
+    state->camera.offset = Vector2Add(state->camera.offset, state->camera_position);
+    // Process animation data
+    TickSpriteAnimations(state->anim_playbacks, state->entity_count);
+
+    // Handle knight movement if they are moving somewhere
+    for (int i = 0; i < state->entity_count; i++) {
+        Vector2 input_vel = {};
+        Knight *knight = &state->knights[i];
+        if (knight->ordered_to_move) {
+            Vector2 target = knight->move_target_point;
+            if (Vector2DistanceSqr(target, knight->position) < 2.5f) {
+                knight->ordered_to_move = false;
+            } else {
+                input_vel.x = knight->position.x - target.x < 0.0f ? 1 : -1;
+                knight->position = Vector2MoveTowards(knight->position, target, 4.0f);
+            }
+        }
+
+        // Handle the attacking state, if not handle state transitions
+        if (knight->state == KnightState::ATTACKING) {
+            if (IsAnimationFinished(state->anim_playbacks[i])) {
+                knight->state = KnightState::IDLE;
+                PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &state->anim_playbacks[i]);
+            }
+        } else {
+            if (input_vel.x != 0) {
+                knight->look_dir = input_vel.x == -1 ? Direction::LEFT : Direction::RIGHT;
+            }
+            if (input_vel.x != 0 || input_vel.y != 0) {
+                if (knight->state == KnightState::IDLE) {
+                    PlayAnimation(ANIM_KNIGHT_RUN, knight_anims, &state->anim_playbacks[i]);
+                    knight->state = KnightState::RUNNING;
+                }
+            } else {
+                if (knight->state == KnightState::RUNNING) {
+                    PlayAnimation(ANIM_KNIGHT_IDLE, knight_anims, &state->anim_playbacks[i]);
+                    knight->state = KnightState::IDLE;
+                }
+            }
+        }
+        if (i == 0) continue;
+        // TODO: This is likely getting called every frame, probably best to have a dirty flag to detect movement
+        // Sort the entities by y position using Insertion Sort
+        int j = i;
+        while (j > 0 && state->knights[j].position.y < state->knights[j - 1].position.y) {
+            // Swap position
+            Knight temp_k = state->knights[j - 1];
+            state->knights[j - 1] = state->knights[j];
+            state->knights[j] = temp_k;
+            // Swap animations
+            SpriteAnimationPlayback temp_a = state->anim_playbacks[j - 1];
+            state->anim_playbacks[j - 1] = state->anim_playbacks[j];
+            state->anim_playbacks[j] = temp_a;
+            j--;
+        }
+    }
+}
+
+void Draw2D(GameState *state) {
+    int size = 32;
+    int topx = SCREEN_WIDTH / 2 - size * 32 / 2;
+    int topy = SCREEN_HEIGHT / 2 - size * 32 / 2;
+    for (int col = 0; col < size; col++) {
+        for (int row = 0; row < size; row++) {
+            int atlas_col = 0;
+            int atlas_row = 0;
+            if (col == size - 1) {
+                atlas_col = 5;
+            } else if (col > 0) {
+                atlas_col = (col % 4) + 1;
+            }
+            if (row == size - 1) {
+                atlas_row = 5;
+            } else if (row > 0) {
+                atlas_row = (row % 4) + 1;
+            }
+            Vector2 pos = {(f32)(32 * col + topx), (f32)(32 * row + topy)};
+            Rectangle src_rect = {(f32)(32 * atlas_col), (f32)(32 * atlas_row), 32, 32};
+            DrawTextureRec(state->assets.textures[TEX_GROUND], src_rect, pos, WHITE);
+        }
+    }
+
+    if (state->selected_point.has_value()) {
+        Vector2 marker_pos = state->selected_point.value();
+        marker_pos.x -= state->assets.textures[TEX_TARGET_RETICLE].width / 2;
+        marker_pos.y -= state->assets.textures[TEX_TARGET_RETICLE].height / 2;
+        D_DrawTextureV(state->assets.textures[TEX_TARGET_RETICLE], marker_pos, WHITE);
+    }
+
+    // for (int i = 0; i < game->anim_playbacks_count; i++) {
+    for (int i = 0; i < state->entity_count; i++) {
+        Knight *knight = &state->knights[i];
+        SpriteAnimationPlayback *playback = &state->anim_playbacks[i];
+        Rectangle src_rect = {
+            (float)(playback->current_frame * knight_sprite_size),
+            (float)(playback->row * knight_sprite_size),
+            knight_sprite_size,
+            knight_sprite_size,
+        };
+        // TODO: This might be a nice place to optimize
+        if (knight->look_dir == Direction::LEFT) {
+            src_rect.width = -abs((int)src_rect.width);
+        }
+        Rectangle dest_rect = {knight->position.x, knight->position.y, 192, 192};
+        Texture2D tex = state->assets.textures[TEX_KNIGHT];
+        D_DrawTexturePro(tex, src_rect, dest_rect, knight_origin, 0.0f, WHITE);
+        if (knight->selected == true) {
+            Rectangle knight_col_area = {
+                knight->position.x + knight_colrect_select.x,
+                knight->position.y + knight_colrect_select.y,
+                knight_colrect_select.width,
+                knight_colrect_select.height,
+            };
+            DrawRectangleLinesEx(knight_col_area, 2.0f, GREEN);
+        }
+    }
+
+    if (state->selection_mouse_start_pos.has_value()) {
+        Point start_pos = state->selection_mouse_start_pos.value();
+        Point current_pos = GetScreenToWorld2D(GetMousePosition(), state->camera);
+
+        if (Vector2DistanceSqr(current_pos, start_pos) >= 100.0f) {
+            f32 width = current_pos.x - start_pos.x;
+            f32 height = current_pos.y - start_pos.y;
+            f32 x = width >= 0.0f ? start_pos.x : current_pos.x;
+            f32 y = height >= 0.0f ? start_pos.y : current_pos.y;
+            Rectangle rect = {x, y, fabs(width), fabs(height)};
+            DrawRectangleLinesEx(rect, 4.0f, WHITE);
+        }
+    }
+
+    Vector2 world = GetScreenToWorld2D(GetMousePosition(), state->camera);
+    Vector2 pointer_pos = Vector2Subtract(world, {24, 19});
+    D_DrawTextureV(state->assets.textures[TEX_MOUSE_CURSOR], pointer_pos, WHITE);
+}
+
+extern "C" {
+    GameState* game_init() {
+        return Init();
+    }
+
+    GameState* game_init_state() {
+        return InitState();
+    }
+
+    void game_step(GameState *state) {
+        try {
+            Input(state);
+            Update(state);
+            BeginDrawing();
+            {
+                ClearBackground({100, 149, 237, 255});
+                BeginMode2D(state->camera);
+                {
+                    Draw2D(state);
+                }
+                EndMode2D();
+
+                DrawRectangle(SCREEN_WIDTH - 106, 4, 88, 30, WHITE);
+                DrawFPS(SCREEN_WIDTH - 100, 10);
+            }
+            EndDrawing();
+        }
+        catch (const exception& e) {
+            printf("Exception: %s\n", e.what());
+            TraceLog(LOG_ERROR, "Exception: %s", e.what());
+        }
+    }
+
+    void game_cleanup(GameState *state) {
+        // free(state->assets.textures);
+        delete state;
+        printf("Cleaning Up\n");
+        CloseWindow();
+    }
+
+    bool window_should_close() {
+        return WindowShouldClose();
+    }
+}

game.h

@@ -0,0 +1,77 @@
+#pragma once
+#include "raylib.h"
+#include "lib.h"
+#include "sprites.h"
+#include <vector>
+
+#include <optional>
+
+using namespace std;
+
+#define TEXTURES_BUF_SIZE 16
+#define TARGET_FPS 60
+#define MAX_KNIGHTS 50
+#define SCREEN_WIDTH 1300
+#define SCREEN_HEIGHT 1080
+
+bool global_debug_mode = false;
+
+enum class KnightState {
+    IDLE = 0,
+    RUNNING = 1,
+    ATTACKING = 2,
+};
+
+enum class Direction : u8 {
+    UP = 0,
+    DOWN = 1,
+    LEFT = 2,
+    RIGHT = 3,
+    // DIR_UP_LEFT = 4,
+    // DIR_UP_RIGHT = 5,
+    // DIR_DOWN_LEFT = 6,
+    // DIR_DOWN_RIGHT = 7,
+};
+
+struct Knight {
+    Point position;
+    Point move_target_point;
+    Direction look_dir;
+    KnightState state;
+    u8 selected;
+    u8 ordered_to_move;
+};
+
+struct Assets {
+    Texture2D *textures;
+};
+
+struct GameState {
+    bool should_reset;
+    Camera2D camera;
+    int frame_count;
+    Point camera_position;
+
+    optional<Point> selected_point;
+    Knight *knights;
+    SpriteAnimationPlayback *anim_playbacks;
+
+    optional<Point> selection_mouse_start_pos;
+
+    int entity_count;
+    Assets assets;
+
+    optional<Point> drag_camera_start_pos;
+
+    Point camera_target_start_pos;
+
+    ~GameState() {
+        free(knights);
+        free(anim_playbacks);
+        for (int i = 0; i < TEXTURES_BUF_SIZE; i++) {
+            UnloadTexture(assets.textures[i]);
+        }
+        free(assets.textures);
+        printf("Freeing GameState memory\n");
+    }
+};

game_data.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#define TEX_GROUND         0
+#define TEX_KNIGHT         1
+#define TEX_MOUSE_CURSOR   2
+#define TEX_TARGET_RETICLE 3
+
+#define ANIM_KNIGHT_IDLE         0
+#define ANIM_KNIGHT_RUN          1
+#define ANIM_KNIGHT_ATTACK_SIDE1 2
+#define ANIM_KNIGHT_ATTACK_SIDE2 3
+#define ANIM_KNIGHT_ATTACK_TOP1  4
+#define ANIM_KNIGHT_ATTACK_TOP2  5
+#define ANIM_KNIGHT_ATTACK_BACK1 6
+#define ANIM_KNIGHT_ATTACK_BACK2 7
+
+const u16 knight_sprite_size = 192;
+const Vector2 knight_origin = {knight_sprite_size / 2, knight_sprite_size / 2 + 35};
+const Size knight_col_size = {50, 75};
+// TODO: We probably want this as a helper function somewhere
+const Rectangle knight_colrect_select = {
+    -knight_col_size.width / 2,
+    -knight_col_size.height / 2 - 35,
+    knight_col_size.width,
+    knight_col_size.height,
+};
+
+SpriteAnimation knight_anims[8] = {
+    {.loop = true,  .total_frames = 6}, // ANIM_KNIGHT_IDLE
+    {.loop = true,  .total_frames = 6}, // ANIM_KNIGHT_RUN
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_SIDE1
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_SIDE2
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_TOP1
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_TOP2
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_BACK1
+    {.loop = false, .total_frames = 6}, // ANIM_KNIGHT_ATTACK_BACK2
+};

include/raylib.h

@@ -1,22 +1,22 @@
 /**********************************************************************************************
 *
-*   raylib v5.0 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
+*   raylib v5.5 - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
 *
 *   FEATURES:
 *       - NO external dependencies, all required libraries included with raylib
 *       - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly,
 *                        MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5.
 *       - Written in plain C code (C99) in PascalCase/camelCase notation
-*       - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile)
+*       - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3, ES2, ES3 - choose at compile)
 *       - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
-*       - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts)
+*       - Multiple Fonts formats supported (TTF, OTF, FNT, BDF, Sprite fonts)
 *       - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
 *       - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
 *       - Flexible Materials system, supporting classic maps and PBR maps
-*       - Animated 3D models supported (skeletal bones animation) (IQM)
+*       - Animated 3D models supported (skeletal bones animation) (IQM, M3D, GLTF)
 *       - Shaders support, including Model shaders and Postprocessing shaders
 *       - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
-*       - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
+*       - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, QOA, XM, MOD)
 *       - VR stereo rendering with configurable HMD device parameters
 *       - Bindings to multiple programming languages available!
 *
@@ -27,29 +27,35 @@
 *       - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2)
 *
 *   DEPENDENCIES (included):
-*       [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP)
+*       [rcore][GLFW] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input
-*       [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP)
+*       [rcore][RGFW] rgfw (ColleagueRiley - github.com/ColleagueRiley/RGFW) for window/context management and input
+*       [rlgl] glad/glad_gles2 (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading
 *       [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management
 *
 *   OPTIONAL DEPENDENCIES (included):
 *       [rcore] msf_gif (Miles Fogle) for GIF recording
 *       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
 *       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
+*       [rcore] rprand (Ramon Snatamaria) for pseudo-random numbers generation
+*       [rtextures] qoi (Dominic Szablewski - https://phoboslab.org) for QOI image manage
 *       [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
 *       [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
-*       [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms
+*       [rtextures] stb_image_resize2 (Sean Barret) for image resizing algorithms
+*       [rtextures] stb_perlin (Sean Barret) for Perlin Noise image generation
 *       [rtext] stb_truetype (Sean Barret) for ttf fonts loading
 *       [rtext] stb_rect_pack (Sean Barret) for rectangles packing
 *       [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation
 *       [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
 *       [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF)
-*       [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d)
+*       [rmodels] m3d (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d)
+*       [rmodels] vox_loader (Johann Nadalutti) for models loading (VOX)
 *       [raudio] dr_wav (David Reid) for WAV audio file loading
 *       [raudio] dr_flac (David Reid) for FLAC audio file loading
 *       [raudio] dr_mp3 (David Reid) for MP3 audio file loading
 *       [raudio] stb_vorbis (Sean Barret) for OGG audio loading
 *       [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
 *       [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
+*       [raudio] qoa (Dominic Szablewski - https://phoboslab.org) for QOA audio manage
 *
 *
 *   LICENSE: zlib/libpng
@@ -57,7 +63,7 @@
 *   raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
 *   BSD-like license that allows static linking with closed source software:
 *
-*   Copyright (c) 2013-2023 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2013-2024 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
@@ -82,21 +88,26 @@
 #include <stdarg.h>     // Required for: va_list - Only used by TraceLogCallback
 
 #define RAYLIB_VERSION_MAJOR 5
-#define RAYLIB_VERSION_MINOR 0
+#define RAYLIB_VERSION_MINOR 5
 #define RAYLIB_VERSION_PATCH 0
-#define RAYLIB_VERSION  "5.0"
+#define RAYLIB_VERSION  "5.5"
 
-// Function specifiers in case library is build/used as a shared library (Windows)
+// Function specifiers in case library is build/used as a shared library
 // NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
+// NOTE: visibility("default") attribute makes symbols "visible" when compiled with -fvisibility=hidden
 #if defined(_WIN32)
+    #if defined(__TINYC__)
+        #define __declspec(x) __attribute__((x))
+    #endif
     #if defined(BUILD_LIBTYPE_SHARED)
-        #if defined(__TINYC__)
-            #define __declspec(x) __attribute__((x))
-        #endif
         #define RLAPI __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
     #elif defined(USE_LIBTYPE_SHARED)
         #define RLAPI __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
     #endif
+#else
+    #if defined(BUILD_LIBTYPE_SHARED)
+        #define RLAPI __attribute__((visibility("default"))) // We are building as a Unix shared library (.so/.dylib)
+    #endif
 #endif
 
 #ifndef RLAPI
@@ -347,8 +358,10 @@ typedef struct Mesh {
     // Animation vertex data
     float *animVertices;    // Animated vertex positions (after bones transformations)
     float *animNormals;     // Animated normals (after bones transformations)
-    unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
+    unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning) (shader-location = 6)
-    float *boneWeights;     // Vertex bone weight, up to 4 bones influence by vertex (skinning)
+    float *boneWeights;     // Vertex bone weight, up to 4 bones influence by vertex (skinning) (shader-location = 7)
+    Matrix *boneMatrices;   // Bones animated transformation matrices
+    int boneCount;          // Number of bones
 
     // OpenGL identifiers
     unsigned int vaoId;     // OpenGL Vertex Array Object id
@@ -416,7 +429,7 @@ typedef struct ModelAnimation {
 // Ray, ray for raycasting
 typedef struct Ray {
     Vector3 position;       // Ray position (origin)
-    Vector3 direction;      // Ray direction
+    Vector3 direction;      // Ray direction (normalized)
 } Ray;
 
 // RayCollision, ray hit information
@@ -479,7 +492,6 @@ typedef struct VrDeviceInfo {
     int vResolution;                // Vertical resolution in pixels
     float hScreenSize;              // Horizontal size in meters
     float vScreenSize;              // Vertical size in meters
-    float vScreenCenter;            // Screen center in meters
     float eyeToScreenDistance;      // Distance between eye and display in meters
     float lensSeparationDistance;   // Lens separation distance in meters
     float interpupillaryDistance;   // IPD (distance between pupils) in meters
@@ -673,7 +685,7 @@ typedef enum {
     KEY_KP_EQUAL        = 336,      // Key: Keypad =
     // Android key buttons
     KEY_BACK            = 4,        // Key: Android back button
-    KEY_MENU            = 82,       // Key: Android menu button
+    KEY_MENU            = 5,        // Key: Android menu button
     KEY_VOLUME_UP       = 24,       // Key: Android volume up button
     KEY_VOLUME_DOWN     = 25        // Key: Android volume down button
 } KeyboardKey;
@@ -717,12 +729,12 @@ typedef enum {
     GAMEPAD_BUTTON_LEFT_FACE_DOWN,      // Gamepad left DPAD down button
     GAMEPAD_BUTTON_LEFT_FACE_LEFT,      // Gamepad left DPAD left button
     GAMEPAD_BUTTON_RIGHT_FACE_UP,       // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
-    GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,    // Gamepad right button right (i.e. PS3: Square, Xbox: X)
+    GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,    // Gamepad right button right (i.e. PS3: Circle, Xbox: B)
     GAMEPAD_BUTTON_RIGHT_FACE_DOWN,     // Gamepad right button down (i.e. PS3: Cross, Xbox: A)
-    GAMEPAD_BUTTON_RIGHT_FACE_LEFT,     // Gamepad right button left (i.e. PS3: Circle, Xbox: B)
+    GAMEPAD_BUTTON_RIGHT_FACE_LEFT,     // Gamepad right button left (i.e. PS3: Square, Xbox: X)
     GAMEPAD_BUTTON_LEFT_TRIGGER_1,      // Gamepad top/back trigger left (first), it could be a trailing button
     GAMEPAD_BUTTON_LEFT_TRIGGER_2,      // Gamepad top/back trigger left (second), it could be a trailing button
-    GAMEPAD_BUTTON_RIGHT_TRIGGER_1,     // Gamepad top/back trigger right (one), it could be a trailing button
+    GAMEPAD_BUTTON_RIGHT_TRIGGER_1,     // Gamepad top/back trigger right (first), it could be a trailing button
     GAMEPAD_BUTTON_RIGHT_TRIGGER_2,     // Gamepad top/back trigger right (second), it could be a trailing button
     GAMEPAD_BUTTON_MIDDLE_LEFT,         // Gamepad center buttons, left one (i.e. PS3: Select)
     GAMEPAD_BUTTON_MIDDLE,              // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
@@ -786,7 +798,10 @@ typedef enum {
     SHADER_LOC_MAP_CUBEMAP,         // Shader location: samplerCube texture: cubemap
     SHADER_LOC_MAP_IRRADIANCE,      // Shader location: samplerCube texture: irradiance
     SHADER_LOC_MAP_PREFILTER,       // Shader location: samplerCube texture: prefilter
-    SHADER_LOC_MAP_BRDF             // Shader location: sampler2d texture: brdf
+    SHADER_LOC_MAP_BRDF,            // Shader location: sampler2d texture: brdf
+    SHADER_LOC_VERTEX_BONEIDS,      // Shader location: vertex attribute: boneIds
+    SHADER_LOC_VERTEX_BONEWEIGHTS,  // Shader location: vertex attribute: boneWeights
+    SHADER_LOC_BONE_MATRICES        // Shader location: array of matrices uniform: boneMatrices
 } ShaderLocationIndex;
 
 #define SHADER_LOC_MAP_DIFFUSE      SHADER_LOC_MAP_ALBEDO
@@ -868,8 +883,7 @@ typedef enum {
     CUBEMAP_LAYOUT_LINE_VERTICAL,           // Layout is defined by a vertical line with faces
     CUBEMAP_LAYOUT_LINE_HORIZONTAL,         // Layout is defined by a horizontal line with faces
     CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR,     // Layout is defined by a 3x4 cross with cubemap faces
-    CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE,     // Layout is defined by a 4x3 cross with cubemap faces
+    CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE     // Layout is defined by a 4x3 cross with cubemap faces
-    CUBEMAP_LAYOUT_PANORAMA                 // Layout is defined by a panorama image (equirrectangular map)
 } CubemapLayout;
 
 // Font type, defines generation method
@@ -909,11 +923,11 @@ typedef enum {
 
 // Camera system modes
 typedef enum {
-    CAMERA_CUSTOM = 0,              // Custom camera
+    CAMERA_CUSTOM = 0,              // Camera custom, controlled by user (UpdateCamera() does nothing)
-    CAMERA_FREE,                    // Free camera
+    CAMERA_FREE,                    // Camera free mode
-    CAMERA_ORBITAL,                 // Orbital camera
+    CAMERA_ORBITAL,                 // Camera orbital, around target, zoom supported
-    CAMERA_FIRST_PERSON,            // First person camera
+    CAMERA_FIRST_PERSON,            // Camera first person
-    CAMERA_THIRD_PERSON             // Third person camera
+    CAMERA_THIRD_PERSON             // Camera third person
 } CameraMode;
 
 // Camera projection
@@ -930,7 +944,7 @@ typedef enum {
 } NPatchLayout;
 
 // Callbacks to hook some internal functions
-// WARNING: These callbacks are intended for advance users
+// WARNING: These callbacks are intended for advanced users
 typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args);  // Logging: Redirect trace log messages
 typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize);    // FileIO: Load binary data
 typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize);   // FileIO: Save binary data
@@ -956,36 +970,36 @@ RLAPI void CloseWindow(void);                                     // Close windo
 RLAPI bool WindowShouldClose(void);                               // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
 RLAPI bool IsWindowReady(void);                                   // Check if window has been initialized successfully
 RLAPI bool IsWindowFullscreen(void);                              // Check if window is currently fullscreen
-RLAPI bool IsWindowHidden(void);                                  // Check if window is currently hidden (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowHidden(void);                                  // Check if window is currently hidden
-RLAPI bool IsWindowMinimized(void);                               // Check if window is currently minimized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMinimized(void);                               // Check if window is currently minimized
-RLAPI bool IsWindowMaximized(void);                               // Check if window is currently maximized (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowMaximized(void);                               // Check if window is currently maximized
-RLAPI bool IsWindowFocused(void);                                 // Check if window is currently focused (only PLATFORM_DESKTOP)
+RLAPI bool IsWindowFocused(void);                                 // Check if window is currently focused
 RLAPI bool IsWindowResized(void);                                 // Check if window has been resized last frame
 RLAPI bool IsWindowState(unsigned int flag);                      // Check if one specific window flag is enabled
-RLAPI void SetWindowState(unsigned int flags);                    // Set window configuration state using flags (only PLATFORM_DESKTOP)
+RLAPI void SetWindowState(unsigned int flags);                    // Set window configuration state using flags
 RLAPI void ClearWindowState(unsigned int flags);                  // Clear window configuration state flags
-RLAPI void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
+RLAPI void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed, resizes monitor to match window resolution
-RLAPI void ToggleBorderlessWindowed(void);                        // Toggle window state: borderless windowed (only PLATFORM_DESKTOP)
+RLAPI void ToggleBorderlessWindowed(void);                        // Toggle window state: borderless windowed, resizes window to match monitor resolution
-RLAPI void MaximizeWindow(void);                                  // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void MaximizeWindow(void);                                  // Set window state: maximized, if resizable
-RLAPI void MinimizeWindow(void);                                  // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
+RLAPI void MinimizeWindow(void);                                  // Set window state: minimized, if resizable
-RLAPI void RestoreWindow(void);                                   // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
+RLAPI void RestoreWindow(void);                                   // Set window state: not minimized/maximized
-RLAPI void SetWindowIcon(Image image);                            // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)
+RLAPI void SetWindowIcon(Image image);                            // Set icon for window (single image, RGBA 32bit)
-RLAPI void SetWindowIcons(Image *images, int count);              // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)
+RLAPI void SetWindowIcons(Image *images, int count);              // Set icon for window (multiple images, RGBA 32bit)
-RLAPI void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
+RLAPI void SetWindowTitle(const char *title);                     // Set title for window
-RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
+RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen
 RLAPI void SetWindowMonitor(int monitor);                         // Set monitor for the current window
 RLAPI void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
 RLAPI void SetWindowMaxSize(int width, int height);               // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
 RLAPI void SetWindowSize(int width, int height);                  // Set window dimensions
-RLAPI void SetWindowOpacity(float opacity);                       // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
+RLAPI void SetWindowOpacity(float opacity);                       // Set window opacity [0.0f..1.0f]
-RLAPI void SetWindowFocused(void);                                // Set window focused (only PLATFORM_DESKTOP)
+RLAPI void SetWindowFocused(void);                                // Set window focused
 RLAPI void *GetWindowHandle(void);                                // Get native window handle
 RLAPI int GetScreenWidth(void);                                   // Get current screen width
 RLAPI int GetScreenHeight(void);                                  // Get current screen height
 RLAPI int GetRenderWidth(void);                                   // Get current render width (it considers HiDPI)
 RLAPI int GetRenderHeight(void);                                  // Get current render height (it considers HiDPI)
 RLAPI int GetMonitorCount(void);                                  // Get number of connected monitors
-RLAPI int GetCurrentMonitor(void);                                // Get current connected monitor
+RLAPI int GetCurrentMonitor(void);                                // Get current monitor where window is placed
 RLAPI Vector2 GetMonitorPosition(int monitor);                    // Get specified monitor position
 RLAPI int GetMonitorWidth(int monitor);                           // Get specified monitor width (current video mode used by monitor)
 RLAPI int GetMonitorHeight(int monitor);                          // Get specified monitor height (current video mode used by monitor)
@@ -997,6 +1011,7 @@ RLAPI Vector2 GetWindowScaleDPI(void);                            // Get window
 RLAPI const char *GetMonitorName(int monitor);                    // Get the human-readable, UTF-8 encoded name of the specified monitor
 RLAPI void SetClipboardText(const char *text);                    // Set clipboard text content
 RLAPI const char *GetClipboardText(void);                         // Get clipboard text content
+RLAPI Image GetClipboardImage(void);                              // Get clipboard image content
 RLAPI void EnableEventWaiting(void);                              // Enable waiting for events on EndDrawing(), no automatic event polling
 RLAPI void DisableEventWaiting(void);                             // Disable waiting for events on EndDrawing(), automatic events polling
 
@@ -1035,7 +1050,7 @@ RLAPI void UnloadVrStereoConfig(VrStereoConfig config);           // Unload VR s
 // NOTE: Shader functionality is not available on OpenGL 1.1
 RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);   // Load shader from files and bind default locations
 RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
-RLAPI bool IsShaderReady(Shader shader);                                   // Check if a shader is ready
+RLAPI bool IsShaderValid(Shader shader);                                   // Check if a shader is valid (loaded on GPU)
 RLAPI int GetShaderLocation(Shader shader, const char *uniformName);       // Get shader uniform location
 RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName);  // Get shader attribute location
 RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType);               // Set shader uniform value
@@ -1045,13 +1060,15 @@ RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture)
 RLAPI void UnloadShader(Shader shader);                                    // Unload shader from GPU memory (VRAM)
 
 // Screen-space-related functions
-RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera);      // Get a ray trace from mouse position
+#define GetMouseRay GetScreenToWorldRay     // Compatibility hack for previous raylib versions
-RLAPI Matrix GetCameraMatrix(Camera camera);                      // Get camera transform matrix (view matrix)
+RLAPI Ray GetScreenToWorldRay(Vector2 position, Camera camera);         // Get a ray trace from screen position (i.e mouse)
-RLAPI Matrix GetCameraMatrix2D(Camera2D camera);                  // Get camera 2d transform matrix
+RLAPI Ray GetScreenToWorldRayEx(Vector2 position, Camera camera, int width, int height); // Get a ray trace from screen position (i.e mouse) in a viewport
-RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);  // Get the screen space position for a 3d world space position
+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);        // Get the screen space position for a 3d world space position
-RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Get the world space position for a 2d camera screen space position
 RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
-RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Get the screen space position for a 2d camera world space position
+RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);    // Get the screen space position for a 2d camera world space position
+RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);    // Get the world space position for a 2d camera screen space position
+RLAPI Matrix GetCameraMatrix(Camera camera);                            // Get camera transform matrix (view matrix)
+RLAPI Matrix GetCameraMatrix2D(Camera2D camera);                        // Get camera 2d transform matrix
 
 // Timing-related functions
 RLAPI void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
@@ -1060,7 +1077,7 @@ RLAPI double GetTime(void);                                       // Get elapsed
 RLAPI int GetFPS(void);                                           // Get current FPS
 
 // Custom frame control functions
-// NOTE: Those functions are intended for advance users that want full control over the frame processing
+// NOTE: Those functions are intended for advanced users that want full control over the frame processing
 // By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
 // To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
 RLAPI void SwapScreenBuffer(void);                                // Swap back buffer with front buffer (screen drawing)
@@ -1087,7 +1104,7 @@ RLAPI void *MemRealloc(void *ptr, unsigned int size);             // Internal me
 RLAPI void MemFree(void *ptr);                                    // Internal memory free
 
 // Set custom callbacks
-// WARNING: Callbacks setup is intended for advance users
+// WARNING: Callbacks setup is intended for advanced users
 RLAPI void SetTraceLogCallback(TraceLogCallback callback);         // Set custom trace log
 RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader
 RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver
@@ -1116,10 +1133,12 @@ RLAPI const char *GetDirectoryPath(const char *filePath);         // Get full pa
 RLAPI const char *GetPrevDirectoryPath(const char *dirPath);      // Get previous directory path for a given path (uses static string)
 RLAPI const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
 RLAPI const char *GetApplicationDirectory(void);                  // Get the directory of the running application (uses static string)
+RLAPI int MakeDirectory(const char *dirPath);                     // Create directories (including full path requested), returns 0 on success
 RLAPI bool ChangeDirectory(const char *dir);                      // Change working directory, return true on success
 RLAPI bool IsPathFile(const char *path);                          // Check if a given path is a file or a directory
+RLAPI bool IsFileNameValid(const char *fileName);                 // Check if fileName is valid for the platform/OS
 RLAPI FilePathList LoadDirectoryFiles(const char *dirPath);       // Load directory filepaths
-RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan
+RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan. Use 'DIR' in the filter string to include directories in the result
 RLAPI void UnloadDirectoryFiles(FilePathList files);              // Unload filepaths
 RLAPI bool IsFileDropped(void);                                   // Check if a file has been dropped into window
 RLAPI FilePathList LoadDroppedFiles(void);                        // Load dropped filepaths
@@ -1131,10 +1150,14 @@ RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *
 RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize);  // Decompress data (DEFLATE algorithm), memory must be MemFree()
 RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // Encode data to Base64 string, memory must be MemFree()
 RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize);                    // Decode Base64 string data, memory must be MemFree()
+RLAPI unsigned int ComputeCRC32(unsigned char *data, int dataSize);     // Compute CRC32 hash code
+RLAPI unsigned int *ComputeMD5(unsigned char *data, int dataSize);      // Compute MD5 hash code, returns static int[4] (16 bytes)
+RLAPI unsigned int *ComputeSHA1(unsigned char *data, int dataSize);      // Compute SHA1 hash code, returns static int[5] (20 bytes)
+
 
 // Automation events functionality
 RLAPI AutomationEventList LoadAutomationEventList(const char *fileName);                // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
-RLAPI void UnloadAutomationEventList(AutomationEventList *list);                        // Unload automation events list from file
+RLAPI void UnloadAutomationEventList(AutomationEventList list);                         // Unload automation events list from file
 RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName);   // Export automation events list as text file
 RLAPI void SetAutomationEventList(AutomationEventList *list);                           // Set automation event list to record to
 RLAPI void SetAutomationEventBaseFrame(int frame);                                      // Set automation event internal base frame to start recording
@@ -1148,7 +1171,7 @@ RLAPI void PlayAutomationEvent(AutomationEvent event);
 
 // Input-related functions: keyboard
 RLAPI bool IsKeyPressed(int key);                             // Check if a key has been pressed once
-RLAPI bool IsKeyPressedRepeat(int key);                       // Check if a key has been pressed again (Only PLATFORM_DESKTOP)
+RLAPI bool IsKeyPressedRepeat(int key);                       // Check if a key has been pressed again
 RLAPI bool IsKeyDown(int key);                                // Check if a key is being pressed
 RLAPI bool IsKeyReleased(int key);                            // Check if a key has been released once
 RLAPI bool IsKeyUp(int key);                                  // Check if a key is NOT being pressed
@@ -1157,16 +1180,17 @@ RLAPI int GetCharPressed(void);                               // Get char presse
 RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
 
 // Input-related functions: gamepads
-RLAPI bool IsGamepadAvailable(int gamepad);                   // Check if a gamepad is available
+RLAPI bool IsGamepadAvailable(int gamepad);                                        // Check if a gamepad is available
-RLAPI const char *GetGamepadName(int gamepad);                // Get gamepad internal name id
+RLAPI const char *GetGamepadName(int gamepad);                                     // Get gamepad internal name id
-RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Check if a gamepad button has been pressed once
+RLAPI bool IsGamepadButtonPressed(int gamepad, int button);                        // Check if a gamepad button has been pressed once
-RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Check if a gamepad button is being pressed
+RLAPI bool IsGamepadButtonDown(int gamepad, int button);                           // Check if a gamepad button is being pressed
-RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Check if a gamepad button has been released once
+RLAPI bool IsGamepadButtonReleased(int gamepad, int button);                       // Check if a gamepad button has been released once
-RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Check if a gamepad button is NOT being pressed
+RLAPI bool IsGamepadButtonUp(int gamepad, int button);                             // Check if a gamepad button is NOT being pressed
-RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
+RLAPI int GetGamepadButtonPressed(void);                                           // Get the last gamepad button pressed
-RLAPI int GetGamepadAxisCount(int gamepad);                   // Get gamepad axis count for a gamepad
+RLAPI int GetGamepadAxisCount(int gamepad);                                        // Get gamepad axis count for a gamepad
-RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Get axis movement value for a gamepad axis
+RLAPI float GetGamepadAxisMovement(int gamepad, int axis);                         // Get axis movement value for a gamepad axis
-RLAPI int SetGamepadMappings(const char *mappings);           // Set internal gamepad mappings (SDL_GameControllerDB)
+RLAPI int SetGamepadMappings(const char *mappings);                                // Set internal gamepad mappings (SDL_GameControllerDB)
+RLAPI void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor, float duration); // Set gamepad vibration for both motors (duration in seconds)
 
 // Input-related functions: mouse
 RLAPI bool IsMouseButtonPressed(int button);                  // Check if a mouse button has been pressed once
@@ -1197,7 +1221,7 @@ RLAPI int GetTouchPointCount(void);                           // Get number of t
 RLAPI void SetGesturesEnabled(unsigned int flags);      // Enable a set of gestures using flags
 RLAPI bool IsGestureDetected(unsigned int gesture);     // Check if a gesture have been detected
 RLAPI int GetGestureDetected(void);                     // Get latest detected gesture
-RLAPI float GetGestureHoldDuration(void);               // Get gesture hold time in milliseconds
+RLAPI float GetGestureHoldDuration(void);               // Get gesture hold time in seconds
 RLAPI Vector2 GetGestureDragVector(void);               // Get gesture drag vector
 RLAPI float GetGestureDragAngle(void);                  // Get gesture drag angle
 RLAPI Vector2 GetGesturePinchVector(void);              // Get gesture pinch delta
@@ -1216,19 +1240,21 @@ RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, f
 // NOTE: It can be useful when using basic shapes and one single font,
 // defining a font char white rectangle would allow drawing everything in a single draw call
 RLAPI void SetShapesTexture(Texture2D texture, Rectangle source);       // Set texture and rectangle to be used on shapes drawing
+RLAPI Texture2D GetShapesTexture(void);                                 // Get texture that is used for shapes drawing
+RLAPI Rectangle GetShapesTextureRectangle(void);                        // Get texture source rectangle that is used for shapes drawing
 
 // Basic shapes drawing functions
-RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
+RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel using geometry [Can be slow, use with care]
-RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
+RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel using geometry (Vector version) [Can be slow, use with care]
 RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
 RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (using gl lines)
 RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line (using triangles/quads)
-RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color);                                  // Draw lines sequence (using gl lines)
+RLAPI void DrawLineStrip(const Vector2 *points, int pointCount, Color color);                            // Draw lines sequence (using gl lines)
 RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw line segment cubic-bezier in-out interpolation
 RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
 RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color);      // Draw a piece of a circle
 RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
-RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
+RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color inner, Color outer);         // Draw a gradient-filled circle
 RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
 RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
 RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color);                                  // Draw circle outline (Vector version)
@@ -1240,27 +1266,28 @@ RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color)
 RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
 RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
 RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
-RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
+RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color top, Color bottom);   // Draw a vertical-gradient-filled rectangle
-RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
+RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color left, Color right);   // Draw a horizontal-gradient-filled rectangle
-RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color topLeft, Color bottomLeft, Color topRight, Color bottomRight); // Draw a gradient-filled rectangle with custom vertex colors
 RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
 RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color);                            // Draw rectangle outline with extended parameters
 RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);              // Draw rectangle with rounded edges
-RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
+RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, Color color);         // Draw rectangle lines with rounded edges
+RLAPI void DrawRectangleRoundedLinesEx(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
 RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle (vertex in counter-clockwise order!)
 RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline (vertex in counter-clockwise order!)
-RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color);                                // Draw a triangle fan defined by points (first vertex is the center)
+RLAPI void DrawTriangleFan(const Vector2 *points, int pointCount, Color color);                          // Draw a triangle fan defined by points (first vertex is the center)
-RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color);                              // Draw a triangle strip defined by points
+RLAPI void DrawTriangleStrip(const Vector2 *points, int pointCount, Color color);                        // Draw a triangle strip defined by points
 RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
 RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);          // Draw a polygon outline of n sides
 RLAPI void DrawPolyLinesEx(Vector2 center, int sides, float radius, float rotation, float lineThick, Color color); // Draw a polygon outline of n sides with extended parameters
 
 // Splines drawing functions
-RLAPI void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color);                  // Draw spline: Linear, minimum 2 points
+RLAPI void DrawSplineLinear(const Vector2 *points, int pointCount, float thick, Color color);                  // Draw spline: Linear, minimum 2 points
-RLAPI void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color);                   // Draw spline: B-Spline, minimum 4 points
+RLAPI void DrawSplineBasis(const Vector2 *points, int pointCount, float thick, Color color);                   // Draw spline: B-Spline, minimum 4 points
-RLAPI void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color);              // Draw spline: Catmull-Rom, minimum 4 points
+RLAPI void DrawSplineCatmullRom(const Vector2 *points, int pointCount, float thick, Color color);              // Draw spline: Catmull-Rom, minimum 4 points
-RLAPI void DrawSplineBezierQuadratic(Vector2 *points, int pointCount, float thick, Color color);         // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
+RLAPI void DrawSplineBezierQuadratic(const Vector2 *points, int pointCount, float thick, Color color);         // Draw spline: Quadratic Bezier, minimum 3 points (1 control point): [p1, c2, p3, c4...]
-RLAPI void DrawSplineBezierCubic(Vector2 *points, int pointCount, float thick, Color color);             // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
+RLAPI void DrawSplineBezierCubic(const Vector2 *points, int pointCount, float thick, Color color);             // Draw spline: Cubic Bezier, minimum 4 points (2 control points): [p1, c2, c3, p4, c5, c6...]
 RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color);                    // Draw spline segment: Linear, 2 points
 RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points
 RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points
@@ -1278,12 +1305,13 @@ RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vect
 RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
 RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
 RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                         // Check collision between circle and rectangle
+RLAPI bool CheckCollisionCircleLine(Vector2 center, float radius, Vector2 p1, Vector2 p2);               // Check if circle collides with a line created betweeen two points [p1] and [p2]
 RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                         // Check if point is inside rectangle
 RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                       // Check if point is inside circle
 RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);               // Check if point is inside a triangle
-RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount);                      // Check if point is within a polygon described by array of vertices
-RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference
 RLAPI bool CheckCollisionPointLine(Vector2 point, Vector2 p1, Vector2 p2, int threshold);                // Check if point belongs to line created between two points [p1] and [p2] with defined margin in pixels [threshold]
+RLAPI bool CheckCollisionPointPoly(Vector2 point, const Vector2 *points, int pointCount);                // Check if point is within a polygon described by array of vertices
+RLAPI bool CheckCollisionLines(Vector2 startPos1, Vector2 endPos1, Vector2 startPos2, Vector2 endPos2, Vector2 *collisionPoint); // Check the collision between two lines defined by two points each, returns collision point by reference
 RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                         // Get collision rectangle for two rectangles collision
 
 //------------------------------------------------------------------------------------
@@ -1294,12 +1322,12 @@ RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);
 // NOTE: These functions do not require GPU access
 RLAPI Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
 RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
-RLAPI Image LoadImageSvg(const char *fileNameOrString, int width, int height);                           // Load image from SVG file data or string with specified size
 RLAPI Image LoadImageAnim(const char *fileName, int *frames);                                            // Load image sequence from file (frames appended to image.data)
+RLAPI Image LoadImageAnimFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int *frames); // Load image sequence from memory buffer
 RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);      // Load image from memory buffer, fileType refers to extension: i.e. '.png'
 RLAPI Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
 RLAPI Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer and (screenshot)
-RLAPI bool IsImageReady(Image image);                                                                    // Check if an image is ready
+RLAPI bool IsImageValid(Image image);                                                                    // Check if an image is valid (data and parameters)
 RLAPI void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
 RLAPI bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
 RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize);              // Export image to memory buffer
@@ -1319,6 +1347,7 @@ RLAPI Image GenImageText(int width, int height, const char *text);
 // Image manipulation functions
 RLAPI Image ImageCopy(Image image);                                                                      // Create an image duplicate (useful for transformations)
 RLAPI Image ImageFromImage(Image image, Rectangle rec);                                                  // Create an image from another image piece
+RLAPI Image ImageFromChannel(Image image, int selectedChannel);                                          // Create an image from a selected channel of another image (GRAYSCALE)
 RLAPI Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
 RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);         // Create an image from text (custom sprite font)
 RLAPI void ImageFormat(Image *image, int newFormat);                                                     // Convert image data to desired format
@@ -1329,9 +1358,10 @@ RLAPI void ImageAlphaClear(Image *image, Color color, float threshold);
 RLAPI void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
 RLAPI void ImageAlphaPremultiply(Image *image);                                                          // Premultiply alpha channel
 RLAPI void ImageBlurGaussian(Image *image, int blurSize);                                                // Apply Gaussian blur using a box blur approximation
+RLAPI void ImageKernelConvolution(Image *image, const float *kernel, int kernelSize);                    // Apply custom square convolution kernel to image
 RLAPI void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize image (Bicubic scaling algorithm)
 RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight);                                      // Resize image (Nearest-Neighbor scaling algorithm)
-RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill);  // Resize canvas and fill with color
+RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill); // Resize canvas and fill with color
 RLAPI void ImageMipmaps(Image *image);                                                                   // Compute all mipmap levels for a provided image
 RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
 RLAPI void ImageFlipVertical(Image *image);                                                              // Flip image vertically
@@ -1359,6 +1389,7 @@ RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color);
 RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color);                                   // Draw pixel within an image (Vector version)
 RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
 RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color);                          // Draw line within an image (Vector version)
+RLAPI void ImageDrawLineEx(Image *dst, Vector2 start, Vector2 end, int thick, Color color);              // Draw a line defining thickness within an image
 RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color);               // Draw a filled circle within an image
 RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color);                        // Draw a filled circle within an image (Vector version)
 RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color);          // Draw circle outline within an image
@@ -1367,6 +1398,11 @@ RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int hei
 RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
 RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
 RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                   // Draw rectangle lines within an image
+RLAPI void ImageDrawTriangle(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);               // Draw triangle within an image
+RLAPI void ImageDrawTriangleEx(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color c1, Color c2, Color c3); // Draw triangle with interpolated colors within an image
+RLAPI void ImageDrawTriangleLines(Image *dst, Vector2 v1, Vector2 v2, Vector2 v3, Color color);          // Draw triangle outline within an image
+RLAPI void ImageDrawTriangleFan(Image *dst, Vector2 *points, int pointCount, Color color);               // Draw a triangle fan defined by points within an image (first vertex is the center)
+RLAPI void ImageDrawTriangleStrip(Image *dst, Vector2 *points, int pointCount, Color color);             // Draw a triangle strip defined by points within an image
 RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint);             // Draw a source image within a destination image (tint applied to source)
 RLAPI void ImageDrawText(Image *dst, const char *text, int posX, int posY, int fontSize, Color color);   // Draw text (using default font) within an image (destination)
 RLAPI void ImageDrawTextEx(Image *dst, Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text (custom sprite font) within an image (destination)
@@ -1377,9 +1413,9 @@ RLAPI Texture2D LoadTexture(const char *fileName);
 RLAPI Texture2D LoadTextureFromImage(Image image);                                                       // Load texture from image data
 RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout);                                        // Load cubemap from image, multiple image cubemap layouts supported
 RLAPI RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
-RLAPI bool IsTextureReady(Texture2D texture);                                                            // Check if a texture is ready
+RLAPI bool IsTextureValid(Texture2D texture);                                                            // Check if a texture is valid (loaded in GPU)
 RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
-RLAPI bool IsRenderTextureReady(RenderTexture2D target);                                                 // Check if a render texture is ready
+RLAPI bool IsRenderTextureValid(RenderTexture2D target);                                                 // Check if a render texture is valid (loaded in GPU)
 RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
 RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
 RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data
@@ -1398,8 +1434,9 @@ RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, V
 RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely
 
 // Color/pixel related functions
+RLAPI bool ColorIsEqual(Color col1, Color col2);                            // Check if two colors are equal
 RLAPI Color Fade(Color color, float alpha);                                 // Get color with alpha applied, alpha goes from 0.0f to 1.0f
-RLAPI int ColorToInt(Color color);                                          // Get hexadecimal value for a Color
+RLAPI int ColorToInt(Color color);                                          // Get hexadecimal value for a Color (0xRRGGBBAA)
 RLAPI Vector4 ColorNormalize(Color color);                                  // Get Color normalized as float [0..1]
 RLAPI Color ColorFromNormalized(Vector4 normalized);                        // Get Color from normalized values [0..1]
 RLAPI Vector3 ColorToHSV(Color color);                                      // Get HSV values for a Color, hue [0..360], saturation/value [0..1]
@@ -1409,6 +1446,7 @@ RLAPI Color ColorBrightness(Color color, float factor);                     // G
 RLAPI Color ColorContrast(Color color, float contrast);                     // Get color with contrast correction, contrast values between -1.0f and 1.0f
 RLAPI Color ColorAlpha(Color color, float alpha);                           // Get color with alpha applied, alpha goes from 0.0f to 1.0f
 RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint);              // Get src alpha-blended into dst color with tint
+RLAPI Color ColorLerp(Color color1, Color color2, float factor);            // Get color lerp interpolation between two colors, factor [0.0f..1.0f]
 RLAPI Color GetColor(unsigned int hexValue);                                // Get Color structure from hexadecimal value
 RLAPI Color GetPixelColor(void *srcPtr, int format);                        // Get Color from a source pixel pointer of certain format
 RLAPI void SetPixelColor(void *dstPtr, Color color, int format);            // Set color formatted into destination pixel pointer
@@ -1421,10 +1459,10 @@ RLAPI int GetPixelDataSize(int width, int height, int format);              // G
 // Font loading/unloading functions
 RLAPI Font GetFontDefault(void);                                                            // Get the default Font
 RLAPI Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
-RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount);  // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set
+RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *codepoints, int codepointCount); // Load font from file with extended parameters, use NULL for codepoints and 0 for codepointCount to load the default character set, font size is provided in pixels height
 RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
 RLAPI Font LoadFontFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount); // Load font from memory buffer, fileType refers to extension: i.e. '.ttf'
-RLAPI bool IsFontReady(Font font);                                                          // Check if a font is ready
+RLAPI bool IsFontValid(Font font);                                                          // Check if a font is valid (font data loaded, WARNING: GPU texture not checked)
 RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use
 RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
 RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount);                               // Unload font chars info data (RAM)
@@ -1465,7 +1503,7 @@ RLAPI bool TextIsEqual(const char *text1, const char *text2);
 RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
 RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf() style)
 RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
-RLAPI char *TextReplace(char *text, const char *replace, const char *by);                   // Replace text string (WARNING: memory must be freed!)
+RLAPI char *TextReplace(const char *text, const char *replace, const char *by);             // Replace text string (WARNING: memory must be freed!)
 RLAPI char *TextInsert(const char *text, const char *insert, int position);                 // Insert text in a position (WARNING: memory must be freed!)
 RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter);        // Join text strings with delimiter
 RLAPI const char **TextSplit(const char *text, char delimiter, int *count);                 // Split text into multiple strings
@@ -1474,7 +1512,11 @@ RLAPI int TextFindIndex(const char *text, const char *find);
 RLAPI const char *TextToUpper(const char *text);                      // Get upper case version of provided string
 RLAPI const char *TextToLower(const char *text);                      // Get lower case version of provided string
 RLAPI const char *TextToPascal(const char *text);                     // Get Pascal case notation version of provided string
+RLAPI const char *TextToSnake(const char *text);                      // Get Snake case notation version of provided string
+RLAPI const char *TextToCamel(const char *text);                      // Get Camel case notation version of provided string
+
 RLAPI int TextToInteger(const char *text);                            // Get integer value from text (negative values not supported)
+RLAPI float TextToFloat(const char *text);                            // Get float value from text (negative values not supported)
 
 //------------------------------------------------------------------------------------
 // Basic 3d Shapes Drawing Functions (Module: models)
@@ -1485,7 +1527,7 @@ RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);
 RLAPI void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
 RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
 RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
-RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color);                            // Draw a triangle strip defined by points
+RLAPI void DrawTriangleStrip3D(const Vector3 *points, int pointCount, Color color);                      // Draw a triangle strip defined by points
 RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
 RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
 RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
@@ -1510,7 +1552,7 @@ RLAPI void DrawGrid(int slices, float spacing);
 // Model management functions
 RLAPI Model LoadModel(const char *fileName);                                                // Load model from files (meshes and materials)
 RLAPI Model LoadModelFromMesh(Mesh mesh);                                                   // Load model from generated mesh (default material)
-RLAPI bool IsModelReady(Model model);                                                       // Check if a model is ready
+RLAPI bool IsModelValid(Model model);                                                       // Check if a model is valid (loaded in GPU, VAO/VBOs)
 RLAPI void UnloadModel(Model model);                                                        // Unload model (including meshes) from memory (RAM and/or VRAM)
 RLAPI BoundingBox GetModelBoundingBox(Model model);                                         // Compute model bounding box limits (considers all meshes)
 
@@ -1519,8 +1561,10 @@ RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);
 RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
 RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);          // Draw a model wires (with texture if set)
 RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
+RLAPI void DrawModelPoints(Model model, Vector3 position, float scale, Color tint); // Draw a model as points
+RLAPI void DrawModelPointsEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model as points with extended parameters
 RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                   // Draw bounding box (wires)
-RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint);   // Draw a billboard texture
+RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float scale, Color tint);   // Draw a billboard texture
 RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
 RLAPI void DrawBillboardPro(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector3 up, Vector2 size, Vector2 origin, float rotation, Color tint); // Draw a billboard texture defined by source and rotation
 
@@ -1530,9 +1574,10 @@ RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize
 RLAPI void UnloadMesh(Mesh mesh);                                                           // Unload mesh data from CPU and GPU
 RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform);                        // Draw a 3d mesh with material and transform
 RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms
-RLAPI bool ExportMesh(Mesh mesh, const char *fileName);                                     // Export mesh data to file, returns true on success
 RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh);                                            // Compute mesh bounding box limits
 RLAPI void GenMeshTangents(Mesh *mesh);                                                     // Compute mesh tangents
+RLAPI bool ExportMesh(Mesh mesh, const char *fileName);                                     // Export mesh data to file, returns true on success
+RLAPI bool ExportMeshAsCode(Mesh mesh, const char *fileName);                               // Export mesh as code file (.h) defining multiple arrays of vertex attributes
 
 // Mesh generation functions
 RLAPI Mesh GenMeshPoly(int sides, float radius);                                            // Generate polygonal mesh
@@ -1550,14 +1595,15 @@ RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);
 // Material loading/unloading functions
 RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                    // Load materials from model file
 RLAPI Material LoadMaterialDefault(void);                                                   // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
-RLAPI bool IsMaterialReady(Material material);                                              // Check if a material is ready
+RLAPI bool IsMaterialValid(Material material);                                              // Check if a material is valid (shader assigned, map textures loaded in GPU)
 RLAPI void UnloadMaterial(Material material);                                               // Unload material from GPU memory (VRAM)
 RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);          // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
 RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh
 
 // Model animations loading/unloading functions
 RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount);            // Load model animations from file
-RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose
+RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose (CPU)
+RLAPI void UpdateModelAnimationBones(Model model, ModelAnimation anim, int frame);          // Update model animation mesh bone matrices (GPU skinning)
 RLAPI void UnloadModelAnimation(ModelAnimation anim);                                       // Unload animation data
 RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount);                // Unload animation array data
 RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim);                         // Check model animation skeleton match
@@ -1587,11 +1633,11 @@ RLAPI float GetMasterVolume(void);                                    // Get mas
 // Wave/Sound loading/unloading functions
 RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
 RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
-RLAPI bool IsWaveReady(Wave wave);                                    // Checks if wave data is ready
+RLAPI bool IsWaveValid(Wave wave);                                    // Checks if wave data is valid (data loaded and parameters)
 RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
 RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
 RLAPI Sound LoadSoundAlias(Sound source);                             // Create a new sound that shares the same sample data as the source sound, does not own the sound data
-RLAPI bool IsSoundReady(Sound sound);                                 // Checks if a sound is ready
+RLAPI bool IsSoundValid(Sound sound);                                 // Checks if a sound is valid (data loaded and buffers initialized)
 RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
 RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
 RLAPI void UnloadSound(Sound sound);                                  // Unload sound
@@ -1609,7 +1655,7 @@ RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set vol
 RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
 RLAPI void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (0.5 is center)
 RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
-RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
+RLAPI void WaveCrop(Wave *wave, int initFrame, int finalFrame);       // Crop a wave to defined frames range
 RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
 RLAPI float *LoadWaveSamples(Wave wave);                              // Load samples data from wave as a 32bit float data array
 RLAPI void UnloadWaveSamples(float *samples);                         // Unload samples data loaded with LoadWaveSamples()
@@ -1617,7 +1663,7 @@ RLAPI void UnloadWaveSamples(float *samples);                         // Unload
 // Music management functions
 RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
 RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
-RLAPI bool IsMusicReady(Music music);                                 // Checks if a music stream is ready
+RLAPI bool IsMusicValid(Music music);                                 // Checks if a music stream is valid (context and buffers initialized)
 RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
 RLAPI void PlayMusicStream(Music music);                              // Start music playing
 RLAPI bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
@@ -1634,7 +1680,7 @@ RLAPI float GetMusicTimePlayed(Music music);                          // Get cur
 
 // AudioStream management functions
 RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
-RLAPI bool IsAudioStreamReady(AudioStream stream);                    // Checks if an audio stream is ready
+RLAPI bool IsAudioStreamValid(AudioStream stream);                    // Checks if an audio stream is valid (buffers initialized)
 RLAPI void UnloadAudioStream(AudioStream stream);                     // Unload audio stream and free memory
 RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
 RLAPI bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
@@ -1649,10 +1695,10 @@ RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan
 RLAPI void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
 RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
 
-RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as <float>s
+RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as 'float'
 RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream
 
-RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as <float>s
+RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as 'float'
 RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline
 
 #if defined(__cplusplus)

include/raymath.h

@@ -1,6 +1,6 @@
 /**********************************************************************************************
 *
-*   raymath v1.5 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
+*   raymath v2.0 - Math functions to work with Vector2, Vector3, Matrix and Quaternions
 *
 *   CONVENTIONS:
 *     - Matrix structure is defined as row-major (memory layout) but parameters naming AND all
@@ -12,7 +12,7 @@
 *     - Functions are always self-contained, no function use another raymath function inside,
 *       required code is directly re-implemented inside
 *     - Functions input parameters are always received by value (2 unavoidable exceptions)
-*     - Functions use always a "result" variable for return
+*     - Functions use always a "result" variable for return (except C++ operators)
 *     - Functions are always defined inline
 *     - Angles are always in radians (DEG2RAD/RAD2DEG macros provided for convenience)
 *     - No compound literals used to make sure libray is compatible with C++
@@ -27,10 +27,12 @@
 *           Define static inline functions code, so #include header suffices for use.
 *           This may use up lots of memory.
 *
+*       #define RAYMATH_DISABLE_CPP_OPERATORS
+*           Disables C++ operator overloads for raymath types.
 *
 *   LICENSE: zlib/libpng
 *
-*   Copyright (c) 2015-2023 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2015-2024 Ramon Santamaria (@raysan5)
 *
 *   This software is provided "as-is", without any express or implied warranty. In no event
 *   will the authors be held liable for any damages arising from the use of this software.
@@ -59,7 +61,9 @@
 // Function specifiers definition
 #if defined(RAYMATH_IMPLEMENTATION)
     #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
-        #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll).
+        #define RMAPI __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll)
+    #elif defined(BUILD_LIBTYPE_SHARED)
+        #define RMAPI __attribute__((visibility("default"))) // We are building raylib as a Unix shared library (.so/.dylib)
     #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
         #define RMAPI __declspec(dllimport)         // We are using raylib as a Win32 shared library (.dll)
     #else
@@ -75,6 +79,7 @@
     #endif
 #endif
 
+
 //----------------------------------------------------------------------------------
 // Defines and Macros
 //----------------------------------------------------------------------------------
@@ -163,7 +168,7 @@ typedef struct float16 {
     float v[16];
 } float16;
 
-#include <math.h>       // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabs()
+#include <math.h>       // Required for: sinf(), cosf(), tan(), atan2f(), sqrtf(), floor(), fminf(), fmaxf(), fabsf()
 
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Utils math
@@ -429,6 +434,28 @@ RMAPI Vector2 Vector2Reflect(Vector2 v, Vector2 normal)
     return result;
 }
 
+// Get min value for each pair of components
+RMAPI Vector2 Vector2Min(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { 0 };
+
+    result.x = fminf(v1.x, v2.x);
+    result.y = fminf(v1.y, v2.y);
+
+    return result;
+}
+
+// Get max value for each pair of components
+RMAPI Vector2 Vector2Max(Vector2 v1, Vector2 v2)
+{
+    Vector2 result = { 0 };
+
+    result.x = fmaxf(v1.x, v2.x);
+    result.y = fmaxf(v1.y, v2.y);
+
+    return result;
+}
+
 // Rotate vector by angle
 RMAPI Vector2 Vector2Rotate(Vector2 v, float angle)
 {
@@ -492,18 +519,18 @@ RMAPI Vector2 Vector2ClampValue(Vector2 v, float min, float max)
     {
         length = sqrtf(length);
 
+        float scale = 1;    // By default, 1 as the neutral element.
         if (length < min)
         {
-            float scale = min/length;
+            scale = min/length;
-            result.x = v.x*scale;
-            result.y = v.y*scale;
         }
         else if (length > max)
         {
-            float scale = max/length;
+            scale = max/length;
-            result.x = v.x*scale;
-            result.y = v.y*scale;
         }
+
+        result.x = v.x*scale;
+        result.y = v.y*scale;
     }
 
     return result;
@@ -522,6 +549,31 @@ RMAPI int Vector2Equals(Vector2 p, Vector2 q)
     return result;
 }
 
+// Compute the direction of a refracted ray
+// v: normalized direction of the incoming ray
+// n: normalized normal vector of the interface of two optical media
+// r: ratio of the refractive index of the medium from where the ray comes
+//    to the refractive index of the medium on the other side of the surface
+RMAPI Vector2 Vector2Refract(Vector2 v, Vector2 n, float r)
+{
+    Vector2 result = { 0 };
+
+    float dot = v.x*n.x + v.y*n.y;
+    float d = 1.0f - r*r*(1.0f - dot*dot);
+
+    if (d >= 0.0f)
+    {
+        d = sqrtf(d);
+        v.x = r*v.x - (r*dot + d)*n.x;
+        v.y = r*v.y - (r*dot + d)*n.y;
+
+        result = v;
+    }
+
+    return result;
+}
+
+
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Vector3 math
 //----------------------------------------------------------------------------------
@@ -603,12 +655,12 @@ RMAPI Vector3 Vector3Perpendicular(Vector3 v)
 {
     Vector3 result = { 0 };
 
-    float min = (float) fabs(v.x);
+    float min = fabsf(v.x);
     Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
 
     if (fabsf(v.y) < min)
     {
-        min = (float) fabs(v.y);
+        min = fabsf(v.y);
         Vector3 tmp = {0.0f, 1.0f, 0.0f};
         cardinalAxis = tmp;
     }
@@ -832,7 +884,7 @@ RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle)
     // Vector3Normalize(axis);
     float length = sqrtf(axis.x*axis.x + axis.y*axis.y + axis.z*axis.z);
     if (length == 0.0f) length = 1.0f;
-    float ilength = 1.0f / length;
+    float ilength = 1.0f/length;
     axis.x *= ilength;
     axis.y *= ilength;
     axis.z *= ilength;
@@ -873,6 +925,27 @@ RMAPI Vector3 Vector3RotateByAxisAngle(Vector3 v, Vector3 axis, float angle)
     return result;
 }
 
+// Move Vector towards target
+RMAPI Vector3 Vector3MoveTowards(Vector3 v, Vector3 target, float maxDistance)
+{
+    Vector3 result = { 0 };
+
+    float dx = target.x - v.x;
+    float dy = target.y - v.y;
+    float dz = target.z - v.z;
+    float value = (dx*dx) + (dy*dy) + (dz*dz);
+
+    if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target;
+
+    float dist = sqrtf(value);
+
+    result.x = v.x + dx/dist*maxDistance;
+    result.y = v.y + dy/dist*maxDistance;
+    result.z = v.z + dz/dist*maxDistance;
+
+    return result;
+}
+
 // Calculate linear interpolation between two vectors
 RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
 {
@@ -885,6 +958,22 @@ RMAPI Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
     return result;
 }
 
+// Calculate cubic hermite interpolation between two vectors and their tangents
+// as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic
+RMAPI Vector3 Vector3CubicHermite(Vector3 v1, Vector3 tangent1, Vector3 v2, Vector3 tangent2, float amount)
+{
+    Vector3 result = { 0 };
+
+    float amountPow2 = amount*amount;
+    float amountPow3 = amount*amount*amount;
+
+    result.x = (2*amountPow3 - 3*amountPow2 + 1)*v1.x + (amountPow3 - 2*amountPow2 + amount)*tangent1.x + (-2*amountPow3 + 3*amountPow2)*v2.x + (amountPow3 - amountPow2)*tangent2.x;
+    result.y = (2*amountPow3 - 3*amountPow2 + 1)*v1.y + (amountPow3 - 2*amountPow2 + amount)*tangent1.y + (-2*amountPow3 + 3*amountPow2)*v2.y + (amountPow3 - amountPow2)*tangent2.y;
+    result.z = (2*amountPow3 - 3*amountPow2 + 1)*v1.z + (amountPow3 - 2*amountPow2 + amount)*tangent1.z + (-2*amountPow3 + 3*amountPow2)*v2.z + (amountPow3 - amountPow2)*tangent2.z;
+
+    return result;
+}
+
 // Calculate reflected vector to normal
 RMAPI Vector3 Vector3Reflect(Vector3 v, Vector3 normal)
 {
@@ -1078,20 +1167,19 @@ RMAPI Vector3 Vector3ClampValue(Vector3 v, float min, float max)
     {
         length = sqrtf(length);
 
+        float scale = 1;    // By default, 1 as the neutral element.
         if (length < min)
         {
-            float scale = min/length;
+            scale = min/length;
-            result.x = v.x*scale;
-            result.y = v.y*scale;
-            result.z = v.z*scale;
         }
         else if (length > max)
         {
-            float scale = max/length;
+            scale = max/length;
-            result.x = v.x*scale;
-            result.y = v.y*scale;
-            result.z = v.z*scale;
         }
+
+        result.x = v.x*scale;
+        result.y = v.y*scale;
+        result.z = v.z*scale;
     }
 
     return result;
@@ -1136,6 +1224,233 @@ RMAPI Vector3 Vector3Refract(Vector3 v, Vector3 n, float r)
     return result;
 }
 
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition - Vector4 math
+//----------------------------------------------------------------------------------
+
+RMAPI Vector4 Vector4Zero(void)
+{
+    Vector4 result = { 0.0f, 0.0f, 0.0f, 0.0f };
+    return result;
+}
+
+RMAPI Vector4 Vector4One(void)
+{
+    Vector4 result = { 1.0f, 1.0f, 1.0f, 1.0f };
+    return result;
+}
+
+RMAPI Vector4 Vector4Add(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = {
+        v1.x + v2.x,
+        v1.y + v2.y,
+        v1.z + v2.z,
+        v1.w + v2.w
+    };
+    return result;
+}
+
+RMAPI Vector4 Vector4AddValue(Vector4 v, float add)
+{
+    Vector4 result = {
+        v.x + add,
+        v.y + add,
+        v.z + add,
+        v.w + add
+    };
+    return result;
+}
+
+RMAPI Vector4 Vector4Subtract(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = {
+        v1.x - v2.x,
+        v1.y - v2.y,
+        v1.z - v2.z,
+        v1.w - v2.w
+    };
+    return result;
+}
+
+RMAPI Vector4 Vector4SubtractValue(Vector4 v, float add)
+{
+    Vector4 result = {
+        v.x - add,
+        v.y - add,
+        v.z - add,
+        v.w - add
+    };
+    return result;
+}
+
+RMAPI float Vector4Length(Vector4 v)
+{
+    float result = sqrtf((v.x*v.x) + (v.y*v.y) + (v.z*v.z) + (v.w*v.w));
+    return result;
+}
+
+RMAPI float Vector4LengthSqr(Vector4 v)
+{
+    float result = (v.x*v.x) + (v.y*v.y) + (v.z*v.z) + (v.w*v.w);
+    return result;
+}
+
+RMAPI float Vector4DotProduct(Vector4 v1, Vector4 v2)
+{
+    float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z + v1.w*v2.w);
+    return result;
+}
+
+// Calculate distance between two vectors
+RMAPI float Vector4Distance(Vector4 v1, Vector4 v2)
+{
+    float result = sqrtf(
+        (v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y) +
+        (v1.z - v2.z)*(v1.z - v2.z) + (v1.w - v2.w)*(v1.w - v2.w));
+    return result;
+}
+
+// Calculate square distance between two vectors
+RMAPI float Vector4DistanceSqr(Vector4 v1, Vector4 v2)
+{
+    float result =
+        (v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y) +
+        (v1.z - v2.z)*(v1.z - v2.z) + (v1.w - v2.w)*(v1.w - v2.w);
+
+    return result;
+}
+
+RMAPI Vector4 Vector4Scale(Vector4 v, float scale)
+{
+    Vector4 result = { v.x*scale, v.y*scale, v.z*scale, v.w*scale };
+    return result;
+}
+
+// Multiply vector by vector
+RMAPI Vector4 Vector4Multiply(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z, v1.w*v2.w };
+    return result;
+}
+
+// Negate vector
+RMAPI Vector4 Vector4Negate(Vector4 v)
+{
+    Vector4 result = { -v.x, -v.y, -v.z, -v.w };
+    return result;
+}
+
+// Divide vector by vector
+RMAPI Vector4 Vector4Divide(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z, v1.w/v2.w };
+    return result;
+}
+
+// Normalize provided vector
+RMAPI Vector4 Vector4Normalize(Vector4 v)
+{
+    Vector4 result = { 0 };
+    float length = sqrtf((v.x*v.x) + (v.y*v.y) + (v.z*v.z) + (v.w*v.w));
+
+    if (length > 0)
+    {
+        float ilength = 1.0f/length;
+        result.x = v.x*ilength;
+        result.y = v.y*ilength;
+        result.z = v.z*ilength;
+        result.w = v.w*ilength;
+    }
+
+    return result;
+}
+
+// Get min value for each pair of components
+RMAPI Vector4 Vector4Min(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = { 0 };
+
+    result.x = fminf(v1.x, v2.x);
+    result.y = fminf(v1.y, v2.y);
+    result.z = fminf(v1.z, v2.z);
+    result.w = fminf(v1.w, v2.w);
+
+    return result;
+}
+
+// Get max value for each pair of components
+RMAPI Vector4 Vector4Max(Vector4 v1, Vector4 v2)
+{
+    Vector4 result = { 0 };
+
+    result.x = fmaxf(v1.x, v2.x);
+    result.y = fmaxf(v1.y, v2.y);
+    result.z = fmaxf(v1.z, v2.z);
+    result.w = fmaxf(v1.w, v2.w);
+
+    return result;
+}
+
+// Calculate linear interpolation between two vectors
+RMAPI Vector4 Vector4Lerp(Vector4 v1, Vector4 v2, float amount)
+{
+    Vector4 result = { 0 };
+
+    result.x = v1.x + amount*(v2.x - v1.x);
+    result.y = v1.y + amount*(v2.y - v1.y);
+    result.z = v1.z + amount*(v2.z - v1.z);
+    result.w = v1.w + amount*(v2.w - v1.w);
+
+    return result;
+}
+
+// Move Vector towards target
+RMAPI Vector4 Vector4MoveTowards(Vector4 v, Vector4 target, float maxDistance)
+{
+    Vector4 result = { 0 };
+
+    float dx = target.x - v.x;
+    float dy = target.y - v.y;
+    float dz = target.z - v.z;
+    float dw = target.w - v.w;
+    float value = (dx*dx) + (dy*dy) + (dz*dz) + (dw*dw);
+
+    if ((value == 0) || ((maxDistance >= 0) && (value <= maxDistance*maxDistance))) return target;
+
+    float dist = sqrtf(value);
+
+    result.x = v.x + dx/dist*maxDistance;
+    result.y = v.y + dy/dist*maxDistance;
+    result.z = v.z + dz/dist*maxDistance;
+    result.w = v.w + dw/dist*maxDistance;
+
+    return result;
+}
+
+// Invert the given vector
+RMAPI Vector4 Vector4Invert(Vector4 v)
+{
+    Vector4 result = { 1.0f/v.x, 1.0f/v.y, 1.0f/v.z, 1.0f/v.w };
+    return result;
+}
+
+// Check whether two given vectors are almost equal
+RMAPI int Vector4Equals(Vector4 p, Vector4 q)
+{
+#if !defined(EPSILON)
+    #define EPSILON 0.000001f
+#endif
+
+    int result = ((fabsf(p.x - q.x)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.x), fabsf(q.x))))) &&
+                  ((fabsf(p.y - q.y)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.y), fabsf(q.y))))) &&
+                  ((fabsf(p.z - q.z)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.z), fabsf(q.z))))) &&
+                  ((fabsf(p.w - q.w)) <= (EPSILON*fmaxf(1.0f, fmaxf(fabsf(p.w), fabsf(q.w)))));
+    return result;
+}
+
+
 //----------------------------------------------------------------------------------
 // Module Functions Definition - Matrix math
 //----------------------------------------------------------------------------------
@@ -1524,32 +1839,32 @@ RMAPI Matrix MatrixScale(float x, float y, float z)
 }
 
 // Get perspective projection matrix
-RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far)
+RMAPI Matrix MatrixFrustum(double left, double right, double bottom, double top, double nearPlane, double farPlane)
 {
     Matrix result = { 0 };
 
     float rl = (float)(right - left);
     float tb = (float)(top - bottom);
-    float fn = (float)(far - near);
+    float fn = (float)(farPlane - nearPlane);
 
-    result.m0 = ((float)near*2.0f)/rl;
+    result.m0 = ((float)nearPlane*2.0f)/rl;
     result.m1 = 0.0f;
     result.m2 = 0.0f;
     result.m3 = 0.0f;
 
     result.m4 = 0.0f;
-    result.m5 = ((float)near*2.0f)/tb;
+    result.m5 = ((float)nearPlane*2.0f)/tb;
     result.m6 = 0.0f;
     result.m7 = 0.0f;
 
     result.m8 = ((float)right + (float)left)/rl;
     result.m9 = ((float)top + (float)bottom)/tb;
-    result.m10 = -((float)far + (float)near)/fn;
+    result.m10 = -((float)farPlane + (float)nearPlane)/fn;
     result.m11 = -1.0f;
 
     result.m12 = 0.0f;
     result.m13 = 0.0f;
-    result.m14 = -((float)far*(float)near*2.0f)/fn;
+    result.m14 = -((float)farPlane*(float)nearPlane*2.0f)/fn;
     result.m15 = 0.0f;
 
     return result;
@@ -1901,6 +2216,32 @@ RMAPI Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
     return result;
 }
 
+// Calculate quaternion cubic spline interpolation using Cubic Hermite Spline algorithm
+// as described in the GLTF 2.0 specification: https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#interpolation-cubic
+RMAPI Quaternion QuaternionCubicHermiteSpline(Quaternion q1, Quaternion outTangent1, Quaternion q2, Quaternion inTangent2, float t)
+{
+    float t2 = t*t;
+    float t3 = t2*t;
+    float h00 = 2*t3 - 3*t2 + 1;
+    float h10 = t3 - 2*t2 + t;
+    float h01 = -2*t3 + 3*t2;
+    float h11 = t3 - t2;
+
+    Quaternion p0 = QuaternionScale(q1, h00);
+    Quaternion m0 = QuaternionScale(outTangent1, h10);
+    Quaternion p1 = QuaternionScale(q2, h01);
+    Quaternion m1 = QuaternionScale(inTangent2, h11);
+
+    Quaternion result = { 0 };
+
+    result = QuaternionAdd(p0, m0);
+    result = QuaternionAdd(result, p1);
+    result = QuaternionAdd(result, m1);
+    result = QuaternionNormalize(result);
+
+    return result;
+}
+
 // Calculate quaternion based on the rotation from one vector to another
 RMAPI Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
 {
@@ -1960,7 +2301,7 @@ RMAPI Quaternion QuaternionFromMatrix(Matrix mat)
     }
 
     float biggestVal = sqrtf(fourBiggestSquaredMinus1 + 1.0f)*0.5f;
-    float mult = 0.25f / biggestVal;
+    float mult = 0.25f/biggestVal;
 
     switch (biggestIndex)
     {
@@ -2042,8 +2383,7 @@ RMAPI Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
         float ilength = 0.0f;
 
         // Vector3Normalize(axis)
-        Vector3 v = axis;
+        length = axisLength;
-        length = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
         if (length == 0.0f) length = 1.0f;
         ilength = 1.0f/length;
         axis.x *= ilength;
@@ -2187,4 +2527,415 @@ RMAPI int QuaternionEquals(Quaternion p, Quaternion q)
     return result;
 }
 
+// Decompose a transformation matrix into its rotational, translational and scaling components
+RMAPI void MatrixDecompose(Matrix mat, Vector3 *translation, Quaternion *rotation, Vector3 *scale)
+{
+    // Extract translation.
+    translation->x = mat.m12;
+    translation->y = mat.m13;
+    translation->z = mat.m14;
+
+    // Extract upper-left for determinant computation
+    const float a = mat.m0;
+    const float b = mat.m4;
+    const float c = mat.m8;
+    const float d = mat.m1;
+    const float e = mat.m5;
+    const float f = mat.m9;
+    const float g = mat.m2;
+    const float h = mat.m6;
+    const float i = mat.m10;
+    const float A = e*i - f*h;
+    const float B = f*g - d*i;
+    const float C = d*h - e*g;
+
+    // Extract scale
+    const float det = a*A + b*B + c*C;
+    Vector3 abc = { a, b, c };
+    Vector3 def = { d, e, f };
+    Vector3 ghi = { g, h, i };
+
+    float scalex = Vector3Length(abc);
+    float scaley = Vector3Length(def);
+    float scalez = Vector3Length(ghi);
+    Vector3 s = { scalex, scaley, scalez };
+
+    if (det < 0) s = Vector3Negate(s);
+
+    *scale = s;
+
+    // Remove scale from the matrix if it is not close to zero
+    Matrix clone = mat;
+    if (!FloatEquals(det, 0))
+    {
+        clone.m0 /= s.x;
+        clone.m4 /= s.x;
+        clone.m8 /= s.x;
+        clone.m1 /= s.y;
+        clone.m5 /= s.y;
+        clone.m9 /= s.y;
+        clone.m2 /= s.z;
+        clone.m6 /= s.z;
+        clone.m10 /= s.z;
+
+        // Extract rotation
+        *rotation = QuaternionFromMatrix(clone);
+    }
+    else
+    {
+        // Set to identity if close to zero
+        *rotation = QuaternionIdentity();
+    }
+}
+
+#if defined(__cplusplus) && !defined(RAYMATH_DISABLE_CPP_OPERATORS)
+
+// Optional C++ math operators
+//-------------------------------------------------------------------------------
+
+// Vector2 operators
+static constexpr Vector2 Vector2Zeros = { 0, 0 };
+static constexpr Vector2 Vector2Ones = { 1, 1 };
+static constexpr Vector2 Vector2UnitX = { 1, 0 };
+static constexpr Vector2 Vector2UnitY = { 0, 1 };
+
+inline Vector2 operator + (const Vector2& lhs, const Vector2& rhs)
+{
+    return Vector2Add(lhs, rhs);
+}
+
+inline const Vector2& operator += (Vector2& lhs, const Vector2& rhs)
+{
+    lhs = Vector2Add(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator - (const Vector2& lhs, const Vector2& rhs)
+{
+    return Vector2Subtract(lhs, rhs);
+}
+
+inline const Vector2& operator -= (Vector2& lhs, const Vector2& rhs)
+{
+    lhs = Vector2Subtract(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator * (const Vector2& lhs, const float& rhs)
+{
+    return Vector2Scale(lhs, rhs);
+}
+
+inline const Vector2& operator *= (Vector2& lhs, const float& rhs)
+{
+    lhs = Vector2Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator * (const Vector2& lhs, const Vector2& rhs)
+{
+    return Vector2Multiply(lhs, rhs);
+}
+
+inline const Vector2& operator *= (Vector2& lhs, const Vector2& rhs)
+{
+    lhs = Vector2Multiply(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator * (const Vector2& lhs, const Matrix& rhs)
+{
+    return Vector2Transform(lhs, rhs);
+}
+
+inline const Vector2& operator -= (Vector2& lhs, const Matrix& rhs)
+{
+    lhs = Vector2Transform(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator / (const Vector2& lhs, const float& rhs)
+{
+    return Vector2Scale(lhs, 1.0f / rhs);
+}
+
+inline const Vector2& operator /= (Vector2& lhs, const float& rhs)
+{
+    lhs = Vector2Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector2 operator / (const Vector2& lhs, const Vector2& rhs)
+{
+    return Vector2Divide(lhs, rhs);
+}
+
+inline const Vector2& operator /= (Vector2& lhs, const Vector2& rhs)
+{
+    lhs = Vector2Divide(lhs, rhs);
+    return lhs;
+}
+
+inline bool operator == (const Vector2& lhs, const Vector2& rhs)
+{
+    return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y);
+}
+
+inline bool operator != (const Vector2& lhs, const Vector2& rhs)
+{
+    return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y);
+}
+
+// Vector3 operators
+static constexpr Vector3 Vector3Zeros = { 0, 0, 0 };
+static constexpr Vector3 Vector3Ones = { 1, 1, 1 };
+static constexpr Vector3 Vector3UnitX = { 1, 0, 0 };
+static constexpr Vector3 Vector3UnitY = { 0, 1, 0 };
+static constexpr Vector3 Vector3UnitZ = { 0, 0, 1 };
+
+inline Vector3 operator + (const Vector3& lhs, const Vector3& rhs)
+{
+    return Vector3Add(lhs, rhs);
+}
+
+inline const Vector3& operator += (Vector3& lhs, const Vector3& rhs)
+{
+    lhs = Vector3Add(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator - (const Vector3& lhs, const Vector3& rhs)
+{
+    return Vector3Subtract(lhs, rhs);
+}
+
+inline const Vector3& operator -= (Vector3& lhs, const Vector3& rhs)
+{
+    lhs = Vector3Subtract(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator * (const Vector3& lhs, const float& rhs)
+{
+    return Vector3Scale(lhs, rhs);
+}
+
+inline const Vector3& operator *= (Vector3& lhs, const float& rhs)
+{
+    lhs = Vector3Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator * (const Vector3& lhs, const Vector3& rhs)
+{
+    return Vector3Multiply(lhs, rhs);
+}
+
+inline const Vector3& operator *= (Vector3& lhs, const Vector3& rhs)
+{
+    lhs = Vector3Multiply(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator * (const Vector3& lhs, const Matrix& rhs)
+{
+    return Vector3Transform(lhs, rhs);
+}
+
+inline const Vector3& operator -= (Vector3& lhs, const Matrix& rhs)
+{
+    lhs = Vector3Transform(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator / (const Vector3& lhs, const float& rhs)
+{
+    return Vector3Scale(lhs, 1.0f / rhs);
+}
+
+inline const Vector3& operator /= (Vector3& lhs, const float& rhs)
+{
+    lhs = Vector3Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector3 operator / (const Vector3& lhs, const Vector3& rhs)
+{
+    return Vector3Divide(lhs, rhs);
+}
+
+inline const Vector3& operator /= (Vector3& lhs, const Vector3& rhs)
+{
+    lhs = Vector3Divide(lhs, rhs);
+    return lhs;
+}
+
+inline bool operator == (const Vector3& lhs, const Vector3& rhs)
+{
+    return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z);
+}
+
+inline bool operator != (const Vector3& lhs, const Vector3& rhs)
+{
+    return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z);
+}
+
+// Vector4 operators
+static constexpr Vector4 Vector4Zeros = { 0, 0, 0, 0 };
+static constexpr Vector4 Vector4Ones = { 1, 1, 1, 1 };
+static constexpr Vector4 Vector4UnitX = { 1, 0, 0, 0 };
+static constexpr Vector4 Vector4UnitY = { 0, 1, 0, 0 };
+static constexpr Vector4 Vector4UnitZ = { 0, 0, 1, 0 };
+static constexpr Vector4 Vector4UnitW = { 0, 0, 0, 1 };
+
+inline Vector4 operator + (const Vector4& lhs, const Vector4& rhs)
+{
+    return Vector4Add(lhs, rhs);
+}
+
+inline const Vector4& operator += (Vector4& lhs, const Vector4& rhs)
+{
+    lhs = Vector4Add(lhs, rhs);
+    return lhs;
+}
+
+inline Vector4 operator - (const Vector4& lhs, const Vector4& rhs)
+{
+    return Vector4Subtract(lhs, rhs);
+}
+
+inline const Vector4& operator -= (Vector4& lhs, const Vector4& rhs)
+{
+    lhs = Vector4Subtract(lhs, rhs);
+    return lhs;
+}
+
+inline Vector4 operator * (const Vector4& lhs, const float& rhs)
+{
+    return Vector4Scale(lhs, rhs);
+}
+
+inline const Vector4& operator *= (Vector4& lhs, const float& rhs)
+{
+    lhs = Vector4Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector4 operator * (const Vector4& lhs, const Vector4& rhs)
+{
+    return Vector4Multiply(lhs, rhs);
+}
+
+inline const Vector4& operator *= (Vector4& lhs, const Vector4& rhs)
+{
+    lhs = Vector4Multiply(lhs, rhs);
+    return lhs;
+}
+
+inline Vector4 operator / (const Vector4& lhs, const float& rhs)
+{
+    return Vector4Scale(lhs, 1.0f / rhs);
+}
+
+inline const Vector4& operator /= (Vector4& lhs, const float& rhs)
+{
+    lhs = Vector4Scale(lhs, rhs);
+    return lhs;
+}
+
+inline Vector4 operator / (const Vector4& lhs, const Vector4& rhs)
+{
+    return Vector4Divide(lhs, rhs);
+}
+
+inline const Vector4& operator /= (Vector4& lhs, const Vector4& rhs)
+{
+    lhs = Vector4Divide(lhs, rhs);
+    return lhs;
+}
+
+inline bool operator == (const Vector4& lhs, const Vector4& rhs)
+{
+    return FloatEquals(lhs.x, rhs.x) && FloatEquals(lhs.y, rhs.y) && FloatEquals(lhs.z, rhs.z) && FloatEquals(lhs.w, rhs.w);
+}
+
+inline bool operator != (const Vector4& lhs, const Vector4& rhs)
+{
+    return !FloatEquals(lhs.x, rhs.x) || !FloatEquals(lhs.y, rhs.y) || !FloatEquals(lhs.z, rhs.z) || !FloatEquals(lhs.w, rhs.w);
+}
+
+// Quaternion operators
+static constexpr Quaternion QuaternionZeros = { 0, 0, 0, 0 };
+static constexpr Quaternion QuaternionOnes = { 1, 1, 1, 1 };
+static constexpr Quaternion QuaternionUnitX = { 0, 0, 0, 1 };
+
+inline Quaternion operator + (const Quaternion& lhs, const float& rhs)
+{
+    return QuaternionAddValue(lhs, rhs);
+}
+
+inline const Quaternion& operator += (Quaternion& lhs, const float& rhs)
+{
+    lhs = QuaternionAddValue(lhs, rhs);
+    return lhs;
+}
+
+inline Quaternion operator - (const Quaternion& lhs, const float& rhs)
+{
+    return QuaternionSubtractValue(lhs, rhs);
+}
+
+inline const Quaternion& operator -= (Quaternion& lhs, const float& rhs)
+{
+    lhs = QuaternionSubtractValue(lhs, rhs);
+    return lhs;
+}
+
+inline Quaternion operator * (const Quaternion& lhs, const Matrix& rhs)
+{
+    return QuaternionTransform(lhs, rhs);
+}
+
+inline const Quaternion& operator *= (Quaternion& lhs, const Matrix& rhs)
+{
+    lhs = QuaternionTransform(lhs, rhs);
+    return lhs;
+}
+
+// Matrix operators
+inline Matrix operator + (const Matrix& lhs, const Matrix& rhs)
+{
+    return MatrixAdd(lhs, rhs);
+}
+
+inline const Matrix& operator += (Matrix& lhs, const Matrix& rhs)
+{
+    lhs = MatrixAdd(lhs, rhs);
+    return lhs;
+}
+
+inline Matrix operator - (const Matrix& lhs, const Matrix& rhs)
+{
+    return MatrixSubtract(lhs, rhs);
+}
+
+inline const Matrix& operator -= (Matrix& lhs, const Matrix& rhs)
+{
+    lhs = MatrixSubtract(lhs, rhs);
+    return lhs;
+}
+
+inline Matrix operator * (const Matrix& lhs, const Matrix& rhs)
+{
+    return MatrixMultiply(lhs, rhs);
+}
+
+inline const Matrix& operator *= (Matrix& lhs, const Matrix& rhs)
+{
+    lhs = MatrixMultiply(lhs, rhs);
+    return lhs;
+}
+//-------------------------------------------------------------------------------
+#endif  // C++ operators
+
 #endif  // RAYMATH_H

lib.h

@@ -1,7 +1,11 @@
 #pragma once
-#include <stdint.h>
+#include <cstdint>
-#include <stddef.h>
+#include <cstddef>
 #include "include/raylib.h"
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+#include "include/raymath.h"
+#pragma GCC diagnostic pop
 
 typedef uint8_t   u8;
 typedef uint16_t  u16;
@@ -13,7 +17,6 @@ typedef float     f32;
 typedef double    f64;
 typedef uintptr_t uptr;
 typedef char      sbyte;
-typedef ptrdiff_t size;
 typedef size_t    usize;
 
 typedef Vector2 Point;
@@ -33,36 +36,29 @@ typedef union {
     Rectangle rect;
 } RectU;
 
-#define OPTION(type, typeName)                  \
-    struct {                                    \
-        enum {NONE, SOME} tag;                  \
-        union {                                 \
-            u8 none;                            \
-            type typeName;                      \
-        } some;                                 \
-    }
 
-typedef OPTION(Point, point) PointOption;
+extern "C" {
-
+    void D_DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);
-void D_DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);
+    void D_DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint);
-void D_DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint);
+    void D_DrawTextureV(Texture2D texture, Vector2 position, Color tint);
-void D_DrawTextureV(Texture2D texture, Vector2 position, Color tint);
+}
 
 #ifdef ENNIX_LIB_IMPLEMENTATION
 extern bool global_debug_mode;
 inline void D_DrawTextureV(Texture2D texture, Vector2 position, Color tint) {
     DrawTextureV(texture, position, tint);
-#ifdef DEBUG_MODE_ENABLED
+#ifdef DEBUG
     if (global_debug_mode) {
-        Rectangle debug = {position.x,position.y,texture.width,texture.height};
+        Rectangle debug = {position.x,position.y,(f32)texture.width,(f32)texture.height};
         DrawRectangleLinesEx(debug, 1.0f, RED);
     }
 #endif
 }
 
+
 inline void D_DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint) {
     DrawTextureRec(texture, source, position, tint);
-#ifdef DEBUG_MODE_ENABLED
+#ifdef DEBUG
     if (global_debug_mode) {
         Rectangle debug = {position.x,position.y,source.width,source.height};
         DrawRectangleLinesEx(debug, 1.0f, RED);
@@ -72,7 +68,7 @@ inline void D_DrawTextureRec(Texture2D texture, Rectangle source, Vector2 positi
 
 inline void D_DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint) {
     DrawTexturePro(texture, source, dest, origin, rotation, tint);
-#ifdef DEBUG_MODE_ENABLED
+#ifdef DEBUG
     if (global_debug_mode) {
         Rectangle debug = {dest.x-origin.x,dest.y-origin.y,dest.width,dest.height};
         DrawRectangleLinesEx(debug, 1.0f, RED);

lisp-version/ECL-INSTALL

@@ -2,6 +2,104 @@ You will find detailed installation instructions in the ECL manual
        https://common-lisp.net/project/ecl/static/manual/Building-ECL.html
 If you do not have access to the online version, follow the following recipies.
 
+* Cross-compile for the WASM platform (via emscripten)
+
+Emscripten target is a little fickle so keep in mind that:
+
+- shared libraries are supported but come with some drawbacks (e.g.
+  increased code size if used together with -sASYNCIFY), therefore the
+  build instructions default to disable-shared
+
+- disable-tcp is needed, because accept can't be found (lack of
+  -lsockets or something in this spirit?)
+
+- select for interactive streams does not work, because reading operations are
+  blocking (as they should be!), so there is no EOF returned -- clear-input will
+  hang without a proper file-cnt
+
+- to build emscripten you need to use their SDK that provides the toolchain, and
+  set the environment variable EMSDK_PATH
+
+- for the garbage collector to be able to identify roots on the stack,
+  you need to pass the -sBINARYEN_EXTRA_PASSES=--spill-pointers option
+  to the linker for all of your code that might store pointer on the
+  stack (for instance when embedding ECL)
+
+- the optimization level -O0 is used because higher optimization
+  levels seem to interfere with the binaryen options needed to get the
+  garbage collector to work correctly and tend slow down the program
+  (might be worth experimenting with the optimization options)
+
+1. Build the host ECL
+
+#+begin_src shell-script
+  ./configure ABI=32 CFLAGS="-m32 -g -O2 -DECL_C_COMPATIBLE_VARIADIC_DISPATCH" LDFLAGS="-m32 -g -O2" \
+              --prefix=`pwd`/ecl-emscripten-host --disable-threads
+
+  make -j16 && make install
+  rm -rf build/
+#+end_src
+
+2. Configure the toolchain
+
+Install the Emscripten SDK using the official instructions:
+
+        https://emscripten.org/docs/getting_started/downloads.html
+
+These build instructions were tested against ~emsdk 3.1.41~. If things doesn't
+work try that version instead of ~latest~.
+
+After that activate the toolchain and configure build flags:
+
+#+begin_src shell-script
+  source ${EMSDK_PATH}/emsdk_env.sh
+  export ECL_TO_RUN=`pwd`/ecl-emscripten-host/bin/ecl
+  # You may customize various emscripten flags here, i.e:
+  # export LDFLAGS="-sASYNCIFY=1"
+#+end_src
+
+3. Build the core environment and install it
+
+#+begin_src shell-script
+  emconfigure ./configure \
+              --host=wasm32-unknown-emscripten \
+              --build=x86_64-pc-linux-gnu \
+              --with-cross-config=`pwd`/src/util/wasm32-unknown-emscripten.cross_config \
+              --prefix=`pwd`/ecl-emscripten \
+              --disable-shared \
+              --with-tcp=no \
+              --with-cmp=no
+
+  emmake make && emmake make install
+
+  # some files need to be copied manually
+  cp build/bin/ecl.js build/bin/ecl.wasm ecl-emscripten/
+#+end_src
+
+4. ECL may be hosted on a web page. Assuming that you have quicklisp installed:
+
+#+begin_src shell-script
+  export WEBSERVER=`pwd`/src/util/webserver.lisp
+  pushd ecl-emscripten/
+  lisp --load $WEBSERVER
+  # After the server is loaded run:
+  # firefox localhost:8888/ecl.html
+  popd
+#+end_src
+
+If the output does not show on the webpage then open the javascript console.
+This is a default html website produced by emscripten.
+
+5. Build an external program linked against libecl.a
+
+The default stack size proposed by emscripten is 64KB. This is too little for
+ECL, so when you build a program that is linked against libecl.a, then it is
+imoprtant to specify a different size. For example:
+
+#+begin_src shell-script
+  emcc program.c -sSTACK_SIZE=1048576 lib/*.a -I./include -o program.o
+#+end_src
+
 * Unix and similar platforms.
 1. Type
    ./configure --help
@@ -111,104 +209,6 @@ Hint provided by Pascal J. Bourguignon.
 4. Library and assets in the ecl-iOS directory are ready to run on
    the iOS system.
 
-* Cross-compile for the WASM platform (via emscripten)
-
-Emscripten target is a little fickle so keep in mind that:
-
-- shared libraries are supported but come with some drawbacks (e.g.
-  increased code size if used together with -sASYNCIFY), therefore the
-  build instructions default to disable-shared
-
-- disable-tcp is needed, because accept can't be found (lack of
-  -lsockets or something in this spirit?)
-
-- select for interactive streams does not work, because reading operations are
-  blocking (as they should be!), so there is no EOF returned -- clear-input will
-  hang without a proper file-cnt
-
-- to build emscripten you need to use their SDK that provides the toolchain, and
-  set the environment variable EMSDK_PATH
-
-- for the garbage collector to be able to identify roots on the stack,
-  you need to pass the -sBINARYEN_EXTRA_PASSES=--spill-pointers option
-  to the linker for all of your code that might store pointer on the
-  stack (for instance when embedding ECL)
-
-- the optimization level -O0 is used because higher optimization
-  levels seem to interfere with the binaryen options needed to get the
-  garbage collector to work correctly and tend slow down the program
-  (might be worth experimenting with the optimization options)
-
-1. Build the host ECL
-
-#+begin_src shell-script
-  ./configure ABI=32 CFLAGS="-m32 -g -O2 -DECL_C_COMPATIBLE_VARIADIC_DISPATCH" LDFLAGS="-m32 -g -O2" \
-              --prefix=`pwd`/ecl-emscripten-host --disable-threads
-
-  make -j16 && make install
-  rm -rf build/
-#+end_src
-
-2. Configure the toolchain
-
-Install the Emscripten SDK using the official instructions:
-
-        https://emscripten.org/docs/getting_started/downloads.html
-
-These build instructions were tested against ~emsdk 3.1.41~. If things doesn't
-work try that version instead of ~latest~.
-
-After that activate the toolchain and configure build flags:
-
-#+begin_src shell-script
-  source ${EMSDK_PATH}/emsdk_env.sh
-  export ECL_TO_RUN=`pwd`/ecl-emscripten-host/bin/ecl
-  # You may customize various emscripten flags here, i.e:
-  # export LDFLAGS="-sASYNCIFY=1"
-#+end_src
-
-3. Build the core environment and install it
-
-#+begin_src shell-script
-  emconfigure ./configure \
-              --host=wasm32-unknown-emscripten \
-              --build=x86_64-pc-linux-gnu \
-              --with-cross-config=`pwd`/src/util/wasm32-unknown-emscripten.cross_config \
-              --prefix=`pwd`/ecl-emscripten \
-              --disable-shared \
-              --with-tcp=no \
-              --with-cmp=no
-
-  emmake make && emmake make install
-
-  # some files need to be copied manually
-  cp build/bin/ecl.js build/bin/ecl.wasm ecl-emscripten/
-#+end_src
-
-4. ECL may be hosted on a web page. Assuming that you have quicklisp installed:
-
-#+begin_src shell-script
-  export WEBSERVER=`pwd`/src/util/webserver.lisp
-  pushd ecl-emscripten/
-  lisp --load $WEBSERVER
-  # After the server is loaded run:
-  # firefox localhost:8888/ecl.html
-  popd
-#+end_src
-
-If the output does not show on the webpage then open the javascript console.
-This is a default html website produced by emscripten.
-
-5. Build an external program linked against libecl.a
-
-The default stack size proposed by emscripten is 64KB. This is too little for
-ECL, so when you build a program that is linked against libecl.a, then it is
-imoprtant to specify a different size. For example:
-
-#+begin_src shell-script
-  emcc program.c -sSTACK_SIZE=1048576 lib/*.a -I./include -o program.o
-#+end_src
-
 * Build using Cosmopolitan toolchain (experimental)
 
 Binaries built with cosmopolitan toolchain can be executed on numerous platforms

lisp-version/game.lisp

@@ -1,5 +1,5 @@
 (eval-when (:compile-toplevel :load-toplevel :execute)
-  (load "~/.local/share/quicklisp/setup.lisp")
+  ;; (load "~/.local/share/quicklisp/setup.lisp")
   (ql:quickload :cl-raylib)
   (ql:quickload :livesupport))
 
@@ -10,6 +10,39 @@
 (in-package :raylib-user)
 
 (defparameter *move-speed* 5.0)
+(defparameter *tower-pos* (vec 80 150))
+(defparameter *tower-center* (vec 64 220))
+(defparameter *assets-path* "~/Development/tinyswords/assets/")
+(defparameter *camera* (rl:make-camera2d :offset (vec 0 0) :target (vec 0 0) :rotation 0.0 :zoom 1.0))
+
+(defparameter *mouse-drag-start-pos* (vec 0 0))
+(defparameter *camera-drag-start-pos* (vec 0 0))
+(defparameter *unit-select-drag-start-pos* (vec 0 0))
+(defparameter *camera-dragging?* nil)
+(defparameter *unit-select-dragging?* nil)
+(defparameter *selection-rect* (rl:make-rectangle :x 0.0 :y 0.0 :width 0.0 :height 0.0))
+
+(defparameter *selected-units* (make-array 64 :adjustable t :fill-pointer 0))
+
+(defparameter *game-state* nil)
+(defparameter *textures* (make-hash-table))
+
+(defmacro rsetf (rect &key x y width height)
+  "Set rectangle fields using keywords"
+  `(progn
+     ,@(when x `((setf (raylib:rectangle-x ,rect) ,x)))
+     ,@(when y `((setf (raylib:rectangle-y ,rect) ,y)))
+     ,@(when width `((setf (raylib:rectangle-width ,rect) ,width)))
+     ,@(when height `((setf (raylib:rectangle-height ,rect) ,height)))))
+
+(defun set-selection-rect ()
+  (let* ((start-x (vx *mouse-drag-start-pos*))
+         (start-y (vy *mouse-drag-start-pos*))
+         (end-x (rl:get-mouse-x))
+         (end-y (rl:get-mouse-y))
+         (x (min start-x end-x))
+         (y (min start-y end-y)))
+    (rsetf *selection-rect* :x x :y y :width (abs (- end-x start-x)) :height (abs (- end-y start-y)))))
 
 (defclass health ()
   ((current-amount :initform 100.0 :accessor current-amount)
@@ -29,6 +62,7 @@
 (defclass soldier ()
   ((pos :initarg :pos :initform (vec 0 0) :accessor pos)
    (anim-state :initform 0 :accessor anim-state)
+   (entity-type :initarg :entity-type :initform nil :accessor entity-type)
    (sprite :initarg :sprite :initform (make-instance 'sprite-class) :accessor sprite)
    (velocity :initform (vec 0 0) :accessor velocity)
    (health :initarg :health :initform (make-instance 'health) :accessor health)))
@@ -36,6 +70,7 @@
 (defparameter *knight*
   (make-instance
    'soldier
+   :entity-type ':soldier
    :pos (vec 270 360)
    :sprite (make-instance
             'sprite-class
@@ -46,6 +81,7 @@
 (defparameter *archer*
   (make-instance
    'soldier
+   :entity-type :archer
    :pos (vec 145.0 253.0)
    :sprite (make-instance
             'sprite-class
@@ -53,6 +89,17 @@
             :src-rect (rl:make-rectangle :x 0.0 :y 0.0 :width 192.0 :height 192.0)
             :origin (vec 95.0 128.0))))
 
+(defparameter *goblin*
+  (make-instance
+   'soldier
+   :entity-type :goblin
+   :pos (vec 445.0 300.0)
+   :sprite (make-instance
+            'sprite-class
+            :texture-key 'goblin
+            :src-rect (rl:make-rectangle :x 0.0 :y 0.0 :width 192.0 :height 192.0)
+            :origin (vec 95.0 128.0))))
+
 (defun deal-damage (obj damage)
   (with-accessors ((h health)) obj
     (setf h (- h damage))))
@@ -63,26 +110,44 @@
   ((click-pos :initform nil :accessor click-pos)
    (entities :initform '() :accessor entities)))
 
-(defparameter *game-state* nil)
-(defparameter *textures* (make-hash-table))
-
 (defun bind-texture (key path)
-  (setf (gethash key *textures*) (rl:load-texture (uiop:native-namestring path))))
+  (setf (gethash key *textures*) (rl:load-texture (uiop:native-namestring (merge-pathnames path *assets-path*)))))
 
 (defun game-init ()
   (setf *game-state* (make-instance 'game-state))
-  (setf (entities *game-state*) (list *knight* *archer*))
+  (setf (entities *game-state*) (list *knight* *archer* *goblin*))
   ;; (add-component (knight *game-state*) (make-instance 'transform))
-  (bind-texture 'terrain "~/Development/tinyswords/assets/Terrain/Ground/Tilemap_Flat.png")
+  (bind-texture 'terrain "Terrain/Ground/Tilemap_Flat.png")
-  (bind-texture 'knight "~/Development/tinyswords/assets/Factions/Knights/Troops/Warrior/Blue/Warrior_Blue.png")
+  (bind-texture 'knight  "Factions/Knights/Troops/Warrior/Blue/Warrior_Blue.png")
-  (bind-texture 'archer "~/Development/tinyswords/assets/Factions/Knights/Troops/Archer/Blue/Archer_Blue.png")
+  (bind-texture 'archer  "Factions/Knights/Troops/Archer/Blue/Archer_Blue.png")
-  (bind-texture 'tower "~/Development/tinyswords/assets/Factions/Knights/Buildings/Tower/Tower_Blue.png"))
+  (bind-texture 'tower   "Factions/Knights/Buildings/Tower/Tower_Blue.png")
+  (bind-texture 'goblin  "Factions/Goblins/Troops/Torch/Red/Torch_Red.png"))
 
 (defun game-input ()
   (when (rl:is-mouse-button-pressed 0)
-    (setf (click-pos *game-state*) (print (rl:get-mouse-position))))
+    (if (rl:is-key-down :key-left-control)
-  (when (rl:is-mouse-button-pressed 1)
+        (progn
-    (setf (click-pos *game-state*) (print (rl:get-mouse-position)))))
+          (setf *camera-dragging?* t)
+          (v<- *camera-drag-start-pos* (rl:camera2d-target *camera*)))
+        (progn
+          (setf *unit-select-dragging?* t)
+          (v<- *unit-select-drag-start-pos* (rl:camera2d-target *camera*))))
+    (v<- *mouse-drag-start-pos* (rl:get-mouse-position)))
+  ;; (princ (rl:get-mouse-wheel-move))
+  (setf (rl:camera2d-zoom *camera*)
+          (alexandria:clamp (exp (+ (log (rl:camera2d-zoom *camera*))
+                                    (* (rl:get-mouse-wheel-move) 0.1)))
+                            1.0 2.0))
+  (when (rl:is-mouse-button-released 0)
+    (setf *camera-dragging?* nil)
+    (setf *unit-select-dragging?* nil))
+  (when (rl:is-key-down :key-r) (setf (rl:camera2d-target *camera*) (vec 0 0))))
+
+;; (defun game-input ()
+;;   (when (rl:is-mouse-button-pressed 0)
+;;     (setf (click-pos *game-state*) (print (rl:get-mouse-position))))
+;;   (when (rl:is-mouse-button-pressed 1)
+;;     (setf (click-pos *game-state*) (print (rl:get-mouse-position)))))
 ;; (with-slots ((pos archer-pos) (kpos knight-pos)) *game-state*
 ;; (let ((dx 0.0) (dy 0.0))
 ;;   (when (rl:is-key-down :key-right) (incf dx 1))
@@ -91,7 +156,26 @@
 ;;   (when (rl:is-key-down :key-down)  (incf dy 1))
 ;;   (setf pos (v+ pos (v* (vunit* (vec dx dy)) *move-speed*))))))
 
+(defun goblin-fsm ()
+  (dolist (entity (entities *game-state*))
+    (when (eq (entity-type entity) :goblin)
+      (let* ((target-dist (v- (v+ *tower-pos* *tower-center*) (pos entity)))
+             (dir (vunit* target-dist)))
+        (setf (anim-idx (sprite entity)) 1)
+        (setf (pos entity) (v+ (pos entity) (v* dir 1)))))))
+
+(defun calculate-camera-drag ()
+  (let* ((target-pos (v- (rl:get-mouse-position)
+                         *mouse-drag-start-pos*)))
+    (setf (rl:camera2d-target *camera*) (v+ *camera-drag-start-pos* (v* -1 target-pos)))))
+
 (defun game-update ()
+  (when *camera-dragging?*
+    (calculate-camera-drag))
+  (when *unit-select-dragging?*
+    (setf (fill-pointer *selected-units*) 0)
+    (set-selection-rect)
+    (vector-push-extend *knight* *selected-units* ))
   (with-accessors ((click-pos click-pos)) *game-state*
     (when click-pos
       (with-accessors ((kpos pos)) *knight*
@@ -103,10 +187,11 @@
                 (setf kpos click-pos)
                 ;; (setf (velocity *knight*) (vec 0 0))
                 (setf click-pos nil))
-              (let ((vel (v* (* (rl:get-frame-time) 150.0) (vunit* dist))))
+              (let ((vel (v* (* (rl:get-frame-time) 240.0) (vunit* dist))))
                 (setf (anim-idx (sprite *knight*)) 1)
                 (setf (velocity *knight*) vel)
                 (setf kpos (v+ kpos vel))))))))
+  (goblin-fsm)
   (dolist (entity (entities *game-state*))
     (tick-sprite-animation (sprite entity) (< (vx (velocity entity)) 0.0))))
 
@@ -159,20 +244,24 @@
 
 (defun game-draw ()
   (rl:clear-background (rl:make-rgba 71 171 169 1))
-  (draw-ground)
+  (rl:with-mode-2d (*camera*)
-  (rl:draw-texture-v (gethash 'tower *textures*) (vec 80 150) :white)
+    (draw-ground)
-  (dolist (entity (entities *game-state*))
+    (rl:draw-texture-v (gethash 'tower *textures*) *tower-pos* :white)
-    (draw-sprite (sprite entity) (pos entity)))
+    (dolist (entity (entities *game-state*))
+      (draw-sprite (sprite entity) (pos entity))))
+  (when *unit-select-dragging?*
+    (rl:draw-rectangle-lines-ex *selection-rect* 2.0 :raywhite))
   (rl:draw-fps 10 10))
 
 (defun game ()
-  (let* ((screen-width 900)
+  (let* ((screen-width 1600)
-         (screen-height 500))
+         (screen-height 900))
     (rl:with-window (screen-width screen-height "RTS")
-      (rl:set-target-fps 240)
+      (rl:set-target-fps 60)
       (game-init)
       (loop :until (rl:window-should-close)
-            :do (livesupport:continuable (game-input)
+            :do (livesupport:continuable
+                 (game-input)
                  (game-update)
                  (rl:with-drawing
                    (game-draw))))

lsan.supp

@@ -0,0 +1,3 @@
+# One-time GLFW/X11/GL driver init allocations reached via InitWindow.
+# Never freed by design; not owned by this codebase.
+leak:_glfwCreateWindowX11

main.cpp

@@ -0,0 +1,83 @@
+#include <cstdlib>
+#include <dlfcn.h>
+#include <sys/stat.h>
+#include <cstdio>
+
+#include "game.h"
+
+struct GameApi {
+    GameState *(*init)();
+    GameState *(*init_state)();
+    void (*step) (GameState *state);
+    void (*cleanup) (GameState *state);
+    bool (*window_should_close)();
+};
+
+struct Game {
+    time_t last_write_time;
+    void *gamelib_handle;
+    ino_t gamelib_id;
+    GameApi api;
+    GameState *state;
+};
+
+time_t get_file_write_time(const char* path) {
+    struct stat file_stat;
+    if (stat(path, &file_stat) == 0) {
+        return file_stat.st_mtime;
+    }
+    return 0;
+}
+
+bool load_game_api(Game* game) {
+    const char* lib_path = "./game.so";
+    time_t write_time = get_file_write_time(lib_path);
+    
+    if (write_time <= game->last_write_time) {
+        return false;
+    }
+    
+    void *gamelib_handle = dlopen(lib_path, RTLD_NOW);
+    if (!gamelib_handle) {
+        printf("Failed to load game.so: %s\n", dlerror());
+        return false;
+    }
+
+    if (game->gamelib_handle) {
+        dlclose(game->gamelib_handle);
+    }
+    game->gamelib_handle = gamelib_handle;
+    
+    game->api.init = (GameState*(*)())dlsym(game->gamelib_handle, "game_init");
+    game->api.init_state = (GameState*(*)())dlsym(game->gamelib_handle, "game_init_state");
+    game->api.step = (void(*)(GameState*))dlsym(game->gamelib_handle, "game_step");
+    game->api.cleanup = (void(*)(GameState*))dlsym(game->gamelib_handle, "game_cleanup");
+    game->api.window_should_close = (bool(*)())dlsym(game->gamelib_handle, "window_should_close");
+    
+    game->last_write_time = write_time;
+    printf("Reloaded game.so\n");
+    return true;
+}
+
+int main(void) {
+    Game game = {};
+
+    load_game_api(&game);
+
+    game.state = game.api.init();
+    while (!game.api.window_should_close()) {
+        // game.frame_count++;
+        // float dt = GetFrameTime();
+        load_game_api(&game);
+
+        if (game.state->should_reset) {
+            delete game.state;
+            game.state = game.api.init_state();
+        }
+
+        game.api.step(game.state);
+    }
+
+    game.api.cleanup(game.state);
+    return 0;
+}

sprites.h

@@ -1,12 +1,34 @@
-#include "sprites.h"
+// sprites.h
+#pragma once
+
+#include "lib.h"
 #include "include/raylib.h"
 
+struct SpriteAnimation {
+    u8 loop;
+    u8 total_frames;
+};
+
+struct SpriteAnimationPlayback {
+    f32 time_elapsed;
+    u8 row;
+    u8 total_frames;
+    u8 current_frame;
+    u8 loop;
+    u8 finished;
+};
+
+void PlayAnimation(int animation, SpriteAnimation *anims, SpriteAnimationPlayback *playback);
+void TickSpriteAnimations(SpriteAnimationPlayback *playbacks, int len);
+bool IsAnimationFinished(SpriteAnimationPlayback playback);
+
 inline void PlayAnimation(int animation, SpriteAnimation *anims, SpriteAnimationPlayback *playback) {
     playback->time_elapsed = 0.0f;
     playback->current_frame = 0;
     playback->row = animation;
     playback->total_frames = anims[animation].total_frames;
     playback->loop = anims[animation].loop;
+    playback->finished = false;
 }
 
 void TickSpriteAnimations(SpriteAnimationPlayback *playbacks, int len) {
@@ -21,11 +43,12 @@ void TickSpriteAnimations(SpriteAnimationPlayback *playbacks, int len) {
                 if (playback->loop) {
                     playback->current_frame = 0;
                 }
+                playback->finished = true;
             }
         }
     }
 }
 
 inline bool IsAnimationFinished(SpriteAnimationPlayback playback) {
-    return playback.current_frame == playback.total_frames;
+    return playback.finished;
 }