so://phie

diff --git a/Makefile b/Makefile
new file mode 100644
index 0000000..8cf6357
--- /dev/null
+++ b/Makefile

   1@@ -0,0 +1,5 @@
   2+build:
   3+	cc -o freezo -I/opt/homebrew/Cellar/raylib/5.0/include -L/opt/homebrew/Cellar/raylib/5.0/lib -lraylib -rdynamic -Wall -Wextra -Werror -pedantic src/*.c
   4+
   5+run: build
   6+	./freezo
   7
   8

diff --git a/README.md b/README.md
new file mode 100644
index 0000000..db4602b
--- /dev/null
+++ b/README.md

   1@@ -0,0 +1,3 @@
   2+# freezo
   3+
   4+A retro platform game
   5
   6

diff --git a/assets/entities.png b/assets/entities.png
new file mode 100644
index 0000000..c2f29cb
Binary files /dev/null and b/assets/entities.png differ

diff --git a/assets/font.png b/assets/font.png
new file mode 100644
index 0000000..54771d8
Binary files /dev/null and b/assets/font.png differ

diff --git a/assets/images.png b/assets/images.png
new file mode 100644
index 0000000..0286fa0
Binary files /dev/null and b/assets/images.png differ

diff --git a/assets/tiles.png b/assets/tiles.png
new file mode 100644
index 0000000..412b610
Binary files /dev/null and b/assets/tiles.png differ

diff --git a/src/const.h b/src/const.h
new file mode 100644
index 0000000..51e62ba
--- /dev/null
+++ b/src/const.h

   1@@ -0,0 +1,14 @@
   2+#define SCALE 3
   3+#define TILE_WIDTH 8 * SCALE
   4+#define TILE_HEIGHT 8 * SCALE
   5+#define WINDOW_WIDTH 24 * TILE_WIDTH
   6+#define WINDOW_HEIGHT 16 * TILE_HEIGHT
   7+#define PLAYER_WIDTH 8 * SCALE
   8+#define PLAYER_HEIGHT 12 *SCALE
   9+#define ENEMY_WIDTH 8 * SCALE
  10+#define ENEMY_HEIGHT 12 * SCALE
  11+#define PLAYER_HEALTH 6
  12+#define PLAYER_SHOOTING_RANGE 2 * TILE_WIDTH
  13+#define PLAYER_GRAVITY 10
  14+#define FONT_WIDTH 5 * (SCALE - 1)
  15+#define FONT_HEIGHT 7 * (SCALE - 1)
  16
  17

diff --git a/src/effect.c b/src/effect.c
new file mode 100644
index 0000000..c87fec6
--- /dev/null
+++ b/src/effect.c

   1@@ -0,0 +1,73 @@
   2+#include <stdlib.h>
   3+
   4+#include "effect.h"
   5+#include "util.h"
   6+#include "const.h"
   7+
   8+effect_t *effect_create(pos_t pos, effect_e type) {
   9+  effect_t *effect = malloc(sizeof(effect_t));
  10+  effect->type = type;
  11+  effect->pos = pos;
  12+  switch (type) {
  13+    case EFFECT_FALL:
  14+      effect->timer = timer_create(7, 3);
  15+      break;
  16+    case EFFECT_BREAK:
  17+      effect->timer = timer_create(10, 3);
  18+      break;
  19+    case EFFECT_PARTICLE:
  20+      effect->timer = timer_create(14, 4);
  21+      break;
  22+  }
  23+  effect->count = 0;
  24+  return effect;
  25+}
  26+
  27+void effect_update(effect_t *effect, game_t *game) {
  28+  timer_update(effect->timer);
  29+  if (timer_check(effect->timer)) {
  30+    effect->count++;
  31+  }
  32+  // remove effect after one iteration
  33+  if (effect->count > 0) {
  34+    for (int i = 0; i < game->effects_len; i++) {
  35+      if (game->effects[i] == effect) {
  36+        if (i + 1 < game->effects_len) {
  37+          for (int j = i; j < game->effects_len - 1; j++) {
  38+            game->effects[j] = game->effects[j + 1];
  39+          }
  40+        }
  41+        game->effects_len--;
  42+        game->effects = realloc(game->effects, sizeof(effect_t) * game->effects_len);
  43+        break;
  44+      }
  45+    }
  46+  }
  47+}
  48+
  49+void effect_draw(effect_t *effect, game_t *game) {
  50+  int x;
  51+  switch (effect->type) {
  52+    case EFFECT_FALL:
  53+      x = 1;
  54+      break;
  55+    case EFFECT_BREAK:
  56+      x = 0;
  57+      break;
  58+    case EFFECT_PARTICLE:
  59+      x = 3;
  60+      break;
  61+  }
  62+  int frame = timer_get(effect->timer);
  63+  DrawTextureRec(game->assets.entities, texture_rect(frame, x, PLAYER_WIDTH, PLAYER_HEIGHT), pos_snap(effect->pos), WHITE);
  64+}
  65+
  66+void effect_free(effect_t *effect) {
  67+  free(effect);
  68+}
  69+
  70+void effect_play(pos_t pos, effect_e type, game_t *game) {
  71+  game->effects = realloc(game->effects, sizeof(effect_t) * (game->effects_len + 1));
  72+  game->effects[game->effects_len] = effect_create(pos, type);
  73+  game->effects_len++;
  74+}
  75
  76

diff --git a/src/effect.h b/src/effect.h
new file mode 100644
index 0000000..e37b19a
--- /dev/null
+++ b/src/effect.h

   1@@ -0,0 +1,26 @@
   2+#pragma once
   3+
   4+typedef struct Effect effect_t;
   5+
   6+#include "game.h"
   7+#include "util.h"
   8+
   9+typedef enum {
  10+  EFFECT_FALL,
  11+  EFFECT_BREAK,
  12+  EFFECT_PARTICLE,
  13+} effect_e;
  14+
  15+struct Effect {
  16+  effect_e type;
  17+  pos_t pos;
  18+  timer_t *timer;
  19+  int count;
  20+};
  21+
  22+effect_t *effect_create(pos_t pos, effect_e type);
  23+void effect_update(effect_t *effect, game_t *game);
  24+void effect_draw(effect_t *effect, game_t *game);
  25+void effect_free(effect_t *effect);
  26+
  27+void effect_play(pos_t pos, effect_e type, game_t *game);
  28
  29

diff --git a/src/enemy.c b/src/enemy.c
new file mode 100644
index 0000000..466e1e4
--- /dev/null
+++ b/src/enemy.c

   1@@ -0,0 +1,224 @@
   2+#include <stdlib.h>
   3+#include <math.h>
   4+
   5+#include "enemy.h"
   6+#include "const.h"
   7+#include "entity.h"
   8+#include "effect.h"
   9+
  10+enemy_t *enemy_create(pos_t pos, enemy_e type) {
  11+  enemy_t *enemy = malloc(sizeof(enemy_t));
  12+  enemy->pos = pos;
  13+  enemy->type = type;
  14+  enemy->on_ground = false;
  15+  enemy->velocity = 0.0;
  16+  enemy->gravity = 0.0;
  17+  enemy->dir = 1;
  18+  enemy->stunned = false;
  19+  enemy->frozen = false;
  20+  enemy->frozen_timer = 0;
  21+  enemy->fall_height = 0.0;
  22+  enemy->timer_walking = timer_create(9, 8);
  23+  enemy->timer_sneaking = timer_create(9, 16);
  24+  return enemy;
  25+}
  26+
  27+void enemy_update(enemy_t *enemy, game_t *game) {
  28+  enemy->stunned = false;
  29+  bool on_ground = false;
  30+  // not beeing held
  31+  if (game->player->held_enemy != enemy) {
  32+    // detect on ground
  33+    if (!(enemy->velocity > 0.0)) {
  34+      for (int i = 0; i < game->tiles_len; i++) {
  35+        tile_t *tile = game->tiles[i];
  36+        if (tile_ground(tile)) {
  37+          if (
  38+            enemy->pos.x + PLAYER_WIDTH > tile->pos.x &&
  39+            enemy->pos.x < tile->pos.x + TILE_WIDTH
  40+          ) {
  41+            float tolerance = 4.0;
  42+            if (enemy->gravity > tolerance) {
  43+              tolerance = enemy->gravity;
  44+            }
  45+            if (fabs(enemy->pos.y + PLAYER_HEIGHT - tile->pos.y) < tolerance) {
  46+              enemy->pos.y = tile->pos.y - PLAYER_HEIGHT;
  47+              on_ground = true;
  48+              if (enemy->fall_height >= 2 * TILE_HEIGHT) {
  49+                effect_play(enemy->pos, EFFECT_BREAK, game);
  50+                effect_play(enemy->pos, EFFECT_PARTICLE, game);
  51+                enemy_kill(enemy, game);
  52+              }
  53+            }
  54+          }
  55+        }
  56+      }
  57+    }
  58+    enemy->on_ground = on_ground;
  59+    if (enemy->on_ground) {
  60+      enemy->gravity = 0.0;
  61+      enemy->fall_height = 0.0;
  62+    }
  63+    else {
  64+      enemy->pos.y += enemy->gravity;
  65+      enemy->fall_height += enemy->gravity;
  66+      if (enemy->gravity < PLAYER_GRAVITY) {
  67+        enemy->gravity += 0.2;
  68+      }
  69+      else {
  70+        enemy->gravity = PLAYER_GRAVITY;
  71+      }
  72+    }
  73+    // handle shooting
  74+    if (
  75+      game->player->shooting &&
  76+      game->player->target_entity != NULL &&
  77+      game->player->target_entity->type == ENTITY_ENEMY &&
  78+      game->player->target_entity->enemy == enemy
  79+    ) {
  80+      if (enemy->frozen) {
  81+        if (game->player->dir > 0) {
  82+          enemy->pos.x += 2.0;
  83+        }
  84+        else {
  85+          enemy->pos.x -= 2.0;
  86+        }
  87+      }
  88+      else {
  89+        enemy->stunned = true;
  90+      }
  91+    }
  92+  }
  93+  // handle freezing
  94+  if (!enemy->frozen) {
  95+    if (enemy->stunned) {
  96+      if (enemy->frozen_timer >= 100) {
  97+        enemy->frozen = true;
  98+        enemy->frozen_timer = 0;
  99+      }
 100+      enemy->frozen_timer++;
 101+    }
 102+    else if (enemy->frozen_timer > 0) {
 103+      enemy->frozen_timer--;
 104+    }
 105+  }
 106+  else {
 107+    if (enemy->frozen_timer >= 1500) {
 108+      enemy->frozen = false;
 109+      enemy->frozen_timer = 0;
 110+      if (game->player->held_enemy == enemy) {
 111+        game->player->held_enemy = NULL;
 112+      }
 113+    }
 114+    enemy->frozen_timer++;
 115+  }
 116+  // handle movement
 117+  tile_t *next_ground_tile = tile_get(game, enemy->pos.x + ENEMY_WIDTH / 2.0 + enemy->dir * ENEMY_WIDTH / 2.0, enemy->pos.y + ENEMY_HEIGHT + 1);
 118+  if (!enemy->frozen) {
 119+    if (enemy->on_ground && (next_ground_tile == NULL || next_ground_tile->type == TILE_AIR)) {
 120+      enemy->dir = -enemy->dir;
 121+    }
 122+    if (enemy->stunned) {
 123+      enemy->pos.x += enemy->dir * 0.1;
 124+    }
 125+    else {
 126+      enemy->pos.x += enemy->dir * 0.5;
 127+    }
 128+  }
 129+  // detect wall
 130+  for (int i = 0; i < game->tiles_len; i++) {
 131+    tile_t *tile = game->tiles[i];
 132+    if (tile_wall(tile)) {
 133+      if (
 134+        enemy->pos.y + ENEMY_HEIGHT > tile->pos.y &&
 135+        enemy->pos.y < tile->pos.y + TILE_HEIGHT
 136+      ) {
 137+        float tolerance = 4.0;
 138+        if (enemy->dir > 0) {
 139+          if (fabs((enemy->pos.x + ENEMY_WIDTH - 0.4 * TILE_WIDTH) - tile->pos.x) < tolerance) {
 140+            enemy->dir = -enemy->dir;
 141+          }
 142+        }
 143+        else {
 144+          if (fabs((enemy->pos.x + 0.4 * TILE_WIDTH) - (tile->pos.x + TILE_WIDTH)) < tolerance) {
 145+            enemy->dir = -enemy->dir;
 146+          }
 147+        }
 148+      }
 149+    }
 150+  }
 151+  // fall out of map
 152+  if (enemy->pos.y > TILE_HEIGHT * game->level->height) {
 153+    pos_t pos = { enemy->pos.x, enemy->pos.y - ENEMY_HEIGHT + ENEMY_HEIGHT / 3.0 };
 154+    effect_play(pos, EFFECT_PARTICLE, game);
 155+    enemy_kill(enemy, game);
 156+  }
 157+  // update timer
 158+  if (enemy->on_ground && !enemy->frozen) {
 159+    timer_update(enemy->timer_walking);
 160+    timer_update(enemy->timer_sneaking);
 161+  }
 162+  else {
 163+    timer_reset(enemy->timer_walking);
 164+    timer_reset(enemy->timer_sneaking);
 165+  }
 166+}
 167+
 168+void enemy_draw(enemy_t *enemy, game_t *game) {
 169+  pos_t pos = pos_snap(enemy->pos);
 170+  int frame_walking = timer_get(enemy->timer_walking);
 171+  int frame_sneaking = timer_get(enemy->timer_sneaking);
 172+  if (enemy->dir > 0) {
 173+    DrawTextureRec(game->assets.entities, texture_rect(enemy->stunned ? frame_sneaking : frame_walking, 8, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 174+  }
 175+  else {
 176+    DrawTextureRec(game->assets.entities, texture_rect(enemy->stunned ? frame_sneaking : frame_walking, 9, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 177+  }
 178+  if (enemy->frozen) {
 179+    if (enemy->frozen_timer <= 1200) {
 180+      DrawTextureRec(game->assets.entities, texture_rect(3, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 181+    }
 182+    else if (enemy->frozen_timer <= 1350) {
 183+      DrawTextureRec(game->assets.entities, texture_rect(4, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 184+    }
 185+    else if (enemy->frozen_timer <= 1450) {
 186+      DrawTextureRec(game->assets.entities, texture_rect(5, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 187+    }
 188+    else {
 189+      DrawTextureRec(game->assets.entities, texture_rect(6, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 190+    }
 191+  }
 192+  else if (enemy->stunned) {
 193+    if (enemy->frozen_timer <= 33) {
 194+      DrawTextureRec(game->assets.entities, texture_rect(0, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 195+    }
 196+    else if (enemy->frozen_timer <= 66) {
 197+      DrawTextureRec(game->assets.entities, texture_rect(1, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 198+    }
 199+    else {
 200+      DrawTextureRec(game->assets.entities, texture_rect(2, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
 201+    }
 202+  }
 203+}
 204+
 205+void enemy_kill(enemy_t *enemy, game_t *game) {
 206+  for (int i = 0; i < game->entities_len; i++) {
 207+    if (game->entities[i].type == ENTITY_ENEMY && game->entities[i].enemy == enemy) {
 208+      if (i + 1 < game->entities_len) {
 209+        for (int j = i; j < game->entities_len - 1; j++) {
 210+          game->entities[j] = game->entities[j + 1];
 211+        }
 212+      }
 213+      game->entities_len--;
 214+      game->entities = realloc(game->entities, sizeof(entity_t) * game->entities_len);
 215+      game->xp += 10;
 216+      break;
 217+    }
 218+  }
 219+}
 220+
 221+void enemy_free(enemy_t *enemy) {
 222+  timer_free(enemy->timer_walking);
 223+  timer_free(enemy->timer_sneaking);
 224+  free(enemy);
 225+}
 226
 227

diff --git a/src/enemy.h b/src/enemy.h
new file mode 100644
index 0000000..657bd44
--- /dev/null
+++ b/src/enemy.h

   1@@ -0,0 +1,31 @@
   2+#pragma once
   3+
   4+typedef struct Enemy enemy_t;
   5+
   6+#include "game.h"
   7+#include "util.h"
   8+
   9+typedef enum {
  10+  ENEMY_TEST,
  11+} enemy_e;
  12+
  13+struct Enemy {
  14+  pos_t pos;
  15+  enemy_e type;
  16+  bool on_ground;
  17+  float velocity;
  18+  float gravity;
  19+  int dir;
  20+  bool stunned;
  21+  bool frozen;
  22+  int frozen_timer;
  23+  float fall_height;
  24+  timer_t *timer_walking;
  25+  timer_t *timer_sneaking;
  26+};
  27+
  28+enemy_t *enemy_create(pos_t pos, enemy_e type);
  29+void enemy_update(enemy_t *enemy, game_t *game);
  30+void enemy_draw(enemy_t *enemy, game_t *game);
  31+void enemy_kill(enemy_t *enemy, game_t *game);
  32+void enemy_free(enemy_t *enemy);
  33
  34

diff --git a/src/entity.c b/src/entity.c
new file mode 100644
index 0000000..a1d9ba2
--- /dev/null
+++ b/src/entity.c

   1@@ -0,0 +1,48 @@
   2+#include <stdlib.h>
   3+
   4+#include "entity.h"
   5+#include "enemy.h"
   6+#include "gate.h"
   7+
   8+entity_t *entity_create(entity_e type) {
   9+ entity_t *entity = malloc(sizeof(entity_t));
  10+  entity->type = type;
  11+  return entity;
  12+}
  13+
  14+void entity_update(entity_t *entity, game_t *game) {
  15+  switch (entity->type) {
  16+    case ENTITY_ENEMY:
  17+      enemy_update(entity->enemy, game);
  18+      break;
  19+    case ENTITY_GATE:
  20+      gate_update(entity->gate, game);
  21+      break;
  22+  }
  23+}
  24+
  25+void entity_draw(entity_t *entity, game_t *game) {
  26+  switch (entity->type) {
  27+    case ENTITY_ENEMY:
  28+      enemy_draw(entity->enemy, game);
  29+      break;
  30+    case ENTITY_GATE:
  31+      gate_draw(entity->gate, game);
  32+      break;
  33+  }
  34+}
  35+
  36+void entity_detach(entity_t *entity) {
  37+  switch (entity->type) {
  38+    case ENTITY_ENEMY:
  39+      enemy_free(entity->enemy);
  40+      break;
  41+    case ENTITY_GATE:
  42+      gate_free(entity->gate);
  43+      break;
  44+  }
  45+}
  46+
  47+void entity_free(entity_t *entity) {
  48+  free(entity);
  49+}
  50
  51

diff --git a/src/entity.h b/src/entity.h
new file mode 100644
index 0000000..0524eee
--- /dev/null
+++ b/src/entity.h

   1@@ -0,0 +1,26 @@
   2+#pragma once
   3+
   4+typedef struct Entity entity_t;
   5+
   6+#include "enemy.h"
   7+#include "gate.h"
   8+#include "game.h"
   9+
  10+typedef enum {
  11+  ENTITY_ENEMY,
  12+  ENTITY_GATE,
  13+} entity_e;
  14+
  15+struct Entity {
  16+  entity_e type;
  17+  union {
  18+    enemy_t *enemy;
  19+    gate_t *gate;
  20+  };
  21+};
  22+
  23+entity_t *entity_create(entity_e type);
  24+void entity_update(entity_t *entity, game_t *game);
  25+void entity_draw(entity_t *entity, game_t *game);
  26+void entity_detach(entity_t *entity);
  27+void entity_free(entity_t *entity);
  28
  29

diff --git a/src/game.c b/src/game.c
new file mode 100644
index 0000000..11f1b44
--- /dev/null
+++ b/src/game.c

   1@@ -0,0 +1,206 @@
   2+#include <stdio.h>
   3+#include <stdlib.h>
   4+#include <string.h>
   5+
   6+#include "libs/raylib.h"
   7+#include "entity.h"
   8+#include "game.h"
   9+#include "tile.h"
  10+#include "util.h"
  11+#include "player.h"
  12+#include "const.h"
  13+#include "level.h"
  14+
  15+game_t *game_create(void) {
  16+  game_t *game = malloc(sizeof(game_t));
  17+  game->state = STATE_GAME;
  18+  game->level = NULL,
  19+  game->quit = false;
  20+  game->defeat = false;
  21+  game->victory = false;
  22+  game->menu = menu_create();
  23+  game->player = NULL;
  24+  game->tiles = NULL;
  25+  game->tiles_len = 0;
  26+  game->entities = NULL;
  27+  game->entities_len = 0;
  28+  game->effects = NULL;
  29+  game->effects_len = 0;
  30+  game->assets.tiles = texture_load("assets/tiles.png", SCALE);
  31+  game->assets.entities = texture_load("assets/entities.png", SCALE);
  32+  game->assets.font = texture_load("assets/font.png", SCALE - 1);
  33+  game->assets.images = texture_load("assets/images.png", SCALE);
  34+  game->camera = (Camera2D) {
  35+    .offset = (pos_t) { 0.0, 0.0 },
  36+    .zoom = 1,
  37+  };
  38+  game->xp = 0;
  39+  game->sceen_timer = 0;
  40+  level_load(game, LEVEL_1);
  41+  return game;
  42+}
  43+
  44+void game_update(game_t *game) {
  45+  switch (game->state) {
  46+    case STATE_MENU: {
  47+      menu_update(game->menu, game);
  48+      break;
  49+    }
  50+    case STATE_GAME: {
  51+      if (IsKeyPressed(KEY_ESCAPE)) {
  52+        game->state = STATE_MENU;
  53+        game->menu->idx = 0;
  54+      }
  55+      if (game->level != NULL) {
  56+        // defeat
  57+        if (game->defeat) {
  58+          if (game->sceen_timer == 100) {
  59+            level_unload(game);
  60+            level_load(game, LEVEL_1);
  61+            game->defeat = false;
  62+            game->xp = 0;
  63+            game->sceen_timer = 0;
  64+          }
  65+          else {
  66+            game->sceen_timer++;
  67+          }
  68+        }
  69+        // victory
  70+        int enemies_len = 0;
  71+        bool gates_frozen = true;
  72+        for (int i = 0; i < game->entities_len; i++) {
  73+          if(game->entities[i].type == ENTITY_ENEMY) {
  74+            enemies_len++;
  75+          }
  76+          if(game->entities[i].type == ENTITY_GATE) {
  77+            if (!game->entities[i].gate->frozen) {
  78+              gates_frozen = false;
  79+            }
  80+          }
  81+        }
  82+        if (enemies_len == 0 && gates_frozen) {
  83+          game->victory = true;
  84+          if (game->victory) {
  85+            if (game->sceen_timer == 100) {
  86+              if (game->level->type < LEVELS) {
  87+                level_e level = game->level->type;
  88+                level++;
  89+                level_unload(game);
  90+                level_load(game, level);
  91+              }
  92+              game->victory = false;
  93+              game->sceen_timer = 0;
  94+            }
  95+            else {
  96+              game->sceen_timer++;
  97+            }
  98+          }
  99+        }
 100+        if (!game->victory && !game->defeat) {
 101+          player_update(game->player, game);
 102+        }
 103+        for (int i = 0; i < game->tiles_len; i++) {
 104+          tile_update(game->tiles[i], game);
 105+        }
 106+        for (int i = 0; i < game->entities_len; i++) {
 107+          int len = game->entities_len;
 108+          entity_update(&game->entities[i], game);
 109+          // check if entity was removed
 110+          if (game->entities_len < len) {
 111+            i--;
 112+          }
 113+        }
 114+        for (int i = 0; i < game->effects_len; i++) {
 115+          int len = game->effects_len;
 116+          effect_update(game->effects[i], game);
 117+          // check if enemy was removed
 118+          if (game->effects_len < len) {
 119+            i--;
 120+          }
 121+        }
 122+        pos_t camera_pos = (pos_t) {
 123+          .x = WINDOW_WIDTH / 2.0 - game->player->pos.x - PLAYER_WIDTH / 2.0,
 124+          .y = WINDOW_HEIGHT / 2.0 - game->player->pos.y,
 125+        };
 126+        if (camera_pos.x > 0.0) {
 127+          camera_pos.x = 0.0;
 128+        }
 129+        if (camera_pos.x + TILE_WIDTH * game->level->width < WINDOW_WIDTH) {
 130+          camera_pos.x = WINDOW_WIDTH - TILE_WIDTH * game->level->width;
 131+        }
 132+        if (camera_pos.y > 0.0) {
 133+          camera_pos.y = 0.0;
 134+        }
 135+        if (camera_pos.y + TILE_HEIGHT * game->level->height < WINDOW_HEIGHT) {
 136+          camera_pos.y = WINDOW_HEIGHT - TILE_HEIGHT * game->level->height;
 137+        }
 138+        game->camera.offset = pos_snap(camera_pos);
 139+      }
 140+      break;
 141+    }
 142+  }
 143+}
 144+
 145+void game_draw(game_t *game) {
 146+  BeginDrawing();
 147+  ClearBackground(BLACK);
 148+  if (game->level != LEVEL_NULL) {
 149+    BeginMode2D(game->camera);
 150+    for (int i = 0; i < game->tiles_len; i++) {
 151+      tile_draw(game->tiles[i], game);
 152+    }
 153+    for (int i = 0; i < game->entities_len; i++) {
 154+      entity_draw(&game->entities[i], game);
 155+    }
 156+    player_draw(game->player, game);
 157+    for (int i = 0; i < game->effects_len; i++) {
 158+      effect_draw(game->effects[i], game);
 159+    }
 160+    EndMode2D();
 161+    // draw interface
 162+    int i = 0;
 163+    for (i = 0; i < game->player->health / 2; i++) {
 164+      DrawTextureRec(game->assets.tiles, texture_rect(0, 1, TILE_WIDTH, TILE_HEIGHT), (pos_t) { TILE_WIDTH / 2.0 + i * (TILE_WIDTH + TILE_WIDTH / 4.0), TILE_WIDTH / 2.0 }, WHITE);
 165+    }
 166+    if (game->player->health % 2 != 0) {
 167+      DrawTextureRec(game->assets.tiles, texture_rect(1, 1, TILE_WIDTH, TILE_HEIGHT), (pos_t) { TILE_WIDTH / 2.0 + i * (TILE_WIDTH + TILE_WIDTH / 4.0), TILE_WIDTH / 2.0 }, WHITE);
 168+      i++;
 169+    }
 170+    for (; i < PLAYER_HEALTH / 2; i++) {
 171+      DrawTextureRec(game->assets.tiles, texture_rect(2, 1, TILE_WIDTH, TILE_HEIGHT), (pos_t) { TILE_WIDTH / 2.0 + i * (TILE_WIDTH + TILE_WIDTH / 4.0), TILE_WIDTH / 2.0 }, WHITE);
 172+    }
 173+    char xp_text[10];
 174+    snprintf(xp_text, 10, "%dXP", game->xp);
 175+    pos_t xp_pos = (pos_t) {
 176+      .x = WINDOW_WIDTH - TILE_WIDTH / 2.0,
 177+      .y = TILE_WIDTH / 1.5,
 178+    };
 179+    text_draw(xp_pos, xp_text, TEXT_ALIGNMENT_RIGHT, game);
 180+    char level_text[10];
 181+    snprintf(level_text, 10, "L%d", game->level->type);
 182+    pos_t level_pos = (pos_t) {
 183+      .x = WINDOW_WIDTH - TILE_WIDTH / 2.0,
 184+      .y = TILE_WIDTH / 1.5 + 25,
 185+    };
 186+    text_draw(level_pos, level_text, TEXT_ALIGNMENT_RIGHT, game);
 187+    if (game->defeat || game->victory) {
 188+      DrawRectangle(0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, (Color) { 0, 0, 0, 255 / 100 * game->sceen_timer });
 189+    }
 190+  }
 191+  if (game->state == STATE_MENU) {
 192+    menu_draw(game->menu, game);
 193+  }
 194+  EndDrawing();
 195+}
 196+
 197+void game_free(game_t *game) {
 198+  menu_free(game->menu);
 199+  if (game->level != LEVEL_NULL) {
 200+    level_unload(game);
 201+  }
 202+  UnloadTexture(game->assets.tiles);
 203+  UnloadTexture(game->assets.entities);
 204+  UnloadTexture(game->assets.font);
 205+  UnloadTexture(game->assets.images);
 206+  free(game);
 207+}
 208
 209

diff --git a/src/game.h b/src/game.h
new file mode 100644
index 0000000..cb8e14b
--- /dev/null
+++ b/src/game.h

   1@@ -0,0 +1,48 @@
   2+#pragma once
   3+
   4+typedef struct Assets assets_t;
   5+typedef struct Game game_t;
   6+
   7+#include "entity.h"
   8+#include "player.h"
   9+#include "tile.h"
  10+#include "menu.h"
  11+#include "level.h"
  12+#include "effect.h"
  13+
  14+typedef enum {
  15+  STATE_MENU,
  16+  STATE_GAME,
  17+} state_e;
  18+
  19+struct Assets {
  20+  Texture2D tiles;
  21+  Texture2D entities;
  22+  Texture2D font;
  23+  Texture2D images;
  24+};
  25+
  26+struct Game {
  27+  state_e state;
  28+  level_t *level;
  29+  bool quit;
  30+  bool defeat;
  31+  bool victory;
  32+  menu_t *menu;
  33+  player_t *player;
  34+  tile_t **tiles;
  35+  int tiles_len;
  36+  entity_t *entities;
  37+  int entities_len;
  38+  effect_t **effects;
  39+  int effects_len;
  40+  assets_t assets;
  41+  Camera2D camera;
  42+  int xp;
  43+  int sceen_timer;
  44+};
  45+
  46+game_t *game_create(void);
  47+void game_update(game_t *game);
  48+void game_draw(game_t *game);
  49+void game_free(game_t *game);
  50
  51

diff --git a/src/gate.c b/src/gate.c
new file mode 100644
index 0000000..53dac9b
--- /dev/null
+++ b/src/gate.c

   1@@ -0,0 +1,99 @@
   2+#include <stdlib.h>
   3+
   4+#include "entity.h"
   5+#include "gate.h"
   6+#include "const.h"
   7+
   8+gate_t *gate_create(pos_t pos, int enemy_max, int time) {
   9+  gate_t *gate = malloc(sizeof(gate_t));
  10+  gate->pos = pos;
  11+  gate->enemy_max = enemy_max;
  12+  gate->timer_spawn = timer_create(1, time);
  13+  gate->frozen = false;
  14+  gate->frozen_timer = 0;
  15+  return gate;
  16+}
  17+
  18+void gate_update(gate_t *gate, game_t *game) {
  19+  if (!gate->frozen) {
  20+    bool stunned = false;
  21+    if (
  22+      game->player->shooting &&
  23+      game->player->target_entity != NULL &&
  24+      game->player->target_entity->type == ENTITY_GATE &&
  25+      game->player->target_entity->gate == gate
  26+    ) {
  27+      if (gate->frozen) {
  28+        if (game->player->dir > 0) {
  29+          gate->pos.x += 2.0;
  30+        }
  31+        else {
  32+          gate->pos.x -= 2.0;
  33+        }
  34+      }
  35+      else {
  36+        stunned = true;
  37+      }
  38+    }
  39+    // handle freezing
  40+    if (stunned) {
  41+      if (gate->frozen_timer >= 300) {
  42+        gate->frozen = true;
  43+        gate->frozen_timer = 0;
  44+      }
  45+      gate->frozen_timer++;
  46+    }
  47+    else if (gate->frozen_timer > 0) {
  48+      gate->frozen_timer--;
  49+    }
  50+    // handle spawning
  51+    timer_update(gate->timer_spawn);
  52+    int enemies_len = 0;
  53+    for (int i = 0; i < game->entities_len; i++) {
  54+      if(game->entities[i].type == ENTITY_ENEMY) {
  55+        enemies_len++;
  56+      }
  57+    }
  58+    if (timer_check(gate->timer_spawn) && enemies_len < gate->enemy_max) {
  59+      game->entities = realloc(game->entities, sizeof(entity_t) * (game->entities_len + 1));
  60+      enemy_t *enemy = enemy_create((pos_t) {
  61+        .x = gate->pos.x + (TILE_WIDTH - ENEMY_WIDTH) / 2.0,
  62+        .y = gate->pos.y + TILE_HEIGHT - ENEMY_HEIGHT,
  63+      }, ENEMY_TEST);
  64+      enemy->dir = (rand() & 1) ? 1 : -1;
  65+      game->entities[game->entities_len] = (entity_t) {
  66+        .type = ENTITY_ENEMY,
  67+        .enemy = enemy,
  68+      };
  69+      game->entities_len++;
  70+    }
  71+  }
  72+}
  73+
  74+void gate_draw(gate_t *gate, game_t *game) {
  75+  DrawTextureRec(game->assets.tiles, texture_rect(0, 2, TILE_WIDTH, TILE_HEIGHT), (pos_t) { gate->pos.x, gate->pos.y - TILE_HEIGHT }, WHITE);
  76+  DrawTextureRec(game->assets.tiles, texture_rect(0, 3, TILE_WIDTH, TILE_HEIGHT), gate->pos, WHITE);
  77+  pos_t pos = pos_snap((pos_t) {
  78+    .x = gate->pos.x,
  79+    .y = gate->pos.y - (ENEMY_HEIGHT - TILE_HEIGHT),
  80+  });
  81+  if (gate->frozen) {
  82+    DrawTextureRec(game->assets.entities, texture_rect(3, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
  83+  }
  84+  if (!gate->frozen && gate->frozen_timer > 0) {
  85+    if (gate->frozen_timer <= 100) {
  86+      DrawTextureRec(game->assets.entities, texture_rect(0, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
  87+    }
  88+    else if (gate->frozen_timer <= 200) {
  89+      DrawTextureRec(game->assets.entities, texture_rect(1, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
  90+    }
  91+    else {
  92+      DrawTextureRec(game->assets.entities, texture_rect(2, 2, PLAYER_WIDTH, PLAYER_HEIGHT), pos, WHITE);
  93+    }
  94+  }
  95+}
  96+
  97+void gate_free(gate_t *gate) {
  98+  free(gate->timer_spawn);
  99+  free(gate);
 100+}
 101
 102

diff --git a/src/gate.h b/src/gate.h
new file mode 100644
index 0000000..5b644d6
--- /dev/null
+++ b/src/gate.h

   1@@ -0,0 +1,19 @@
   2+#pragma once
   3+
   4+typedef struct Gate gate_t;
   5+
   6+#include "game.h"
   7+#include "util.h"
   8+
   9+struct Gate {
  10+  pos_t pos;
  11+  int enemy_max;
  12+  timer_t *timer_spawn;
  13+  bool frozen;
  14+  int frozen_timer;
  15+};
  16+
  17+gate_t *gate_create(pos_t pos, int enemy_max, int time);
  18+void gate_update(gate_t *gate, game_t *game);
  19+void gate_draw(gate_t *gate, game_t *game);
  20+void gate_free(gate_t *gate);
  21
  22

diff --git a/src/level.c b/src/level.c
new file mode 100644
index 0000000..9359d7b
--- /dev/null
+++ b/src/level.c

   1@@ -0,0 +1,208 @@
   2+#include <stdlib.h>
   3+
   4+#include "enemy.h"
   5+#include "level.h"
   6+#include "const.h"
   7+#include "tile.h"
   8+#include "entity.h"
   9+
  10+const char *LEVEL_MAP_1 = {
  11+  "........................"
  12+  "........................"
  13+  "........................"
  14+  "........................"
  15+  "........................"
  16+  "........................"
  17+  "......e................."
  18+  "....xxxx................"
  19+  "........................"
  20+  "...........--...xxx....."
  21+  "................e......."
  22+  "...............--xxxxx.."
  23+  "....p..................."
  24+  "..ggggggggg---xxxxxxxx.."
  25+  "........................"
  26+  "........................"
  27+};
  28+
  29+const char *LEVEL_MAP_2 = {
  30+  "........................"
  31+  "........................"
  32+  "........................"
  33+  "........................"
  34+  "........................"
  35+  "..............xxxx......"
  36+  "........s.e............."
  37+  "....xxxxxxxxxtxxx--x...."
  38+  ".............w.........."
  39+  ".............w...--....."
  40+  ".............w.........."
  41+  ".........----x...--....."
  42+  "....p...............e..."
  43+  "..ggggg....xxxxxxxxxxx.."
  44+  "........................"
  45+  "........................"
  46+};
  47+
  48+const char *LEVEL_MAP_3 = {
  49+  "........................................"
  50+  "........................................"
  51+  "........................................"
  52+  "........................................"
  53+  "........................................"
  54+  "........................................"
  55+  "........................................"
  56+  "........................................"
  57+  "........................................"
  58+  "........................................"
  59+  "......e..................e...s.........."
  60+  "....ggggg...--...xxxxxxxxxxxxxxxxx......"
  61+  "........................................"
  62+  "............--.........................."
  63+  "....................e..................."
  64+  "............--...xxxxxxxxt-............."
  65+  ".........................w.............."
  66+  "............--...........w-............."
  67+  "..............e.......s..w..e..........."
  68+  "..........xxxxxxxxxxxxxxxxxxxxxxxt--x..."
  69+  ".................................w......"
  70+  ".................................w--...."
  71+  ".................................w......"
  72+  ".................................w--...."
  73+  "........................e........w......"
  74+  "....................xxtxxxtxx----x--...."
  75+  "....p.......e.........w...w............."
  76+  "..ggggg..-----...xxxxxxxxxxxxxxxxxxxxx.."
  77+  "........................................"
  78+  "........................................"
  79+};
  80+
  81+void level_generate(game_t *game, const char *map, int width, int height) {
  82+  game->player = NULL;
  83+  game->tiles = malloc(sizeof(tile_t) * width * height);
  84+  game->tiles_len = width * height;
  85+  game->entities = NULL;
  86+  game->entities_len = 0;
  87+  game->effects = NULL;
  88+  game->effects_len = 0;
  89+  for (int y = 0; y < height; y++) {
  90+    for (int x = 0; x < width; x++) {
  91+      int idx = y * width + x;
  92+      char c = map[idx];
  93+      game->tiles[idx] = tile_create((pos_t) {
  94+        .x = x * TILE_WIDTH,
  95+        .y = y * TILE_HEIGHT,
  96+      }, TILE_AIR);
  97+      tile_t *tile = game->tiles[idx];
  98+      // generate tile types
  99+      switch (c) {
 100+        case 'x':
 101+          tile->type = TILE_STONE;
 102+          break;
 103+        case 'g':
 104+          tile->type = TILE_GRASS;
 105+          break;
 106+        case '-':
 107+          tile->type = TILE_WOOD_PLATFORM;
 108+          break;
 109+        case 't':
 110+          tile->type = TILE_STONE_JOINT;
 111+          break;
 112+        case 'w':
 113+          tile->type = TILE_STONE_WALL;
 114+          break;
 115+        case 'i':
 116+          tile->type = TILE_SNOW;
 117+          break;
 118+        case 'n':
 119+          tile->type = TILE_SAND;
 120+          break;
 121+        default:
 122+          break;
 123+      }
 124+      // spawn entities
 125+      switch (c) {
 126+        case 'p': {
 127+          game->player = player_create((pos_t) {
 128+            .x = x * TILE_WIDTH + (TILE_WIDTH - PLAYER_WIDTH) / 2.0,
 129+            .y = y * TILE_HEIGHT + TILE_HEIGHT - PLAYER_HEIGHT,
 130+          });
 131+          break;
 132+        }
 133+        case 'e': {
 134+          game->entities = realloc(game->entities, sizeof(enemy_t) * (game->entities_len + 1));
 135+          enemy_t *enemy = enemy_create((pos_t) {
 136+            .x = x * TILE_WIDTH + (TILE_WIDTH - ENEMY_WIDTH) / 2.0,
 137+            .y = y * TILE_HEIGHT + TILE_HEIGHT - ENEMY_HEIGHT,
 138+          }, ENEMY_TEST);
 139+          game->entities[game->entities_len] = (entity_t) {
 140+            .type = ENTITY_ENEMY,
 141+            .enemy = enemy,
 142+          };
 143+          game->entities_len++;
 144+          break;
 145+        }
 146+        case 's': {
 147+          game->entities = realloc(game->entities, sizeof(enemy_t) * (game->entities_len + 1));
 148+          gate_t *gate = gate_create((pos_t) {
 149+            .x = x * TILE_WIDTH + (TILE_WIDTH - ENEMY_WIDTH) / 2.0,
 150+            .y = y * TILE_HEIGHT,
 151+          }, 5, 500);
 152+          game->entities[game->entities_len] = (entity_t) {
 153+            .type = ENTITY_GATE,
 154+            .gate = gate,
 155+          };
 156+          game->entities_len++;
 157+          break;
 158+        }
 159+        default:
 160+          break;
 161+      }
 162+    }
 163+  }
 164+}
 165+
 166+void level_load(game_t *game, level_e type) {
 167+  level_t *level = malloc(sizeof(level_t));
 168+  level->type = type;
 169+  switch (type) {
 170+    case LEVEL_NULL:
 171+      break;
 172+    case LEVEL_1: {
 173+      level_generate(game, LEVEL_MAP_1, 24, 16);
 174+      level->width = 24;
 175+      level->height = 16;
 176+      break;
 177+    }
 178+    case LEVEL_2: {
 179+      level_generate(game, LEVEL_MAP_2, 24, 16);
 180+      level->width = 24;
 181+      level->height = 16;
 182+      break;
 183+    }
 184+    case LEVEL_3: {
 185+      level_generate(game, LEVEL_MAP_3, 40, 30);
 186+      level->width = 40;
 187+      level->height = 30;
 188+      break;
 189+    }
 190+  }
 191+  game->level = level;
 192+}
 193+
 194+void level_unload(game_t *game) {
 195+  player_free(game->player);
 196+  for (int i = 0; i < game->tiles_len; i++) {
 197+    tile_free(game->tiles[i]);
 198+  }
 199+  free(game->tiles);
 200+  for (int i = 0; i < game->entities_len; i++) {
 201+    entity_detach(&game->entities[i]);
 202+  }
 203+  free(game->entities);
 204+  for (int i = 0; i < game->effects_len; i++) {
 205+    effect_free(game->effects[i]);
 206+  }
 207+  free(game->effects);
 208+  free(game->level);
 209+}
 210
 211

diff --git a/src/level.h b/src/level.h
new file mode 100644
index 0000000..d6b96ba
--- /dev/null
+++ b/src/level.h

   1@@ -0,0 +1,23 @@
   2+#pragma once
   3+
   4+#define LEVELS 3
   5+
   6+typedef struct Level level_t;
   7+
   8+typedef enum {
   9+  LEVEL_NULL,
  10+  LEVEL_1,
  11+  LEVEL_2,
  12+  LEVEL_3,
  13+} level_e;
  14+
  15+#include "game.h"
  16+
  17+struct Level {
  18+  level_e type;
  19+  int width;
  20+  int height;
  21+};
  22+
  23+void level_load(game_t *game, level_e type);
  24+void level_unload(game_t *game);
  25
  26

diff --git a/src/libs/raylib.h b/src/libs/raylib.h
new file mode 100644
index 0000000..5ff2399
--- /dev/null
+++ b/src/libs/raylib.h

   1@@ -0,0 +1,1673 @@
   2+/**********************************************************************************************
   3+*
   4+*   raylib v5.1-dev - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
   5+*
   6+*   FEATURES:
   7+*       - NO external dependencies, all required libraries included with raylib
   8+*       - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly,
   9+*                        MacOS, Haiku, Android, Raspberry Pi, DRM native, HTML5.
  10+*       - Written in plain C code (C99) in PascalCase/camelCase notation
  11+*       - Hardware accelerated with OpenGL (1.1, 2.1, 3.3, 4.3 or ES2 - choose at compile)
  12+*       - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
  13+*       - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts)
  14+*       - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
  15+*       - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
  16+*       - Flexible Materials system, supporting classic maps and PBR maps
  17+*       - Animated 3D models supported (skeletal bones animation) (IQM)
  18+*       - Shaders support, including Model shaders and Postprocessing shaders
  19+*       - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
  20+*       - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
  21+*       - VR stereo rendering with configurable HMD device parameters
  22+*       - Bindings to multiple programming languages available!
  23+*
  24+*   NOTES:
  25+*       - One default Font is loaded on InitWindow()->LoadFontDefault() [core, text]
  26+*       - One default Texture2D is loaded on rlglInit(), 1x1 white pixel R8G8B8A8 [rlgl] (OpenGL 3.3 or ES2)
  27+*       - One default Shader is loaded on rlglInit()->rlLoadShaderDefault() [rlgl] (OpenGL 3.3 or ES2)
  28+*       - One default RenderBatch is loaded on rlglInit()->rlLoadRenderBatch() [rlgl] (OpenGL 3.3 or ES2)
  29+*
  30+*   DEPENDENCIES (included):
  31+*       [rcore] rglfw (Camilla Löwy - github.com/glfw/glfw) for window/context management and input (PLATFORM_DESKTOP)
  32+*       [rlgl] glad (David Herberth - github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (PLATFORM_DESKTOP)
  33+*       [raudio] miniaudio (David Reid - github.com/mackron/miniaudio) for audio device/context management
  34+*
  35+*   OPTIONAL DEPENDENCIES (included):
  36+*       [rcore] msf_gif (Miles Fogle) for GIF recording
  37+*       [rcore] sinfl (Micha Mettke) for DEFLATE decompression algorithm
  38+*       [rcore] sdefl (Micha Mettke) for DEFLATE compression algorithm
  39+*       [rtextures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
  40+*       [rtextures] stb_image_write (Sean Barret) for image writing (BMP, TGA, PNG, JPG)
  41+*       [rtextures] stb_image_resize (Sean Barret) for image resizing algorithms
  42+*       [rtext] stb_truetype (Sean Barret) for ttf fonts loading
  43+*       [rtext] stb_rect_pack (Sean Barret) for rectangles packing
  44+*       [rmodels] par_shapes (Philip Rideout) for parametric 3d shapes generation
  45+*       [rmodels] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
  46+*       [rmodels] cgltf (Johannes Kuhlmann) for models loading (glTF)
  47+*       [rmodels] Model3D (bzt) for models loading (M3D, https://bztsrc.gitlab.io/model3d)
  48+*       [raudio] dr_wav (David Reid) for WAV audio file loading
  49+*       [raudio] dr_flac (David Reid) for FLAC audio file loading
  50+*       [raudio] dr_mp3 (David Reid) for MP3 audio file loading
  51+*       [raudio] stb_vorbis (Sean Barret) for OGG audio loading
  52+*       [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
  53+*       [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
  54+*
  55+*
  56+*   LICENSE: zlib/libpng
  57+*
  58+*   raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
  59+*   BSD-like license that allows static linking with closed source software:
  60+*
  61+*   Copyright (c) 2013-2024 Ramon Santamaria (@raysan5)
  62+*
  63+*   This software is provided "as-is", without any express or implied warranty. In no event
  64+*   will the authors be held liable for any damages arising from the use of this software.
  65+*
  66+*   Permission is granted to anyone to use this software for any purpose, including commercial
  67+*   applications, and to alter it and redistribute it freely, subject to the following restrictions:
  68+*
  69+*     1. The origin of this software must not be misrepresented; you must not claim that you
  70+*     wrote the original software. If you use this software in a product, an acknowledgment
  71+*     in the product documentation would be appreciated but is not required.
  72+*
  73+*     2. Altered source versions must be plainly marked as such, and must not be misrepresented
  74+*     as being the original software.
  75+*
  76+*     3. This notice may not be removed or altered from any source distribution.
  77+*
  78+**********************************************************************************************/
  79+
  80+#ifndef RAYLIB_H
  81+#define RAYLIB_H
  82+
  83+#include <stdarg.h>     // Required for: va_list - Only used by TraceLogCallback
  84+
  85+#define RAYLIB_VERSION_MAJOR 5
  86+#define RAYLIB_VERSION_MINOR 1
  87+#define RAYLIB_VERSION_PATCH 0
  88+#define RAYLIB_VERSION  "5.1-dev"
  89+
  90+// Function specifiers in case library is build/used as a shared library
  91+// NOTE: Microsoft specifiers to tell compiler that symbols are imported/exported from a .dll
  92+// NOTE: visibility("default") attribute makes symbols "visible" when compiled with -fvisibility=hidden
  93+#if defined(_WIN32)
  94+    #if defined(__TINYC__)
  95+        #define __declspec(x) __attribute__((x))
  96+    #endif
  97+    #if defined(BUILD_LIBTYPE_SHARED)
  98+        #define RLAPI __declspec(dllexport)     // We are building the library as a Win32 shared library (.dll)
  99+    #elif defined(USE_LIBTYPE_SHARED)
 100+        #define RLAPI __declspec(dllimport)     // We are using the library as a Win32 shared library (.dll)
 101+    #endif
 102+#else
 103+    #if defined(BUILD_LIBTYPE_SHARED)
 104+        #define RLAPI __attribute__((visibility("default"))) // We are building as a Unix shared library (.so/.dylib)
 105+    #endif
 106+#endif
 107+
 108+#ifndef RLAPI
 109+    #define RLAPI       // Functions defined as 'extern' by default (implicit specifiers)
 110+#endif
 111+
 112+//----------------------------------------------------------------------------------
 113+// Some basic Defines
 114+//----------------------------------------------------------------------------------
 115+#ifndef PI
 116+    #define PI 3.14159265358979323846f
 117+#endif
 118+#ifndef DEG2RAD
 119+    #define DEG2RAD (PI/180.0f)
 120+#endif
 121+#ifndef RAD2DEG
 122+    #define RAD2DEG (180.0f/PI)
 123+#endif
 124+
 125+// Allow custom memory allocators
 126+// NOTE: Require recompiling raylib sources
 127+#ifndef RL_MALLOC
 128+    #define RL_MALLOC(sz)       malloc(sz)
 129+#endif
 130+#ifndef RL_CALLOC
 131+    #define RL_CALLOC(n,sz)     calloc(n,sz)
 132+#endif
 133+#ifndef RL_REALLOC
 134+    #define RL_REALLOC(ptr,sz)  realloc(ptr,sz)
 135+#endif
 136+#ifndef RL_FREE
 137+    #define RL_FREE(ptr)        free(ptr)
 138+#endif
 139+
 140+// NOTE: MSVC C++ compiler does not support compound literals (C99 feature)
 141+// Plain structures in C++ (without constructors) can be initialized with { }
 142+// This is called aggregate initialization (C++11 feature)
 143+#if defined(__cplusplus)
 144+    #define CLITERAL(type)      type
 145+#else
 146+    #define CLITERAL(type)      (type)
 147+#endif
 148+
 149+// Some compilers (mostly macos clang) default to C++98,
 150+// where aggregate initialization can't be used
 151+// So, give a more clear error stating how to fix this
 152+// #if !defined(_MSC_VER) && (defined(__cplusplus) && __cplusplus < 201103L)
 153+//     #error "C++11 or later is required. Add -std=c++11"
 154+// #endif
 155+
 156+// NOTE: We set some defines with some data types declared by raylib
 157+// Other modules (raymath, rlgl) also require some of those types, so,
 158+// to be able to use those other modules as standalone (not depending on raylib)
 159+// this defines are very useful for internal check and avoid type (re)definitions
 160+#define RL_COLOR_TYPE
 161+#define RL_RECTANGLE_TYPE
 162+#define RL_VECTOR2_TYPE
 163+#define RL_VECTOR3_TYPE
 164+#define RL_VECTOR4_TYPE
 165+#define RL_QUATERNION_TYPE
 166+#define RL_MATRIX_TYPE
 167+
 168+// Some Basic Colors
 169+// NOTE: Custom raylib color palette for amazing visuals on WHITE background
 170+#define LIGHTGRAY  CLITERAL(Color){ 200, 200, 200, 255 }   // Light Gray
 171+#define GRAY       CLITERAL(Color){ 130, 130, 130, 255 }   // Gray
 172+#define DARKGRAY   CLITERAL(Color){ 80, 80, 80, 255 }      // Dark Gray
 173+#define YELLOW     CLITERAL(Color){ 253, 249, 0, 255 }     // Yellow
 174+#define GOLD       CLITERAL(Color){ 255, 203, 0, 255 }     // Gold
 175+#define ORANGE     CLITERAL(Color){ 255, 161, 0, 255 }     // Orange
 176+#define PINK       CLITERAL(Color){ 255, 109, 194, 255 }   // Pink
 177+#define RED        CLITERAL(Color){ 230, 41, 55, 255 }     // Red
 178+#define MAROON     CLITERAL(Color){ 190, 33, 55, 255 }     // Maroon
 179+#define GREEN      CLITERAL(Color){ 0, 228, 48, 255 }      // Green
 180+#define LIME       CLITERAL(Color){ 0, 158, 47, 255 }      // Lime
 181+#define DARKGREEN  CLITERAL(Color){ 0, 117, 44, 255 }      // Dark Green
 182+#define SKYBLUE    CLITERAL(Color){ 102, 191, 255, 255 }   // Sky Blue
 183+#define BLUE       CLITERAL(Color){ 0, 121, 241, 255 }     // Blue
 184+#define DARKBLUE   CLITERAL(Color){ 0, 82, 172, 255 }      // Dark Blue
 185+#define PURPLE     CLITERAL(Color){ 200, 122, 255, 255 }   // Purple
 186+#define VIOLET     CLITERAL(Color){ 135, 60, 190, 255 }    // Violet
 187+#define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 }    // Dark Purple
 188+#define BEIGE      CLITERAL(Color){ 211, 176, 131, 255 }   // Beige
 189+#define BROWN      CLITERAL(Color){ 127, 106, 79, 255 }    // Brown
 190+#define DARKBROWN  CLITERAL(Color){ 76, 63, 47, 255 }      // Dark Brown
 191+
 192+#define WHITE      CLITERAL(Color){ 255, 255, 255, 255 }   // White
 193+#define BLACK      CLITERAL(Color){ 0, 0, 0, 255 }         // Black
 194+#define BLANK      CLITERAL(Color){ 0, 0, 0, 0 }           // Blank (Transparent)
 195+#define MAGENTA    CLITERAL(Color){ 255, 0, 255, 255 }     // Magenta
 196+#define RAYWHITE   CLITERAL(Color){ 245, 245, 245, 255 }   // My own White (raylib logo)
 197+
 198+//----------------------------------------------------------------------------------
 199+// Structures Definition
 200+//----------------------------------------------------------------------------------
 201+// Boolean type
 202+#if (defined(__STDC__) && __STDC_VERSION__ >= 199901L) || (defined(_MSC_VER) && _MSC_VER >= 1800)
 203+    #include <stdbool.h>
 204+#elif !defined(__cplusplus) && !defined(bool)
 205+    typedef enum bool { false = 0, true = !false } bool;
 206+    #define RL_BOOL_TYPE
 207+#endif
 208+
 209+// Vector2, 2 components
 210+typedef struct Vector2 {
 211+    float x;                // Vector x component
 212+    float y;                // Vector y component
 213+} Vector2;
 214+
 215+// Vector3, 3 components
 216+typedef struct Vector3 {
 217+    float x;                // Vector x component
 218+    float y;                // Vector y component
 219+    float z;                // Vector z component
 220+} Vector3;
 221+
 222+// Vector4, 4 components
 223+typedef struct Vector4 {
 224+    float x;                // Vector x component
 225+    float y;                // Vector y component
 226+    float z;                // Vector z component
 227+    float w;                // Vector w component
 228+} Vector4;
 229+
 230+// Quaternion, 4 components (Vector4 alias)
 231+typedef Vector4 Quaternion;
 232+
 233+// Matrix, 4x4 components, column major, OpenGL style, right-handed
 234+typedef struct Matrix {
 235+    float m0, m4, m8, m12;  // Matrix first row (4 components)
 236+    float m1, m5, m9, m13;  // Matrix second row (4 components)
 237+    float m2, m6, m10, m14; // Matrix third row (4 components)
 238+    float m3, m7, m11, m15; // Matrix fourth row (4 components)
 239+} Matrix;
 240+
 241+// Color, 4 components, R8G8B8A8 (32bit)
 242+typedef struct Color {
 243+    unsigned char r;        // Color red value
 244+    unsigned char g;        // Color green value
 245+    unsigned char b;        // Color blue value
 246+    unsigned char a;        // Color alpha value
 247+} Color;
 248+
 249+// Rectangle, 4 components
 250+typedef struct Rectangle {
 251+    float x;                // Rectangle top-left corner position x
 252+    float y;                // Rectangle top-left corner position y
 253+    float width;            // Rectangle width
 254+    float height;           // Rectangle height
 255+} Rectangle;
 256+
 257+// Image, pixel data stored in CPU memory (RAM)
 258+typedef struct Image {
 259+    void *data;             // Image raw data
 260+    int width;              // Image base width
 261+    int height;             // Image base height
 262+    int mipmaps;            // Mipmap levels, 1 by default
 263+    int format;             // Data format (PixelFormat type)
 264+} Image;
 265+
 266+// Texture, tex data stored in GPU memory (VRAM)
 267+typedef struct Texture {
 268+    unsigned int id;        // OpenGL texture id
 269+    int width;              // Texture base width
 270+    int height;             // Texture base height
 271+    int mipmaps;            // Mipmap levels, 1 by default
 272+    int format;             // Data format (PixelFormat type)
 273+} Texture;
 274+
 275+// Texture2D, same as Texture
 276+typedef Texture Texture2D;
 277+
 278+// TextureCubemap, same as Texture
 279+typedef Texture TextureCubemap;
 280+
 281+// RenderTexture, fbo for texture rendering
 282+typedef struct RenderTexture {
 283+    unsigned int id;        // OpenGL framebuffer object id
 284+    Texture texture;        // Color buffer attachment texture
 285+    Texture depth;          // Depth buffer attachment texture
 286+} RenderTexture;
 287+
 288+// RenderTexture2D, same as RenderTexture
 289+typedef RenderTexture RenderTexture2D;
 290+
 291+// NPatchInfo, n-patch layout info
 292+typedef struct NPatchInfo {
 293+    Rectangle source;       // Texture source rectangle
 294+    int left;               // Left border offset
 295+    int top;                // Top border offset
 296+    int right;              // Right border offset
 297+    int bottom;             // Bottom border offset
 298+    int layout;             // Layout of the n-patch: 3x3, 1x3 or 3x1
 299+} NPatchInfo;
 300+
 301+// GlyphInfo, font characters glyphs info
 302+typedef struct GlyphInfo {
 303+    int value;              // Character value (Unicode)
 304+    int offsetX;            // Character offset X when drawing
 305+    int offsetY;            // Character offset Y when drawing
 306+    int advanceX;           // Character advance position X
 307+    Image image;            // Character image data
 308+} GlyphInfo;
 309+
 310+// Font, font texture and GlyphInfo array data
 311+typedef struct Font {
 312+    int baseSize;           // Base size (default chars height)
 313+    int glyphCount;         // Number of glyph characters
 314+    int glyphPadding;       // Padding around the glyph characters
 315+    Texture2D texture;      // Texture atlas containing the glyphs
 316+    Rectangle *recs;        // Rectangles in texture for the glyphs
 317+    GlyphInfo *glyphs;      // Glyphs info data
 318+} Font;
 319+
 320+// Camera, defines position/orientation in 3d space
 321+typedef struct Camera3D {
 322+    Vector3 position;       // Camera position
 323+    Vector3 target;         // Camera target it looks-at
 324+    Vector3 up;             // Camera up vector (rotation over its axis)
 325+    float fovy;             // Camera field-of-view aperture in Y (degrees) in perspective, used as near plane width in orthographic
 326+    int projection;         // Camera projection: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
 327+} Camera3D;
 328+
 329+typedef Camera3D Camera;    // Camera type fallback, defaults to Camera3D
 330+
 331+// Camera2D, defines position/orientation in 2d space
 332+typedef struct Camera2D {
 333+    Vector2 offset;         // Camera offset (displacement from target)
 334+    Vector2 target;         // Camera target (rotation and zoom origin)
 335+    float rotation;         // Camera rotation in degrees
 336+    float zoom;             // Camera zoom (scaling), should be 1.0f by default
 337+} Camera2D;
 338+
 339+// Mesh, vertex data and vao/vbo
 340+typedef struct Mesh {
 341+    int vertexCount;        // Number of vertices stored in arrays
 342+    int triangleCount;      // Number of triangles stored (indexed or not)
 343+
 344+    // Vertex attributes data
 345+    float *vertices;        // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
 346+    float *texcoords;       // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
 347+    float *texcoords2;      // Vertex texture second coordinates (UV - 2 components per vertex) (shader-location = 5)
 348+    float *normals;         // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
 349+    float *tangents;        // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
 350+    unsigned char *colors;      // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
 351+    unsigned short *indices;    // Vertex indices (in case vertex data comes indexed)
 352+
 353+    // Animation vertex data
 354+    float *animVertices;    // Animated vertex positions (after bones transformations)
 355+    float *animNormals;     // Animated normals (after bones transformations)
 356+    unsigned char *boneIds; // Vertex bone ids, max 255 bone ids, up to 4 bones influence by vertex (skinning)
 357+    float *boneWeights;     // Vertex bone weight, up to 4 bones influence by vertex (skinning)
 358+
 359+    // OpenGL identifiers
 360+    unsigned int vaoId;     // OpenGL Vertex Array Object id
 361+    unsigned int *vboId;    // OpenGL Vertex Buffer Objects id (default vertex data)
 362+} Mesh;
 363+
 364+// Shader
 365+typedef struct Shader {
 366+    unsigned int id;        // Shader program id
 367+    int *locs;              // Shader locations array (RL_MAX_SHADER_LOCATIONS)
 368+} Shader;
 369+
 370+// MaterialMap
 371+typedef struct MaterialMap {
 372+    Texture2D texture;      // Material map texture
 373+    Color color;            // Material map color
 374+    float value;            // Material map value
 375+} MaterialMap;
 376+
 377+// Material, includes shader and maps
 378+typedef struct Material {
 379+    Shader shader;          // Material shader
 380+    MaterialMap *maps;      // Material maps array (MAX_MATERIAL_MAPS)
 381+    float params[4];        // Material generic parameters (if required)
 382+} Material;
 383+
 384+// Transform, vertex transformation data
 385+typedef struct Transform {
 386+    Vector3 translation;    // Translation
 387+    Quaternion rotation;    // Rotation
 388+    Vector3 scale;          // Scale
 389+} Transform;
 390+
 391+// Bone, skeletal animation bone
 392+typedef struct BoneInfo {
 393+    char name[32];          // Bone name
 394+    int parent;             // Bone parent
 395+} BoneInfo;
 396+
 397+// Model, meshes, materials and animation data
 398+typedef struct Model {
 399+    Matrix transform;       // Local transform matrix
 400+
 401+    int meshCount;          // Number of meshes
 402+    int materialCount;      // Number of materials
 403+    Mesh *meshes;           // Meshes array
 404+    Material *materials;    // Materials array
 405+    int *meshMaterial;      // Mesh material number
 406+
 407+    // Animation data
 408+    int boneCount;          // Number of bones
 409+    BoneInfo *bones;        // Bones information (skeleton)
 410+    Transform *bindPose;    // Bones base transformation (pose)
 411+} Model;
 412+
 413+// ModelAnimation
 414+typedef struct ModelAnimation {
 415+    int boneCount;          // Number of bones
 416+    int frameCount;         // Number of animation frames
 417+    BoneInfo *bones;        // Bones information (skeleton)
 418+    Transform **framePoses; // Poses array by frame
 419+    char name[32];          // Animation name
 420+} ModelAnimation;
 421+
 422+// Ray, ray for raycasting
 423+typedef struct Ray {
 424+    Vector3 position;       // Ray position (origin)
 425+    Vector3 direction;      // Ray direction
 426+} Ray;
 427+
 428+// RayCollision, ray hit information
 429+typedef struct RayCollision {
 430+    bool hit;               // Did the ray hit something?
 431+    float distance;         // Distance to the nearest hit
 432+    Vector3 point;          // Point of the nearest hit
 433+    Vector3 normal;         // Surface normal of hit
 434+} RayCollision;
 435+
 436+// BoundingBox
 437+typedef struct BoundingBox {
 438+    Vector3 min;            // Minimum vertex box-corner
 439+    Vector3 max;            // Maximum vertex box-corner
 440+} BoundingBox;
 441+
 442+// Wave, audio wave data
 443+typedef struct Wave {
 444+    unsigned int frameCount;    // Total number of frames (considering channels)
 445+    unsigned int sampleRate;    // Frequency (samples per second)
 446+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
 447+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
 448+    void *data;                 // Buffer data pointer
 449+} Wave;
 450+
 451+// Opaque structs declaration
 452+// NOTE: Actual structs are defined internally in raudio module
 453+typedef struct rAudioBuffer rAudioBuffer;
 454+typedef struct rAudioProcessor rAudioProcessor;
 455+
 456+// AudioStream, custom audio stream
 457+typedef struct AudioStream {
 458+    rAudioBuffer *buffer;       // Pointer to internal data used by the audio system
 459+    rAudioProcessor *processor; // Pointer to internal data processor, useful for audio effects
 460+
 461+    unsigned int sampleRate;    // Frequency (samples per second)
 462+    unsigned int sampleSize;    // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
 463+    unsigned int channels;      // Number of channels (1-mono, 2-stereo, ...)
 464+} AudioStream;
 465+
 466+// Sound
 467+typedef struct Sound {
 468+    AudioStream stream;         // Audio stream
 469+    unsigned int frameCount;    // Total number of frames (considering channels)
 470+} Sound;
 471+
 472+// Music, audio stream, anything longer than ~10 seconds should be streamed
 473+typedef struct Music {
 474+    AudioStream stream;         // Audio stream
 475+    unsigned int frameCount;    // Total number of frames (considering channels)
 476+    bool looping;               // Music looping enable
 477+
 478+    int ctxType;                // Type of music context (audio filetype)
 479+    void *ctxData;              // Audio context data, depends on type
 480+} Music;
 481+
 482+// VrDeviceInfo, Head-Mounted-Display device parameters
 483+typedef struct VrDeviceInfo {
 484+    int hResolution;                // Horizontal resolution in pixels
 485+    int vResolution;                // Vertical resolution in pixels
 486+    float hScreenSize;              // Horizontal size in meters
 487+    float vScreenSize;              // Vertical size in meters
 488+    float eyeToScreenDistance;      // Distance between eye and display in meters
 489+    float lensSeparationDistance;   // Lens separation distance in meters
 490+    float interpupillaryDistance;   // IPD (distance between pupils) in meters
 491+    float lensDistortionValues[4];  // Lens distortion constant parameters
 492+    float chromaAbCorrection[4];    // Chromatic aberration correction parameters
 493+} VrDeviceInfo;
 494+
 495+// VrStereoConfig, VR stereo rendering configuration for simulator
 496+typedef struct VrStereoConfig {
 497+    Matrix projection[2];           // VR projection matrices (per eye)
 498+    Matrix viewOffset[2];           // VR view offset matrices (per eye)
 499+    float leftLensCenter[2];        // VR left lens center
 500+    float rightLensCenter[2];       // VR right lens center
 501+    float leftScreenCenter[2];      // VR left screen center
 502+    float rightScreenCenter[2];     // VR right screen center
 503+    float scale[2];                 // VR distortion scale
 504+    float scaleIn[2];               // VR distortion scale in
 505+} VrStereoConfig;
 506+
 507+// File path list
 508+typedef struct FilePathList {
 509+    unsigned int capacity;          // Filepaths max entries
 510+    unsigned int count;             // Filepaths entries count
 511+    char **paths;                   // Filepaths entries
 512+} FilePathList;
 513+
 514+// Automation event
 515+typedef struct AutomationEvent {
 516+    unsigned int frame;             // Event frame
 517+    unsigned int type;              // Event type (AutomationEventType)
 518+    int params[4];                  // Event parameters (if required)
 519+} AutomationEvent;
 520+
 521+// Automation event list
 522+typedef struct AutomationEventList {
 523+    unsigned int capacity;          // Events max entries (MAX_AUTOMATION_EVENTS)
 524+    unsigned int count;             // Events entries count
 525+    AutomationEvent *events;        // Events entries
 526+} AutomationEventList;
 527+
 528+//----------------------------------------------------------------------------------
 529+// Enumerators Definition
 530+//----------------------------------------------------------------------------------
 531+// System/Window config flags
 532+// NOTE: Every bit registers one state (use it with bit masks)
 533+// By default all flags are set to 0
 534+typedef enum {
 535+    FLAG_VSYNC_HINT         = 0x00000040,   // Set to try enabling V-Sync on GPU
 536+    FLAG_FULLSCREEN_MODE    = 0x00000002,   // Set to run program in fullscreen
 537+    FLAG_WINDOW_RESIZABLE   = 0x00000004,   // Set to allow resizable window
 538+    FLAG_WINDOW_UNDECORATED = 0x00000008,   // Set to disable window decoration (frame and buttons)
 539+    FLAG_WINDOW_HIDDEN      = 0x00000080,   // Set to hide window
 540+    FLAG_WINDOW_MINIMIZED   = 0x00000200,   // Set to minimize window (iconify)
 541+    FLAG_WINDOW_MAXIMIZED   = 0x00000400,   // Set to maximize window (expanded to monitor)
 542+    FLAG_WINDOW_UNFOCUSED   = 0x00000800,   // Set to window non focused
 543+    FLAG_WINDOW_TOPMOST     = 0x00001000,   // Set to window always on top
 544+    FLAG_WINDOW_ALWAYS_RUN  = 0x00000100,   // Set to allow windows running while minimized
 545+    FLAG_WINDOW_TRANSPARENT = 0x00000010,   // Set to allow transparent framebuffer
 546+    FLAG_WINDOW_HIGHDPI     = 0x00002000,   // Set to support HighDPI
 547+    FLAG_WINDOW_MOUSE_PASSTHROUGH = 0x00004000, // Set to support mouse passthrough, only supported when FLAG_WINDOW_UNDECORATED
 548+    FLAG_BORDERLESS_WINDOWED_MODE = 0x00008000, // Set to run program in borderless windowed mode
 549+    FLAG_MSAA_4X_HINT       = 0x00000020,   // Set to try enabling MSAA 4X
 550+    FLAG_INTERLACED_HINT    = 0x00010000    // Set to try enabling interlaced video format (for V3D)
 551+} ConfigFlags;
 552+
 553+// Trace log level
 554+// NOTE: Organized by priority level
 555+typedef enum {
 556+    LOG_ALL = 0,        // Display all logs
 557+    LOG_TRACE,          // Trace logging, intended for internal use only
 558+    LOG_DEBUG,          // Debug logging, used for internal debugging, it should be disabled on release builds
 559+    LOG_INFO,           // Info logging, used for program execution info
 560+    LOG_WARNING,        // Warning logging, used on recoverable failures
 561+    LOG_ERROR,          // Error logging, used on unrecoverable failures
 562+    LOG_FATAL,          // Fatal logging, used to abort program: exit(EXIT_FAILURE)
 563+    LOG_NONE            // Disable logging
 564+} TraceLogLevel;
 565+
 566+// Keyboard keys (US keyboard layout)
 567+// NOTE: Use GetKeyPressed() to allow redefining
 568+// required keys for alternative layouts
 569+typedef enum {
 570+    KEY_NULL            = 0,        // Key: NULL, used for no key pressed
 571+    // Alphanumeric keys
 572+    KEY_APOSTROPHE      = 39,       // Key: '
 573+    KEY_COMMA           = 44,       // Key: ,
 574+    KEY_MINUS           = 45,       // Key: -
 575+    KEY_PERIOD          = 46,       // Key: .
 576+    KEY_SLASH           = 47,       // Key: /
 577+    KEY_ZERO            = 48,       // Key: 0
 578+    KEY_ONE             = 49,       // Key: 1
 579+    KEY_TWO             = 50,       // Key: 2
 580+    KEY_THREE           = 51,       // Key: 3
 581+    KEY_FOUR            = 52,       // Key: 4
 582+    KEY_FIVE            = 53,       // Key: 5
 583+    KEY_SIX             = 54,       // Key: 6
 584+    KEY_SEVEN           = 55,       // Key: 7
 585+    KEY_EIGHT           = 56,       // Key: 8
 586+    KEY_NINE            = 57,       // Key: 9
 587+    KEY_SEMICOLON       = 59,       // Key: ;
 588+    KEY_EQUAL           = 61,       // Key: =
 589+    KEY_A               = 65,       // Key: A | a
 590+    KEY_B               = 66,       // Key: B | b
 591+    KEY_C               = 67,       // Key: C | c
 592+    KEY_D               = 68,       // Key: D | d
 593+    KEY_E               = 69,       // Key: E | e
 594+    KEY_F               = 70,       // Key: F | f
 595+    KEY_G               = 71,       // Key: G | g
 596+    KEY_H               = 72,       // Key: H | h
 597+    KEY_I               = 73,       // Key: I | i
 598+    KEY_J               = 74,       // Key: J | j
 599+    KEY_K               = 75,       // Key: K | k
 600+    KEY_L               = 76,       // Key: L | l
 601+    KEY_M               = 77,       // Key: M | m
 602+    KEY_N               = 78,       // Key: N | n
 603+    KEY_O               = 79,       // Key: O | o
 604+    KEY_P               = 80,       // Key: P | p
 605+    KEY_Q               = 81,       // Key: Q | q
 606+    KEY_R               = 82,       // Key: R | r
 607+    KEY_S               = 83,       // Key: S | s
 608+    KEY_T               = 84,       // Key: T | t
 609+    KEY_U               = 85,       // Key: U | u
 610+    KEY_V               = 86,       // Key: V | v
 611+    KEY_W               = 87,       // Key: W | w
 612+    KEY_X               = 88,       // Key: X | x
 613+    KEY_Y               = 89,       // Key: Y | y
 614+    KEY_Z               = 90,       // Key: Z | z
 615+    KEY_LEFT_BRACKET    = 91,       // Key: [
 616+    KEY_BACKSLASH       = 92,       // Key: '\'
 617+    KEY_RIGHT_BRACKET   = 93,       // Key: ]
 618+    KEY_GRAVE           = 96,       // Key: `
 619+    // Function keys
 620+    KEY_SPACE           = 32,       // Key: Space
 621+    KEY_ESCAPE          = 256,      // Key: Esc
 622+    KEY_ENTER           = 257,      // Key: Enter
 623+    KEY_TAB             = 258,      // Key: Tab
 624+    KEY_BACKSPACE       = 259,      // Key: Backspace
 625+    KEY_INSERT          = 260,      // Key: Ins
 626+    KEY_DELETE          = 261,      // Key: Del
 627+    KEY_RIGHT           = 262,      // Key: Cursor right
 628+    KEY_LEFT            = 263,      // Key: Cursor left
 629+    KEY_DOWN            = 264,      // Key: Cursor down
 630+    KEY_UP              = 265,      // Key: Cursor up
 631+    KEY_PAGE_UP         = 266,      // Key: Page up
 632+    KEY_PAGE_DOWN       = 267,      // Key: Page down
 633+    KEY_HOME            = 268,      // Key: Home
 634+    KEY_END             = 269,      // Key: End
 635+    KEY_CAPS_LOCK       = 280,      // Key: Caps lock
 636+    KEY_SCROLL_LOCK     = 281,      // Key: Scroll down
 637+    KEY_NUM_LOCK        = 282,      // Key: Num lock
 638+    KEY_PRINT_SCREEN    = 283,      // Key: Print screen
 639+    KEY_PAUSE           = 284,      // Key: Pause
 640+    KEY_F1              = 290,      // Key: F1
 641+    KEY_F2              = 291,      // Key: F2
 642+    KEY_F3              = 292,      // Key: F3
 643+    KEY_F4              = 293,      // Key: F4
 644+    KEY_F5              = 294,      // Key: F5
 645+    KEY_F6              = 295,      // Key: F6
 646+    KEY_F7              = 296,      // Key: F7
 647+    KEY_F8              = 297,      // Key: F8
 648+    KEY_F9              = 298,      // Key: F9
 649+    KEY_F10             = 299,      // Key: F10
 650+    KEY_F11             = 300,      // Key: F11
 651+    KEY_F12             = 301,      // Key: F12
 652+    KEY_LEFT_SHIFT      = 340,      // Key: Shift left
 653+    KEY_LEFT_CONTROL    = 341,      // Key: Control left
 654+    KEY_LEFT_ALT        = 342,      // Key: Alt left
 655+    KEY_LEFT_SUPER      = 343,      // Key: Super left
 656+    KEY_RIGHT_SHIFT     = 344,      // Key: Shift right
 657+    KEY_RIGHT_CONTROL   = 345,      // Key: Control right
 658+    KEY_RIGHT_ALT       = 346,      // Key: Alt right
 659+    KEY_RIGHT_SUPER     = 347,      // Key: Super right
 660+    KEY_KB_MENU         = 348,      // Key: KB menu
 661+    // Keypad keys
 662+    KEY_KP_0            = 320,      // Key: Keypad 0
 663+    KEY_KP_1            = 321,      // Key: Keypad 1
 664+    KEY_KP_2            = 322,      // Key: Keypad 2
 665+    KEY_KP_3            = 323,      // Key: Keypad 3
 666+    KEY_KP_4            = 324,      // Key: Keypad 4
 667+    KEY_KP_5            = 325,      // Key: Keypad 5
 668+    KEY_KP_6            = 326,      // Key: Keypad 6
 669+    KEY_KP_7            = 327,      // Key: Keypad 7
 670+    KEY_KP_8            = 328,      // Key: Keypad 8
 671+    KEY_KP_9            = 329,      // Key: Keypad 9
 672+    KEY_KP_DECIMAL      = 330,      // Key: Keypad .
 673+    KEY_KP_DIVIDE       = 331,      // Key: Keypad /
 674+    KEY_KP_MULTIPLY     = 332,      // Key: Keypad *
 675+    KEY_KP_SUBTRACT     = 333,      // Key: Keypad -
 676+    KEY_KP_ADD          = 334,      // Key: Keypad +
 677+    KEY_KP_ENTER        = 335,      // Key: Keypad Enter
 678+    KEY_KP_EQUAL        = 336,      // Key: Keypad =
 679+    // Android key buttons
 680+    KEY_BACK            = 4,        // Key: Android back button
 681+    KEY_MENU            = 5,        // Key: Android menu button
 682+    KEY_VOLUME_UP       = 24,       // Key: Android volume up button
 683+    KEY_VOLUME_DOWN     = 25        // Key: Android volume down button
 684+} KeyboardKey;
 685+
 686+// Add backwards compatibility support for deprecated names
 687+#define MOUSE_LEFT_BUTTON   MOUSE_BUTTON_LEFT
 688+#define MOUSE_RIGHT_BUTTON  MOUSE_BUTTON_RIGHT
 689+#define MOUSE_MIDDLE_BUTTON MOUSE_BUTTON_MIDDLE
 690+
 691+// Mouse buttons
 692+typedef enum {
 693+    MOUSE_BUTTON_LEFT    = 0,       // Mouse button left
 694+    MOUSE_BUTTON_RIGHT   = 1,       // Mouse button right
 695+    MOUSE_BUTTON_MIDDLE  = 2,       // Mouse button middle (pressed wheel)
 696+    MOUSE_BUTTON_SIDE    = 3,       // Mouse button side (advanced mouse device)
 697+    MOUSE_BUTTON_EXTRA   = 4,       // Mouse button extra (advanced mouse device)
 698+    MOUSE_BUTTON_FORWARD = 5,       // Mouse button forward (advanced mouse device)
 699+    MOUSE_BUTTON_BACK    = 6,       // Mouse button back (advanced mouse device)
 700+} MouseButton;
 701+
 702+// Mouse cursor
 703+typedef enum {
 704+    MOUSE_CURSOR_DEFAULT       = 0,     // Default pointer shape
 705+    MOUSE_CURSOR_ARROW         = 1,     // Arrow shape
 706+    MOUSE_CURSOR_IBEAM         = 2,     // Text writing cursor shape
 707+    MOUSE_CURSOR_CROSSHAIR     = 3,     // Cross shape
 708+    MOUSE_CURSOR_POINTING_HAND = 4,     // Pointing hand cursor
 709+    MOUSE_CURSOR_RESIZE_EW     = 5,     // Horizontal resize/move arrow shape
 710+    MOUSE_CURSOR_RESIZE_NS     = 6,     // Vertical resize/move arrow shape
 711+    MOUSE_CURSOR_RESIZE_NWSE   = 7,     // Top-left to bottom-right diagonal resize/move arrow shape
 712+    MOUSE_CURSOR_RESIZE_NESW   = 8,     // The top-right to bottom-left diagonal resize/move arrow shape
 713+    MOUSE_CURSOR_RESIZE_ALL    = 9,     // The omnidirectional resize/move cursor shape
 714+    MOUSE_CURSOR_NOT_ALLOWED   = 10     // The operation-not-allowed shape
 715+} MouseCursor;
 716+
 717+// Gamepad buttons
 718+typedef enum {
 719+    GAMEPAD_BUTTON_UNKNOWN = 0,         // Unknown button, just for error checking
 720+    GAMEPAD_BUTTON_LEFT_FACE_UP,        // Gamepad left DPAD up button
 721+    GAMEPAD_BUTTON_LEFT_FACE_RIGHT,     // Gamepad left DPAD right button
 722+    GAMEPAD_BUTTON_LEFT_FACE_DOWN,      // Gamepad left DPAD down button
 723+    GAMEPAD_BUTTON_LEFT_FACE_LEFT,      // Gamepad left DPAD left button
 724+    GAMEPAD_BUTTON_RIGHT_FACE_UP,       // Gamepad right button up (i.e. PS3: Triangle, Xbox: Y)
 725+    GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,    // Gamepad right button right (i.e. PS3: Square, Xbox: X)
 726+    GAMEPAD_BUTTON_RIGHT_FACE_DOWN,     // Gamepad right button down (i.e. PS3: Cross, Xbox: A)
 727+    GAMEPAD_BUTTON_RIGHT_FACE_LEFT,     // Gamepad right button left (i.e. PS3: Circle, Xbox: B)
 728+    GAMEPAD_BUTTON_LEFT_TRIGGER_1,      // Gamepad top/back trigger left (first), it could be a trailing button
 729+    GAMEPAD_BUTTON_LEFT_TRIGGER_2,      // Gamepad top/back trigger left (second), it could be a trailing button
 730+    GAMEPAD_BUTTON_RIGHT_TRIGGER_1,     // Gamepad top/back trigger right (one), it could be a trailing button
 731+    GAMEPAD_BUTTON_RIGHT_TRIGGER_2,     // Gamepad top/back trigger right (second), it could be a trailing button
 732+    GAMEPAD_BUTTON_MIDDLE_LEFT,         // Gamepad center buttons, left one (i.e. PS3: Select)
 733+    GAMEPAD_BUTTON_MIDDLE,              // Gamepad center buttons, middle one (i.e. PS3: PS, Xbox: XBOX)
 734+    GAMEPAD_BUTTON_MIDDLE_RIGHT,        // Gamepad center buttons, right one (i.e. PS3: Start)
 735+    GAMEPAD_BUTTON_LEFT_THUMB,          // Gamepad joystick pressed button left
 736+    GAMEPAD_BUTTON_RIGHT_THUMB          // Gamepad joystick pressed button right
 737+} GamepadButton;
 738+
 739+// Gamepad axis
 740+typedef enum {
 741+    GAMEPAD_AXIS_LEFT_X        = 0,     // Gamepad left stick X axis
 742+    GAMEPAD_AXIS_LEFT_Y        = 1,     // Gamepad left stick Y axis
 743+    GAMEPAD_AXIS_RIGHT_X       = 2,     // Gamepad right stick X axis
 744+    GAMEPAD_AXIS_RIGHT_Y       = 3,     // Gamepad right stick Y axis
 745+    GAMEPAD_AXIS_LEFT_TRIGGER  = 4,     // Gamepad back trigger left, pressure level: [1..-1]
 746+    GAMEPAD_AXIS_RIGHT_TRIGGER = 5      // Gamepad back trigger right, pressure level: [1..-1]
 747+} GamepadAxis;
 748+
 749+// Material map index
 750+typedef enum {
 751+    MATERIAL_MAP_ALBEDO = 0,        // Albedo material (same as: MATERIAL_MAP_DIFFUSE)
 752+    MATERIAL_MAP_METALNESS,         // Metalness material (same as: MATERIAL_MAP_SPECULAR)
 753+    MATERIAL_MAP_NORMAL,            // Normal material
 754+    MATERIAL_MAP_ROUGHNESS,         // Roughness material
 755+    MATERIAL_MAP_OCCLUSION,         // Ambient occlusion material
 756+    MATERIAL_MAP_EMISSION,          // Emission material
 757+    MATERIAL_MAP_HEIGHT,            // Heightmap material
 758+    MATERIAL_MAP_CUBEMAP,           // Cubemap material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
 759+    MATERIAL_MAP_IRRADIANCE,        // Irradiance material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
 760+    MATERIAL_MAP_PREFILTER,         // Prefilter material (NOTE: Uses GL_TEXTURE_CUBE_MAP)
 761+    MATERIAL_MAP_BRDF               // Brdf material
 762+} MaterialMapIndex;
 763+
 764+#define MATERIAL_MAP_DIFFUSE      MATERIAL_MAP_ALBEDO
 765+#define MATERIAL_MAP_SPECULAR     MATERIAL_MAP_METALNESS
 766+
 767+// Shader location index
 768+typedef enum {
 769+    SHADER_LOC_VERTEX_POSITION = 0, // Shader location: vertex attribute: position
 770+    SHADER_LOC_VERTEX_TEXCOORD01,   // Shader location: vertex attribute: texcoord01
 771+    SHADER_LOC_VERTEX_TEXCOORD02,   // Shader location: vertex attribute: texcoord02
 772+    SHADER_LOC_VERTEX_NORMAL,       // Shader location: vertex attribute: normal
 773+    SHADER_LOC_VERTEX_TANGENT,      // Shader location: vertex attribute: tangent
 774+    SHADER_LOC_VERTEX_COLOR,        // Shader location: vertex attribute: color
 775+    SHADER_LOC_MATRIX_MVP,          // Shader location: matrix uniform: model-view-projection
 776+    SHADER_LOC_MATRIX_VIEW,         // Shader location: matrix uniform: view (camera transform)
 777+    SHADER_LOC_MATRIX_PROJECTION,   // Shader location: matrix uniform: projection
 778+    SHADER_LOC_MATRIX_MODEL,        // Shader location: matrix uniform: model (transform)
 779+    SHADER_LOC_MATRIX_NORMAL,       // Shader location: matrix uniform: normal
 780+    SHADER_LOC_VECTOR_VIEW,         // Shader location: vector uniform: view
 781+    SHADER_LOC_COLOR_DIFFUSE,       // Shader location: vector uniform: diffuse color
 782+    SHADER_LOC_COLOR_SPECULAR,      // Shader location: vector uniform: specular color
 783+    SHADER_LOC_COLOR_AMBIENT,       // Shader location: vector uniform: ambient color
 784+    SHADER_LOC_MAP_ALBEDO,          // Shader location: sampler2d texture: albedo (same as: SHADER_LOC_MAP_DIFFUSE)
 785+    SHADER_LOC_MAP_METALNESS,       // Shader location: sampler2d texture: metalness (same as: SHADER_LOC_MAP_SPECULAR)
 786+    SHADER_LOC_MAP_NORMAL,          // Shader location: sampler2d texture: normal
 787+    SHADER_LOC_MAP_ROUGHNESS,       // Shader location: sampler2d texture: roughness
 788+    SHADER_LOC_MAP_OCCLUSION,       // Shader location: sampler2d texture: occlusion
 789+    SHADER_LOC_MAP_EMISSION,        // Shader location: sampler2d texture: emission
 790+    SHADER_LOC_MAP_HEIGHT,          // Shader location: sampler2d texture: height
 791+    SHADER_LOC_MAP_CUBEMAP,         // Shader location: samplerCube texture: cubemap
 792+    SHADER_LOC_MAP_IRRADIANCE,      // Shader location: samplerCube texture: irradiance
 793+    SHADER_LOC_MAP_PREFILTER,       // Shader location: samplerCube texture: prefilter
 794+    SHADER_LOC_MAP_BRDF             // Shader location: sampler2d texture: brdf
 795+} ShaderLocationIndex;
 796+
 797+#define SHADER_LOC_MAP_DIFFUSE      SHADER_LOC_MAP_ALBEDO
 798+#define SHADER_LOC_MAP_SPECULAR     SHADER_LOC_MAP_METALNESS
 799+
 800+// Shader uniform data type
 801+typedef enum {
 802+    SHADER_UNIFORM_FLOAT = 0,       // Shader uniform type: float
 803+    SHADER_UNIFORM_VEC2,            // Shader uniform type: vec2 (2 float)
 804+    SHADER_UNIFORM_VEC3,            // Shader uniform type: vec3 (3 float)
 805+    SHADER_UNIFORM_VEC4,            // Shader uniform type: vec4 (4 float)
 806+    SHADER_UNIFORM_INT,             // Shader uniform type: int
 807+    SHADER_UNIFORM_IVEC2,           // Shader uniform type: ivec2 (2 int)
 808+    SHADER_UNIFORM_IVEC3,           // Shader uniform type: ivec3 (3 int)
 809+    SHADER_UNIFORM_IVEC4,           // Shader uniform type: ivec4 (4 int)
 810+    SHADER_UNIFORM_SAMPLER2D        // Shader uniform type: sampler2d
 811+} ShaderUniformDataType;
 812+
 813+// Shader attribute data types
 814+typedef enum {
 815+    SHADER_ATTRIB_FLOAT = 0,        // Shader attribute type: float
 816+    SHADER_ATTRIB_VEC2,             // Shader attribute type: vec2 (2 float)
 817+    SHADER_ATTRIB_VEC3,             // Shader attribute type: vec3 (3 float)
 818+    SHADER_ATTRIB_VEC4              // Shader attribute type: vec4 (4 float)
 819+} ShaderAttributeDataType;
 820+
 821+// Pixel formats
 822+// NOTE: Support depends on OpenGL version and platform
 823+typedef enum {
 824+    PIXELFORMAT_UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
 825+    PIXELFORMAT_UNCOMPRESSED_GRAY_ALPHA,    // 8*2 bpp (2 channels)
 826+    PIXELFORMAT_UNCOMPRESSED_R5G6B5,        // 16 bpp
 827+    PIXELFORMAT_UNCOMPRESSED_R8G8B8,        // 24 bpp
 828+    PIXELFORMAT_UNCOMPRESSED_R5G5B5A1,      // 16 bpp (1 bit alpha)
 829+    PIXELFORMAT_UNCOMPRESSED_R4G4B4A4,      // 16 bpp (4 bit alpha)
 830+    PIXELFORMAT_UNCOMPRESSED_R8G8B8A8,      // 32 bpp
 831+    PIXELFORMAT_UNCOMPRESSED_R32,           // 32 bpp (1 channel - float)
 832+    PIXELFORMAT_UNCOMPRESSED_R32G32B32,     // 32*3 bpp (3 channels - float)
 833+    PIXELFORMAT_UNCOMPRESSED_R32G32B32A32,  // 32*4 bpp (4 channels - float)
 834+    PIXELFORMAT_UNCOMPRESSED_R16,           // 16 bpp (1 channel - half float)
 835+    PIXELFORMAT_UNCOMPRESSED_R16G16B16,     // 16*3 bpp (3 channels - half float)
 836+    PIXELFORMAT_UNCOMPRESSED_R16G16B16A16,  // 16*4 bpp (4 channels - half float)
 837+    PIXELFORMAT_COMPRESSED_DXT1_RGB,        // 4 bpp (no alpha)
 838+    PIXELFORMAT_COMPRESSED_DXT1_RGBA,       // 4 bpp (1 bit alpha)
 839+    PIXELFORMAT_COMPRESSED_DXT3_RGBA,       // 8 bpp
 840+    PIXELFORMAT_COMPRESSED_DXT5_RGBA,       // 8 bpp
 841+    PIXELFORMAT_COMPRESSED_ETC1_RGB,        // 4 bpp
 842+    PIXELFORMAT_COMPRESSED_ETC2_RGB,        // 4 bpp
 843+    PIXELFORMAT_COMPRESSED_ETC2_EAC_RGBA,   // 8 bpp
 844+    PIXELFORMAT_COMPRESSED_PVRT_RGB,        // 4 bpp
 845+    PIXELFORMAT_COMPRESSED_PVRT_RGBA,       // 4 bpp
 846+    PIXELFORMAT_COMPRESSED_ASTC_4x4_RGBA,   // 8 bpp
 847+    PIXELFORMAT_COMPRESSED_ASTC_8x8_RGBA    // 2 bpp
 848+} PixelFormat;
 849+
 850+// Texture parameters: filter mode
 851+// NOTE 1: Filtering considers mipmaps if available in the texture
 852+// NOTE 2: Filter is accordingly set for minification and magnification
 853+typedef enum {
 854+    TEXTURE_FILTER_POINT = 0,               // No filter, just pixel approximation
 855+    TEXTURE_FILTER_BILINEAR,                // Linear filtering
 856+    TEXTURE_FILTER_TRILINEAR,               // Trilinear filtering (linear with mipmaps)
 857+    TEXTURE_FILTER_ANISOTROPIC_4X,          // Anisotropic filtering 4x
 858+    TEXTURE_FILTER_ANISOTROPIC_8X,          // Anisotropic filtering 8x
 859+    TEXTURE_FILTER_ANISOTROPIC_16X,         // Anisotropic filtering 16x
 860+} TextureFilter;
 861+
 862+// Texture parameters: wrap mode
 863+typedef enum {
 864+    TEXTURE_WRAP_REPEAT = 0,                // Repeats texture in tiled mode
 865+    TEXTURE_WRAP_CLAMP,                     // Clamps texture to edge pixel in tiled mode
 866+    TEXTURE_WRAP_MIRROR_REPEAT,             // Mirrors and repeats the texture in tiled mode
 867+    TEXTURE_WRAP_MIRROR_CLAMP               // Mirrors and clamps to border the texture in tiled mode
 868+} TextureWrap;
 869+
 870+// Cubemap layouts
 871+typedef enum {
 872+    CUBEMAP_LAYOUT_AUTO_DETECT = 0,         // Automatically detect layout type
 873+    CUBEMAP_LAYOUT_LINE_VERTICAL,           // Layout is defined by a vertical line with faces
 874+    CUBEMAP_LAYOUT_LINE_HORIZONTAL,         // Layout is defined by a horizontal line with faces
 875+    CUBEMAP_LAYOUT_CROSS_THREE_BY_FOUR,     // Layout is defined by a 3x4 cross with cubemap faces
 876+    CUBEMAP_LAYOUT_CROSS_FOUR_BY_THREE,     // Layout is defined by a 4x3 cross with cubemap faces
 877+    CUBEMAP_LAYOUT_PANORAMA                 // Layout is defined by a panorama image (equirrectangular map)
 878+} CubemapLayout;
 879+
 880+// Font type, defines generation method
 881+typedef enum {
 882+    FONT_DEFAULT = 0,               // Default font generation, anti-aliased
 883+    FONT_BITMAP,                    // Bitmap font generation, no anti-aliasing
 884+    FONT_SDF                        // SDF font generation, requires external shader
 885+} FontType;
 886+
 887+// Color blending modes (pre-defined)
 888+typedef enum {
 889+    BLEND_ALPHA = 0,                // Blend textures considering alpha (default)
 890+    BLEND_ADDITIVE,                 // Blend textures adding colors
 891+    BLEND_MULTIPLIED,               // Blend textures multiplying colors
 892+    BLEND_ADD_COLORS,               // Blend textures adding colors (alternative)
 893+    BLEND_SUBTRACT_COLORS,          // Blend textures subtracting colors (alternative)
 894+    BLEND_ALPHA_PREMULTIPLY,        // Blend premultiplied textures considering alpha
 895+    BLEND_CUSTOM,                   // Blend textures using custom src/dst factors (use rlSetBlendFactors())
 896+    BLEND_CUSTOM_SEPARATE           // Blend textures using custom rgb/alpha separate src/dst factors (use rlSetBlendFactorsSeparate())
 897+} BlendMode;
 898+
 899+// Gesture
 900+// NOTE: Provided as bit-wise flags to enable only desired gestures
 901+typedef enum {
 902+    GESTURE_NONE        = 0,        // No gesture
 903+    GESTURE_TAP         = 1,        // Tap gesture
 904+    GESTURE_DOUBLETAP   = 2,        // Double tap gesture
 905+    GESTURE_HOLD        = 4,        // Hold gesture
 906+    GESTURE_DRAG        = 8,        // Drag gesture
 907+    GESTURE_SWIPE_RIGHT = 16,       // Swipe right gesture
 908+    GESTURE_SWIPE_LEFT  = 32,       // Swipe left gesture
 909+    GESTURE_SWIPE_UP    = 64,       // Swipe up gesture
 910+    GESTURE_SWIPE_DOWN  = 128,      // Swipe down gesture
 911+    GESTURE_PINCH_IN    = 256,      // Pinch in gesture
 912+    GESTURE_PINCH_OUT   = 512       // Pinch out gesture
 913+} Gesture;
 914+
 915+// Camera system modes
 916+typedef enum {
 917+    CAMERA_CUSTOM = 0,              // Custom camera
 918+    CAMERA_FREE,                    // Free camera
 919+    CAMERA_ORBITAL,                 // Orbital camera
 920+    CAMERA_FIRST_PERSON,            // First person camera
 921+    CAMERA_THIRD_PERSON             // Third person camera
 922+} CameraMode;
 923+
 924+// Camera projection
 925+typedef enum {
 926+    CAMERA_PERSPECTIVE = 0,         // Perspective projection
 927+    CAMERA_ORTHOGRAPHIC             // Orthographic projection
 928+} CameraProjection;
 929+
 930+// N-patch layout
 931+typedef enum {
 932+    NPATCH_NINE_PATCH = 0,          // Npatch layout: 3x3 tiles
 933+    NPATCH_THREE_PATCH_VERTICAL,    // Npatch layout: 1x3 tiles
 934+    NPATCH_THREE_PATCH_HORIZONTAL   // Npatch layout: 3x1 tiles
 935+} NPatchLayout;
 936+
 937+// Callbacks to hook some internal functions
 938+// WARNING: These callbacks are intended for advance users
 939+typedef void (*TraceLogCallback)(int logLevel, const char *text, va_list args);  // Logging: Redirect trace log messages
 940+typedef unsigned char *(*LoadFileDataCallback)(const char *fileName, int *dataSize);    // FileIO: Load binary data
 941+typedef bool (*SaveFileDataCallback)(const char *fileName, void *data, int dataSize);   // FileIO: Save binary data
 942+typedef char *(*LoadFileTextCallback)(const char *fileName);            // FileIO: Load text data
 943+typedef bool (*SaveFileTextCallback)(const char *fileName, char *text); // FileIO: Save text data
 944+
 945+//------------------------------------------------------------------------------------
 946+// Global Variables Definition
 947+//------------------------------------------------------------------------------------
 948+// It's lonely here...
 949+
 950+//------------------------------------------------------------------------------------
 951+// Window and Graphics Device Functions (Module: core)
 952+//------------------------------------------------------------------------------------
 953+
 954+#if defined(__cplusplus)
 955+extern "C" {            // Prevents name mangling of functions
 956+#endif
 957+
 958+// Window-related functions
 959+RLAPI void InitWindow(int width, int height, const char *title);  // Initialize window and OpenGL context
 960+RLAPI void CloseWindow(void);                                     // Close window and unload OpenGL context
 961+RLAPI bool WindowShouldClose(void);                               // Check if application should close (KEY_ESCAPE pressed or windows close icon clicked)
 962+RLAPI bool IsWindowReady(void);                                   // Check if window has been initialized successfully
 963+RLAPI bool IsWindowFullscreen(void);                              // Check if window is currently fullscreen
 964+RLAPI bool IsWindowHidden(void);                                  // Check if window is currently hidden (only PLATFORM_DESKTOP)
 965+RLAPI bool IsWindowMinimized(void);                               // Check if window is currently minimized (only PLATFORM_DESKTOP)
 966+RLAPI bool IsWindowMaximized(void);                               // Check if window is currently maximized (only PLATFORM_DESKTOP)
 967+RLAPI bool IsWindowFocused(void);                                 // Check if window is currently focused (only PLATFORM_DESKTOP)
 968+RLAPI bool IsWindowResized(void);                                 // Check if window has been resized last frame
 969+RLAPI bool IsWindowState(unsigned int flag);                      // Check if one specific window flag is enabled
 970+RLAPI void SetWindowState(unsigned int flags);                    // Set window configuration state using flags (only PLATFORM_DESKTOP)
 971+RLAPI void ClearWindowState(unsigned int flags);                  // Clear window configuration state flags
 972+RLAPI void ToggleFullscreen(void);                                // Toggle window state: fullscreen/windowed (only PLATFORM_DESKTOP)
 973+RLAPI void ToggleBorderlessWindowed(void);                        // Toggle window state: borderless windowed (only PLATFORM_DESKTOP)
 974+RLAPI void MaximizeWindow(void);                                  // Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
 975+RLAPI void MinimizeWindow(void);                                  // Set window state: minimized, if resizable (only PLATFORM_DESKTOP)
 976+RLAPI void RestoreWindow(void);                                   // Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
 977+RLAPI void SetWindowIcon(Image image);                            // Set icon for window (single image, RGBA 32bit, only PLATFORM_DESKTOP)
 978+RLAPI void SetWindowIcons(Image *images, int count);              // Set icon for window (multiple images, RGBA 32bit, only PLATFORM_DESKTOP)
 979+RLAPI void SetWindowTitle(const char *title);                     // Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
 980+RLAPI void SetWindowPosition(int x, int y);                       // Set window position on screen (only PLATFORM_DESKTOP)
 981+RLAPI void SetWindowMonitor(int monitor);                         // Set monitor for the current window
 982+RLAPI void SetWindowMinSize(int width, int height);               // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
 983+RLAPI void SetWindowMaxSize(int width, int height);               // Set window maximum dimensions (for FLAG_WINDOW_RESIZABLE)
 984+RLAPI void SetWindowSize(int width, int height);                  // Set window dimensions
 985+RLAPI void SetWindowOpacity(float opacity);                       // Set window opacity [0.0f..1.0f] (only PLATFORM_DESKTOP)
 986+RLAPI void SetWindowFocused(void);                                // Set window focused (only PLATFORM_DESKTOP)
 987+RLAPI void *GetWindowHandle(void);                                // Get native window handle
 988+RLAPI int GetScreenWidth(void);                                   // Get current screen width
 989+RLAPI int GetScreenHeight(void);                                  // Get current screen height
 990+RLAPI int GetRenderWidth(void);                                   // Get current render width (it considers HiDPI)
 991+RLAPI int GetRenderHeight(void);                                  // Get current render height (it considers HiDPI)
 992+RLAPI int GetMonitorCount(void);                                  // Get number of connected monitors
 993+RLAPI int GetCurrentMonitor(void);                                // Get current connected monitor
 994+RLAPI Vector2 GetMonitorPosition(int monitor);                    // Get specified monitor position
 995+RLAPI int GetMonitorWidth(int monitor);                           // Get specified monitor width (current video mode used by monitor)
 996+RLAPI int GetMonitorHeight(int monitor);                          // Get specified monitor height (current video mode used by monitor)
 997+RLAPI int GetMonitorPhysicalWidth(int monitor);                   // Get specified monitor physical width in millimetres
 998+RLAPI int GetMonitorPhysicalHeight(int monitor);                  // Get specified monitor physical height in millimetres
 999+RLAPI int GetMonitorRefreshRate(int monitor);                     // Get specified monitor refresh rate
1000+RLAPI Vector2 GetWindowPosition(void);                            // Get window position XY on monitor
1001+RLAPI Vector2 GetWindowScaleDPI(void);                            // Get window scale DPI factor
1002+RLAPI const char *GetMonitorName(int monitor);                    // Get the human-readable, UTF-8 encoded name of the specified monitor
1003+RLAPI void SetClipboardText(const char *text);                    // Set clipboard text content
1004+RLAPI const char *GetClipboardText(void);                         // Get clipboard text content
1005+RLAPI void EnableEventWaiting(void);                              // Enable waiting for events on EndDrawing(), no automatic event polling
1006+RLAPI void DisableEventWaiting(void);                             // Disable waiting for events on EndDrawing(), automatic events polling
1007+
1008+// Cursor-related functions
1009+RLAPI void ShowCursor(void);                                      // Shows cursor
1010+RLAPI void HideCursor(void);                                      // Hides cursor
1011+RLAPI bool IsCursorHidden(void);                                  // Check if cursor is not visible
1012+RLAPI void EnableCursor(void);                                    // Enables cursor (unlock cursor)
1013+RLAPI void DisableCursor(void);                                   // Disables cursor (lock cursor)
1014+RLAPI bool IsCursorOnScreen(void);                                // Check if cursor is on the screen
1015+
1016+// Drawing-related functions
1017+RLAPI void ClearBackground(Color color);                          // Set background color (framebuffer clear color)
1018+RLAPI void BeginDrawing(void);                                    // Setup canvas (framebuffer) to start drawing
1019+RLAPI void EndDrawing(void);                                      // End canvas drawing and swap buffers (double buffering)
1020+RLAPI void BeginMode2D(Camera2D camera);                          // Begin 2D mode with custom camera (2D)
1021+RLAPI void EndMode2D(void);                                       // Ends 2D mode with custom camera
1022+RLAPI void BeginMode3D(Camera3D camera);                          // Begin 3D mode with custom camera (3D)
1023+RLAPI void EndMode3D(void);                                       // Ends 3D mode and returns to default 2D orthographic mode
1024+RLAPI void BeginTextureMode(RenderTexture2D target);              // Begin drawing to render texture
1025+RLAPI void EndTextureMode(void);                                  // Ends drawing to render texture
1026+RLAPI void BeginShaderMode(Shader shader);                        // Begin custom shader drawing
1027+RLAPI void EndShaderMode(void);                                   // End custom shader drawing (use default shader)
1028+RLAPI void BeginBlendMode(int mode);                              // Begin blending mode (alpha, additive, multiplied, subtract, custom)
1029+RLAPI void EndBlendMode(void);                                    // End blending mode (reset to default: alpha blending)
1030+RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing)
1031+RLAPI void EndScissorMode(void);                                  // End scissor mode
1032+RLAPI void BeginVrStereoMode(VrStereoConfig config);              // Begin stereo rendering (requires VR simulator)
1033+RLAPI void EndVrStereoMode(void);                                 // End stereo rendering (requires VR simulator)
1034+
1035+// VR stereo config functions for VR simulator
1036+RLAPI VrStereoConfig LoadVrStereoConfig(VrDeviceInfo device);     // Load VR stereo config for VR simulator device parameters
1037+RLAPI void UnloadVrStereoConfig(VrStereoConfig config);           // Unload VR stereo config
1038+
1039+// Shader management functions
1040+// NOTE: Shader functionality is not available on OpenGL 1.1
1041+RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName);   // Load shader from files and bind default locations
1042+RLAPI Shader LoadShaderFromMemory(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
1043+RLAPI bool IsShaderReady(Shader shader);                                   // Check if a shader is ready
1044+RLAPI int GetShaderLocation(Shader shader, const char *uniformName);       // Get shader uniform location
1045+RLAPI int GetShaderLocationAttrib(Shader shader, const char *attribName);  // Get shader attribute location
1046+RLAPI void SetShaderValue(Shader shader, int locIndex, const void *value, int uniformType);               // Set shader uniform value
1047+RLAPI void SetShaderValueV(Shader shader, int locIndex, const void *value, int uniformType, int count);   // Set shader uniform value vector
1048+RLAPI void SetShaderValueMatrix(Shader shader, int locIndex, Matrix mat);         // Set shader uniform value (matrix 4x4)
1049+RLAPI void SetShaderValueTexture(Shader shader, int locIndex, Texture2D texture); // Set shader uniform value for texture (sampler2d)
1050+RLAPI void UnloadShader(Shader shader);                                    // Unload shader from GPU memory (VRAM)
1051+
1052+// Screen-space-related functions
1053+RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera);            // Get a ray trace from mouse position
1054+RLAPI Ray GetViewRay(Vector2 mousePosition, Camera camera, float width, float height); // Get a ray trace from mouse position in a viewport
1055+RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera);        // Get the screen space position for a 3d world space position
1056+RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Get size position for a 3d world space position
1057+RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera);    // Get the screen space position for a 2d camera world space position
1058+RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera);    // Get the world space position for a 2d camera screen space position
1059+RLAPI Matrix GetCameraMatrix(Camera camera);                            // Get camera transform matrix (view matrix)
1060+RLAPI Matrix GetCameraMatrix2D(Camera2D camera);                        // Get camera 2d transform matrix
1061+
1062+// Timing-related functions
1063+RLAPI void SetTargetFPS(int fps);                                 // Set target FPS (maximum)
1064+RLAPI float GetFrameTime(void);                                   // Get time in seconds for last frame drawn (delta time)
1065+RLAPI double GetTime(void);                                       // Get elapsed time in seconds since InitWindow()
1066+RLAPI int GetFPS(void);                                           // Get current FPS
1067+
1068+// Custom frame control functions
1069+// NOTE: Those functions are intended for advance users that want full control over the frame processing
1070+// By default EndDrawing() does this job: draws everything + SwapScreenBuffer() + manage frame timing + PollInputEvents()
1071+// To avoid that behaviour and control frame processes manually, enable in config.h: SUPPORT_CUSTOM_FRAME_CONTROL
1072+RLAPI void SwapScreenBuffer(void);                                // Swap back buffer with front buffer (screen drawing)
1073+RLAPI void PollInputEvents(void);                                 // Register all input events
1074+RLAPI void WaitTime(double seconds);                              // Wait for some time (halt program execution)
1075+
1076+// Random values generation functions
1077+RLAPI void SetRandomSeed(unsigned int seed);                      // Set the seed for the random number generator
1078+RLAPI int GetRandomValue(int min, int max);                       // Get a random value between min and max (both included)
1079+RLAPI int *LoadRandomSequence(unsigned int count, int min, int max); // Load random values sequence, no values repeated
1080+RLAPI void UnloadRandomSequence(int *sequence);                   // Unload random values sequence
1081+
1082+// Misc. functions
1083+RLAPI void TakeScreenshot(const char *fileName);                  // Takes a screenshot of current screen (filename extension defines format)
1084+RLAPI void SetConfigFlags(unsigned int flags);                    // Setup init configuration flags (view FLAGS)
1085+RLAPI void OpenURL(const char *url);                              // Open URL with default system browser (if available)
1086+
1087+// NOTE: Following functions implemented in module [utils]
1088+//------------------------------------------------------------------
1089+RLAPI void TraceLog(int logLevel, const char *text, ...);         // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR...)
1090+RLAPI void SetTraceLogLevel(int logLevel);                        // Set the current threshold (minimum) log level
1091+RLAPI void *MemAlloc(unsigned int size);                          // Internal memory allocator
1092+RLAPI void *MemRealloc(void *ptr, unsigned int size);             // Internal memory reallocator
1093+RLAPI void MemFree(void *ptr);                                    // Internal memory free
1094+
1095+// Set custom callbacks
1096+// WARNING: Callbacks setup is intended for advance users
1097+RLAPI void SetTraceLogCallback(TraceLogCallback callback);         // Set custom trace log
1098+RLAPI void SetLoadFileDataCallback(LoadFileDataCallback callback); // Set custom file binary data loader
1099+RLAPI void SetSaveFileDataCallback(SaveFileDataCallback callback); // Set custom file binary data saver
1100+RLAPI void SetLoadFileTextCallback(LoadFileTextCallback callback); // Set custom file text data loader
1101+RLAPI void SetSaveFileTextCallback(SaveFileTextCallback callback); // Set custom file text data saver
1102+
1103+// Files management functions
1104+RLAPI unsigned char *LoadFileData(const char *fileName, int *dataSize); // Load file data as byte array (read)
1105+RLAPI void UnloadFileData(unsigned char *data);                   // Unload file data allocated by LoadFileData()
1106+RLAPI bool SaveFileData(const char *fileName, void *data, int dataSize); // Save data to file from byte array (write), returns true on success
1107+RLAPI bool ExportDataAsCode(const unsigned char *data, int dataSize, const char *fileName); // Export data to code (.h), returns true on success
1108+RLAPI char *LoadFileText(const char *fileName);                   // Load text data from file (read), returns a '\0' terminated string
1109+RLAPI void UnloadFileText(char *text);                            // Unload file text data allocated by LoadFileText()
1110+RLAPI bool SaveFileText(const char *fileName, char *text);        // Save text data to file (write), string must be '\0' terminated, returns true on success
1111+//------------------------------------------------------------------
1112+
1113+// File system functions
1114+RLAPI bool FileExists(const char *fileName);                      // Check if file exists
1115+RLAPI bool DirectoryExists(const char *dirPath);                  // Check if a directory path exists
1116+RLAPI bool IsFileExtension(const char *fileName, const char *ext); // Check file extension (including point: .png, .wav)
1117+RLAPI int GetFileLength(const char *fileName);                    // Get file length in bytes (NOTE: GetFileSize() conflicts with windows.h)
1118+RLAPI const char *GetFileExtension(const char *fileName);         // Get pointer to extension for a filename string (includes dot: '.png')
1119+RLAPI const char *GetFileName(const char *filePath);              // Get pointer to filename for a path string
1120+RLAPI const char *GetFileNameWithoutExt(const char *filePath);    // Get filename string without extension (uses static string)
1121+RLAPI const char *GetDirectoryPath(const char *filePath);         // Get full path for a given fileName with path (uses static string)
1122+RLAPI const char *GetPrevDirectoryPath(const char *dirPath);      // Get previous directory path for a given path (uses static string)
1123+RLAPI const char *GetWorkingDirectory(void);                      // Get current working directory (uses static string)
1124+RLAPI const char *GetApplicationDirectory(void);                  // Get the directory of the running application (uses static string)
1125+RLAPI bool ChangeDirectory(const char *dir);                      // Change working directory, return true on success
1126+RLAPI bool IsPathFile(const char *path);                          // Check if a given path is a file or a directory
1127+RLAPI FilePathList LoadDirectoryFiles(const char *dirPath);       // Load directory filepaths
1128+RLAPI FilePathList LoadDirectoryFilesEx(const char *basePath, const char *filter, bool scanSubdirs); // Load directory filepaths with extension filtering and recursive directory scan
1129+RLAPI void UnloadDirectoryFiles(FilePathList files);              // Unload filepaths
1130+RLAPI bool IsFileDropped(void);                                   // Check if a file has been dropped into window
1131+RLAPI FilePathList LoadDroppedFiles(void);                        // Load dropped filepaths
1132+RLAPI void UnloadDroppedFiles(FilePathList files);                // Unload dropped filepaths
1133+RLAPI long GetFileModTime(const char *fileName);                  // Get file modification time (last write time)
1134+
1135+// Compression/Encoding functionality
1136+RLAPI unsigned char *CompressData(const unsigned char *data, int dataSize, int *compDataSize);        // Compress data (DEFLATE algorithm), memory must be MemFree()
1137+RLAPI unsigned char *DecompressData(const unsigned char *compData, int compDataSize, int *dataSize);  // Decompress data (DEFLATE algorithm), memory must be MemFree()
1138+RLAPI char *EncodeDataBase64(const unsigned char *data, int dataSize, int *outputSize);               // Encode data to Base64 string, memory must be MemFree()
1139+RLAPI unsigned char *DecodeDataBase64(const unsigned char *data, int *outputSize);                    // Decode Base64 string data, memory must be MemFree()
1140+
1141+// Automation events functionality
1142+RLAPI AutomationEventList LoadAutomationEventList(const char *fileName);                // Load automation events list from file, NULL for empty list, capacity = MAX_AUTOMATION_EVENTS
1143+RLAPI void UnloadAutomationEventList(AutomationEventList list);                        // Unload automation events list from file
1144+RLAPI bool ExportAutomationEventList(AutomationEventList list, const char *fileName);   // Export automation events list as text file
1145+RLAPI void SetAutomationEventList(AutomationEventList *list);                           // Set automation event list to record to
1146+RLAPI void SetAutomationEventBaseFrame(int frame);                                      // Set automation event internal base frame to start recording
1147+RLAPI void StartAutomationEventRecording(void);                                         // Start recording automation events (AutomationEventList must be set)
1148+RLAPI void StopAutomationEventRecording(void);                                          // Stop recording automation events
1149+RLAPI void PlayAutomationEvent(AutomationEvent event);                                  // Play a recorded automation event
1150+
1151+//------------------------------------------------------------------------------------
1152+// Input Handling Functions (Module: core)
1153+//------------------------------------------------------------------------------------
1154+
1155+// Input-related functions: keyboard
1156+RLAPI bool IsKeyPressed(int key);                             // Check if a key has been pressed once
1157+RLAPI bool IsKeyPressedRepeat(int key);                       // Check if a key has been pressed again (Only PLATFORM_DESKTOP)
1158+RLAPI bool IsKeyDown(int key);                                // Check if a key is being pressed
1159+RLAPI bool IsKeyReleased(int key);                            // Check if a key has been released once
1160+RLAPI bool IsKeyUp(int key);                                  // Check if a key is NOT being pressed
1161+RLAPI int GetKeyPressed(void);                                // Get key pressed (keycode), call it multiple times for keys queued, returns 0 when the queue is empty
1162+RLAPI int GetCharPressed(void);                               // Get char pressed (unicode), call it multiple times for chars queued, returns 0 when the queue is empty
1163+RLAPI void SetExitKey(int key);                               // Set a custom key to exit program (default is ESC)
1164+
1165+// Input-related functions: gamepads
1166+RLAPI bool IsGamepadAvailable(int gamepad);                   // Check if a gamepad is available
1167+RLAPI const char *GetGamepadName(int gamepad);                // Get gamepad internal name id
1168+RLAPI bool IsGamepadButtonPressed(int gamepad, int button);   // Check if a gamepad button has been pressed once
1169+RLAPI bool IsGamepadButtonDown(int gamepad, int button);      // Check if a gamepad button is being pressed
1170+RLAPI bool IsGamepadButtonReleased(int gamepad, int button);  // Check if a gamepad button has been released once
1171+RLAPI bool IsGamepadButtonUp(int gamepad, int button);        // Check if a gamepad button is NOT being pressed
1172+RLAPI int GetGamepadButtonPressed(void);                      // Get the last gamepad button pressed
1173+RLAPI int GetGamepadAxisCount(int gamepad);                   // Get gamepad axis count for a gamepad
1174+RLAPI float GetGamepadAxisMovement(int gamepad, int axis);    // Get axis movement value for a gamepad axis
1175+RLAPI int SetGamepadMappings(const char *mappings);           // Set internal gamepad mappings (SDL_GameControllerDB)
1176+
1177+// Input-related functions: mouse
1178+RLAPI bool IsMouseButtonPressed(int button);                  // Check if a mouse button has been pressed once
1179+RLAPI bool IsMouseButtonDown(int button);                     // Check if a mouse button is being pressed
1180+RLAPI bool IsMouseButtonReleased(int button);                 // Check if a mouse button has been released once
1181+RLAPI bool IsMouseButtonUp(int button);                       // Check if a mouse button is NOT being pressed
1182+RLAPI int GetMouseX(void);                                    // Get mouse position X
1183+RLAPI int GetMouseY(void);                                    // Get mouse position Y
1184+RLAPI Vector2 GetMousePosition(void);                         // Get mouse position XY
1185+RLAPI Vector2 GetMouseDelta(void);                            // Get mouse delta between frames
1186+RLAPI void SetMousePosition(int x, int y);                    // Set mouse position XY
1187+RLAPI void SetMouseOffset(int offsetX, int offsetY);          // Set mouse offset
1188+RLAPI void SetMouseScale(float scaleX, float scaleY);         // Set mouse scaling
1189+RLAPI float GetMouseWheelMove(void);                          // Get mouse wheel movement for X or Y, whichever is larger
1190+RLAPI Vector2 GetMouseWheelMoveV(void);                       // Get mouse wheel movement for both X and Y
1191+RLAPI void SetMouseCursor(int cursor);                        // Set mouse cursor
1192+
1193+// Input-related functions: touch
1194+RLAPI int GetTouchX(void);                                    // Get touch position X for touch point 0 (relative to screen size)
1195+RLAPI int GetTouchY(void);                                    // Get touch position Y for touch point 0 (relative to screen size)
1196+RLAPI Vector2 GetTouchPosition(int index);                    // Get touch position XY for a touch point index (relative to screen size)
1197+RLAPI int GetTouchPointId(int index);                         // Get touch point identifier for given index
1198+RLAPI int GetTouchPointCount(void);                           // Get number of touch points
1199+
1200+//------------------------------------------------------------------------------------
1201+// Gestures and Touch Handling Functions (Module: rgestures)
1202+//------------------------------------------------------------------------------------
1203+RLAPI void SetGesturesEnabled(unsigned int flags);      // Enable a set of gestures using flags
1204+RLAPI bool IsGestureDetected(unsigned int gesture);     // Check if a gesture have been detected
1205+RLAPI int GetGestureDetected(void);                     // Get latest detected gesture
1206+RLAPI float GetGestureHoldDuration(void);               // Get gesture hold time in milliseconds
1207+RLAPI Vector2 GetGestureDragVector(void);               // Get gesture drag vector
1208+RLAPI float GetGestureDragAngle(void);                  // Get gesture drag angle
1209+RLAPI Vector2 GetGesturePinchVector(void);              // Get gesture pinch delta
1210+RLAPI float GetGesturePinchAngle(void);                 // Get gesture pinch angle
1211+
1212+//------------------------------------------------------------------------------------
1213+// Camera System Functions (Module: rcamera)
1214+//------------------------------------------------------------------------------------
1215+RLAPI void UpdateCamera(Camera *camera, int mode);      // Update camera position for selected mode
1216+RLAPI void UpdateCameraPro(Camera *camera, Vector3 movement, Vector3 rotation, float zoom); // Update camera movement/rotation
1217+
1218+//------------------------------------------------------------------------------------
1219+// Basic Shapes Drawing Functions (Module: shapes)
1220+//------------------------------------------------------------------------------------
1221+// Set texture and rectangle to be used on shapes drawing
1222+// NOTE: It can be useful when using basic shapes and one single font,
1223+// defining a font char white rectangle would allow drawing everything in a single draw call
1224+RLAPI void SetShapesTexture(Texture2D texture, Rectangle source);       // Set texture and rectangle to be used on shapes drawing
1225+RLAPI Texture2D GetShapesTexture(void);                                 // Get texture that is used for shapes drawing
1226+RLAPI Rectangle GetShapesTextureRectangle(void);                        // Get texture source rectangle that is used for shapes drawing
1227+
1228+// Basic shapes drawing functions
1229+RLAPI void DrawPixel(int posX, int posY, Color color);                                                   // Draw a pixel
1230+RLAPI void DrawPixelV(Vector2 position, Color color);                                                    // Draw a pixel (Vector version)
1231+RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color);                // Draw a line
1232+RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color);                                     // Draw a line (using gl lines)
1233+RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color);                       // Draw a line (using triangles/quads)
1234+RLAPI void DrawLineStrip(Vector2 *points, int pointCount, Color color);                                  // Draw lines sequence (using gl lines)
1235+RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color);                   // Draw line segment cubic-bezier in-out interpolation
1236+RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color);                              // Draw a color-filled circle
1237+RLAPI void DrawCircleSector(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color);      // Draw a piece of a circle
1238+RLAPI void DrawCircleSectorLines(Vector2 center, float radius, float startAngle, float endAngle, int segments, Color color); // Draw circle sector outline
1239+RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2);       // Draw a gradient-filled circle
1240+RLAPI void DrawCircleV(Vector2 center, float radius, Color color);                                       // Draw a color-filled circle (Vector version)
1241+RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color);                         // Draw circle outline
1242+RLAPI void DrawCircleLinesV(Vector2 center, float radius, Color color);                                  // Draw circle outline (Vector version)
1243+RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color);             // Draw ellipse
1244+RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color);        // Draw ellipse outline
1245+RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color); // Draw ring
1246+RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, float startAngle, float endAngle, int segments, Color color);    // Draw ring outline
1247+RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color);                        // Draw a color-filled rectangle
1248+RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color);                                  // Draw a color-filled rectangle (Vector version)
1249+RLAPI void DrawRectangleRec(Rectangle rec, Color color);                                                 // Draw a color-filled rectangle
1250+RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color);                 // Draw a color-filled rectangle with pro parameters
1251+RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
1252+RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
1253+RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4);       // Draw a gradient-filled rectangle with custom vertex colors
1254+RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color);                   // Draw rectangle outline
1255+RLAPI void DrawRectangleLinesEx(Rectangle rec, float lineThick, Color color);                            // Draw rectangle outline with extended parameters
1256+RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color);              // Draw rectangle with rounded edges
1257+RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, float lineThick, Color color); // Draw rectangle with rounded edges outline
1258+RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                                // Draw a color-filled triangle (vertex in counter-clockwise order!)
1259+RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color);                           // Draw triangle outline (vertex in counter-clockwise order!)
1260+RLAPI void DrawTriangleFan(Vector2 *points, int pointCount, Color color);                                // Draw a triangle fan defined by points (first vertex is the center)
1261+RLAPI void DrawTriangleStrip(Vector2 *points, int pointCount, Color color);                              // Draw a triangle strip defined by points
1262+RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color);               // Draw a regular polygon (Vector version)
1263+RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color);          // Draw a polygon outline of n sides
1264+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
1265+
1266+// Splines drawing functions
1267+RLAPI void DrawSplineLinear(Vector2 *points, int pointCount, float thick, Color color);                  // Draw spline: Linear, minimum 2 points
1268+RLAPI void DrawSplineBasis(Vector2 *points, int pointCount, float thick, Color color);                   // Draw spline: B-Spline, minimum 4 points
1269+RLAPI void DrawSplineCatmullRom(Vector2 *points, int pointCount, float thick, Color color);              // Draw spline: Catmull-Rom, minimum 4 points
1270+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...]
1271+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...]
1272+RLAPI void DrawSplineSegmentLinear(Vector2 p1, Vector2 p2, float thick, Color color);                    // Draw spline segment: Linear, 2 points
1273+RLAPI void DrawSplineSegmentBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: B-Spline, 4 points
1274+RLAPI void DrawSplineSegmentCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float thick, Color color); // Draw spline segment: Catmull-Rom, 4 points
1275+RLAPI void DrawSplineSegmentBezierQuadratic(Vector2 p1, Vector2 c2, Vector2 p3, float thick, Color color); // Draw spline segment: Quadratic Bezier, 2 points, 1 control point
1276+RLAPI void DrawSplineSegmentBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float thick, Color color); // Draw spline segment: Cubic Bezier, 2 points, 2 control points
1277+
1278+// Spline segment point evaluation functions, for a given t [0.0f .. 1.0f]
1279+RLAPI Vector2 GetSplinePointLinear(Vector2 startPos, Vector2 endPos, float t);                           // Get (evaluate) spline point: Linear
1280+RLAPI Vector2 GetSplinePointBasis(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);              // Get (evaluate) spline point: B-Spline
1281+RLAPI Vector2 GetSplinePointCatmullRom(Vector2 p1, Vector2 p2, Vector2 p3, Vector2 p4, float t);         // Get (evaluate) spline point: Catmull-Rom
1282+RLAPI Vector2 GetSplinePointBezierQuad(Vector2 p1, Vector2 c2, Vector2 p3, float t);                     // Get (evaluate) spline point: Quadratic Bezier
1283+RLAPI Vector2 GetSplinePointBezierCubic(Vector2 p1, Vector2 c2, Vector2 c3, Vector2 p4, float t);        // Get (evaluate) spline point: Cubic Bezier
1284+
1285+// Basic shapes collision detection functions
1286+RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2);                                           // Check collision between two rectangles
1287+RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2);        // Check collision between two circles
1288+RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec);                         // Check collision between circle and rectangle
1289+RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec);                                         // Check if point is inside rectangle
1290+RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius);                       // Check if point is inside circle
1291+RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3);               // Check if point is inside a triangle
1292+RLAPI bool CheckCollisionPointPoly(Vector2 point, Vector2 *points, int pointCount);                      // Check if point is within a polygon described by array of vertices
1293+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
1294+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]
1295+RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2);                                         // Get collision rectangle for two rectangles collision
1296+
1297+//------------------------------------------------------------------------------------
1298+// Texture Loading and Drawing Functions (Module: textures)
1299+//------------------------------------------------------------------------------------
1300+
1301+// Image loading functions
1302+// NOTE: These functions do not require GPU access
1303+RLAPI Image LoadImage(const char *fileName);                                                             // Load image from file into CPU memory (RAM)
1304+RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize);       // Load image from RAW file data
1305+RLAPI Image LoadImageSvg(const char *fileNameOrString, int width, int height);                           // Load image from SVG file data or string with specified size
1306+RLAPI Image LoadImageAnim(const char *fileName, int *frames);                                            // Load image sequence from file (frames appended to image.data)
1307+RLAPI Image LoadImageAnimFromMemory(const char *fileType, const unsigned char *fileData, int dataSize, int *frames); // Load image sequence from memory buffer
1308+RLAPI Image LoadImageFromMemory(const char *fileType, const unsigned char *fileData, int dataSize);      // Load image from memory buffer, fileType refers to extension: i.e. '.png'
1309+RLAPI Image LoadImageFromTexture(Texture2D texture);                                                     // Load image from GPU texture data
1310+RLAPI Image LoadImageFromScreen(void);                                                                   // Load image from screen buffer and (screenshot)
1311+RLAPI bool IsImageReady(Image image);                                                                    // Check if an image is ready
1312+RLAPI void UnloadImage(Image image);                                                                     // Unload image from CPU memory (RAM)
1313+RLAPI bool ExportImage(Image image, const char *fileName);                                               // Export image data to file, returns true on success
1314+RLAPI unsigned char *ExportImageToMemory(Image image, const char *fileType, int *fileSize);              // Export image to memory buffer
1315+RLAPI bool ExportImageAsCode(Image image, const char *fileName);                                         // Export image as code file defining an array of bytes, returns true on success
1316+
1317+// Image generation functions
1318+RLAPI Image GenImageColor(int width, int height, Color color);                                           // Generate image: plain color
1319+RLAPI Image GenImageGradientLinear(int width, int height, int direction, Color start, Color end);        // Generate image: linear gradient, direction in degrees [0..360], 0=Vertical gradient
1320+RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer);      // Generate image: radial gradient
1321+RLAPI Image GenImageGradientSquare(int width, int height, float density, Color inner, Color outer);      // Generate image: square gradient
1322+RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2);    // Generate image: checked
1323+RLAPI Image GenImageWhiteNoise(int width, int height, float factor);                                     // Generate image: white noise
1324+RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale);           // Generate image: perlin noise
1325+RLAPI Image GenImageCellular(int width, int height, int tileSize);                                       // Generate image: cellular algorithm, bigger tileSize means bigger cells
1326+RLAPI Image GenImageText(int width, int height, const char *text);                                       // Generate image: grayscale image from text data
1327+
1328+// Image manipulation functions
1329+RLAPI Image ImageCopy(Image image);                                                                      // Create an image duplicate (useful for transformations)
1330+RLAPI Image ImageFromImage(Image image, Rectangle rec);                                                  // Create an image from another image piece
1331+RLAPI Image ImageText(const char *text, int fontSize, Color color);                                      // Create an image from text (default font)
1332+RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint);         // Create an image from text (custom sprite font)
1333+RLAPI void ImageFormat(Image *image, int newFormat);                                                     // Convert image data to desired format
1334+RLAPI void ImageToPOT(Image *image, Color fill);                                                         // Convert image to POT (power-of-two)
1335+RLAPI void ImageCrop(Image *image, Rectangle crop);                                                      // Crop an image to a defined rectangle
1336+RLAPI void ImageAlphaCrop(Image *image, float threshold);                                                // Crop image depending on alpha value
1337+RLAPI void ImageAlphaClear(Image *image, Color color, float threshold);                                  // Clear alpha channel to desired color
1338+RLAPI void ImageAlphaMask(Image *image, Image alphaMask);                                                // Apply alpha mask to image
1339+RLAPI void ImageAlphaPremultiply(Image *image);                                                          // Premultiply alpha channel
1340+RLAPI void ImageBlurGaussian(Image *image, int blurSize);                                                // Apply Gaussian blur using a box blur approximation
1341+RLAPI void ImageKernelConvolution(Image *image, float* kernel, int kernelSize);                         // Apply Custom Square image convolution kernel
1342+RLAPI void ImageResize(Image *image, int newWidth, int newHeight);                                       // Resize image (Bicubic scaling algorithm)
1343+RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight);                                      // Resize image (Nearest-Neighbor scaling algorithm)
1344+RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color fill);  // Resize canvas and fill with color
1345+RLAPI void ImageMipmaps(Image *image);                                                                   // Compute all mipmap levels for a provided image
1346+RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp);                            // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
1347+RLAPI void ImageFlipVertical(Image *image);                                                              // Flip image vertically
1348+RLAPI void ImageFlipHorizontal(Image *image);                                                            // Flip image horizontally
1349+RLAPI void ImageRotate(Image *image, int degrees);                                                       // Rotate image by input angle in degrees (-359 to 359)
1350+RLAPI void ImageRotateCW(Image *image);                                                                  // Rotate image clockwise 90deg
1351+RLAPI void ImageRotateCCW(Image *image);                                                                 // Rotate image counter-clockwise 90deg
1352+RLAPI void ImageColorTint(Image *image, Color color);                                                    // Modify image color: tint
1353+RLAPI void ImageColorInvert(Image *image);                                                               // Modify image color: invert
1354+RLAPI void ImageColorGrayscale(Image *image);                                                            // Modify image color: grayscale
1355+RLAPI void ImageColorContrast(Image *image, float contrast);                                             // Modify image color: contrast (-100 to 100)
1356+RLAPI void ImageColorBrightness(Image *image, int brightness);                                           // Modify image color: brightness (-255 to 255)
1357+RLAPI void ImageColorReplace(Image *image, Color color, Color replace);                                  // Modify image color: replace color
1358+RLAPI Color *LoadImageColors(Image image);                                                               // Load color data from image as a Color array (RGBA - 32bit)
1359+RLAPI Color *LoadImagePalette(Image image, int maxPaletteSize, int *colorCount);                         // Load colors palette from image as a Color array (RGBA - 32bit)
1360+RLAPI void UnloadImageColors(Color *colors);                                                             // Unload color data loaded with LoadImageColors()
1361+RLAPI void UnloadImagePalette(Color *colors);                                                            // Unload colors palette loaded with LoadImagePalette()
1362+RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold);                                       // Get image alpha border rectangle
1363+RLAPI Color GetImageColor(Image image, int x, int y);                                                    // Get image pixel color at (x, y) position
1364+
1365+// Image drawing functions
1366+// NOTE: Image software-rendering functions (CPU)
1367+RLAPI void ImageClearBackground(Image *dst, Color color);                                                // Clear image background with given color
1368+RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color);                                  // Draw pixel within an image
1369+RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color);                                   // Draw pixel within an image (Vector version)
1370+RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
1371+RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color);                          // Draw line within an image (Vector version)
1372+RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color);               // Draw a filled circle within an image
1373+RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color);                        // Draw a filled circle within an image (Vector version)
1374+RLAPI void ImageDrawCircleLines(Image *dst, int centerX, int centerY, int radius, Color color);          // Draw circle outline within an image
1375+RLAPI void ImageDrawCircleLinesV(Image *dst, Vector2 center, int radius, Color color);                   // Draw circle outline within an image (Vector version)
1376+RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color);       // Draw rectangle within an image
1377+RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color);                 // Draw rectangle within an image (Vector version)
1378+RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color);                                // Draw rectangle within an image
1379+RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color);                   // Draw rectangle lines within an image
1380+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)
1381+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)
1382+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)
1383+
1384+// Texture loading functions
1385+// NOTE: These functions require GPU access
1386+RLAPI Texture2D LoadTexture(const char *fileName);                                                       // Load texture from file into GPU memory (VRAM)
1387+RLAPI Texture2D LoadTextureFromImage(Image image);                                                       // Load texture from image data
1388+RLAPI TextureCubemap LoadTextureCubemap(Image image, int layout);                                        // Load cubemap from image, multiple image cubemap layouts supported
1389+RLAPI RenderTexture2D LoadRenderTexture(int width, int height);                                          // Load texture for rendering (framebuffer)
1390+RLAPI bool IsTextureReady(Texture2D texture);                                                            // Check if a texture is ready
1391+RLAPI void UnloadTexture(Texture2D texture);                                                             // Unload texture from GPU memory (VRAM)
1392+RLAPI bool IsRenderTextureReady(RenderTexture2D target);                                                 // Check if a render texture is ready
1393+RLAPI void UnloadRenderTexture(RenderTexture2D target);                                                  // Unload render texture from GPU memory (VRAM)
1394+RLAPI void UpdateTexture(Texture2D texture, const void *pixels);                                         // Update GPU texture with new data
1395+RLAPI void UpdateTextureRec(Texture2D texture, Rectangle rec, const void *pixels);                       // Update GPU texture rectangle with new data
1396+
1397+// Texture configuration functions
1398+RLAPI void GenTextureMipmaps(Texture2D *texture);                                                        // Generate GPU mipmaps for a texture
1399+RLAPI void SetTextureFilter(Texture2D texture, int filter);                                              // Set texture scaling filter mode
1400+RLAPI void SetTextureWrap(Texture2D texture, int wrap);                                                  // Set texture wrapping mode
1401+
1402+// Texture drawing functions
1403+RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint);                               // Draw a Texture2D
1404+RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint);                                // Draw a Texture2D with position defined as Vector2
1405+RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint);  // Draw a Texture2D with extended parameters
1406+RLAPI void DrawTextureRec(Texture2D texture, Rectangle source, Vector2 position, Color tint);            // Draw a part of a texture defined by a rectangle
1407+RLAPI void DrawTexturePro(Texture2D texture, Rectangle source, Rectangle dest, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
1408+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
1409+
1410+// Color/pixel related functions
1411+RLAPI Color Fade(Color color, float alpha);                                 // Get color with alpha applied, alpha goes from 0.0f to 1.0f
1412+RLAPI int ColorToInt(Color color);                                          // Get hexadecimal value for a Color
1413+RLAPI Vector4 ColorNormalize(Color color);                                  // Get Color normalized as float [0..1]
1414+RLAPI Color ColorFromNormalized(Vector4 normalized);                        // Get Color from normalized values [0..1]
1415+RLAPI Vector3 ColorToHSV(Color color);                                      // Get HSV values for a Color, hue [0..360], saturation/value [0..1]
1416+RLAPI Color ColorFromHSV(float hue, float saturation, float value);         // Get a Color from HSV values, hue [0..360], saturation/value [0..1]
1417+RLAPI Color ColorTint(Color color, Color tint);                             // Get color multiplied with another color
1418+RLAPI Color ColorBrightness(Color color, float factor);                     // Get color with brightness correction, brightness factor goes from -1.0f to 1.0f
1419+RLAPI Color ColorContrast(Color color, float contrast);                     // Get color with contrast correction, contrast values between -1.0f and 1.0f
1420+RLAPI Color ColorAlpha(Color color, float alpha);                           // Get color with alpha applied, alpha goes from 0.0f to 1.0f
1421+RLAPI Color ColorAlphaBlend(Color dst, Color src, Color tint);              // Get src alpha-blended into dst color with tint
1422+RLAPI Color GetColor(unsigned int hexValue);                                // Get Color structure from hexadecimal value
1423+RLAPI Color GetPixelColor(void *srcPtr, int format);                        // Get Color from a source pixel pointer of certain format
1424+RLAPI void SetPixelColor(void *dstPtr, Color color, int format);            // Set color formatted into destination pixel pointer
1425+RLAPI int GetPixelDataSize(int width, int height, int format);              // Get pixel data size in bytes for certain format
1426+
1427+//------------------------------------------------------------------------------------
1428+// Font Loading and Text Drawing Functions (Module: text)
1429+//------------------------------------------------------------------------------------
1430+
1431+// Font loading/unloading functions
1432+RLAPI Font GetFontDefault(void);                                                            // Get the default Font
1433+RLAPI Font LoadFont(const char *fileName);                                                  // Load font from file into GPU memory (VRAM)
1434+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
1435+RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar);                        // Load font from Image (XNA style)
1436+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'
1437+RLAPI bool IsFontReady(Font font);                                                          // Check if a font is ready
1438+RLAPI GlyphInfo *LoadFontData(const unsigned char *fileData, int dataSize, int fontSize, int *codepoints, int codepointCount, int type); // Load font data for further use
1439+RLAPI Image GenImageFontAtlas(const GlyphInfo *glyphs, Rectangle **glyphRecs, int glyphCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
1440+RLAPI void UnloadFontData(GlyphInfo *glyphs, int glyphCount);                               // Unload font chars info data (RAM)
1441+RLAPI void UnloadFont(Font font);                                                           // Unload font from GPU memory (VRAM)
1442+RLAPI bool ExportFontAsCode(Font font, const char *fileName);                               // Export font as code file, returns true on success
1443+
1444+// Text drawing functions
1445+RLAPI void DrawFPS(int posX, int posY);                                                     // Draw current FPS
1446+RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color);       // Draw text (using default font)
1447+RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
1448+RLAPI void DrawTextPro(Font font, const char *text, Vector2 position, Vector2 origin, float rotation, float fontSize, float spacing, Color tint); // Draw text using Font and pro parameters (rotation)
1449+RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float fontSize, Color tint); // Draw one character (codepoint)
1450+RLAPI void DrawTextCodepoints(Font font, const int *codepoints, int codepointCount, Vector2 position, float fontSize, float spacing, Color tint); // Draw multiple character (codepoint)
1451+
1452+// Text font info functions
1453+RLAPI void SetTextLineSpacing(int spacing);                                                 // Set vertical line spacing when drawing with line-breaks
1454+RLAPI int MeasureText(const char *text, int fontSize);                                      // Measure string width for default font
1455+RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing);    // Measure string size for Font
1456+RLAPI int GetGlyphIndex(Font font, int codepoint);                                          // Get glyph index position in font for a codepoint (unicode character), fallback to '?' if not found
1457+RLAPI GlyphInfo GetGlyphInfo(Font font, int codepoint);                                     // Get glyph font info data for a codepoint (unicode character), fallback to '?' if not found
1458+RLAPI Rectangle GetGlyphAtlasRec(Font font, int codepoint);                                 // Get glyph rectangle in font atlas for a codepoint (unicode character), fallback to '?' if not found
1459+
1460+// Text codepoints management functions (unicode characters)
1461+RLAPI char *LoadUTF8(const int *codepoints, int length);                // Load UTF-8 text encoded from codepoints array
1462+RLAPI void UnloadUTF8(char *text);                                      // Unload UTF-8 text encoded from codepoints array
1463+RLAPI int *LoadCodepoints(const char *text, int *count);                // Load all codepoints from a UTF-8 text string, codepoints count returned by parameter
1464+RLAPI void UnloadCodepoints(int *codepoints);                           // Unload codepoints data from memory
1465+RLAPI int GetCodepointCount(const char *text);                          // Get total number of codepoints in a UTF-8 encoded string
1466+RLAPI int GetCodepoint(const char *text, int *codepointSize);           // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
1467+RLAPI int GetCodepointNext(const char *text, int *codepointSize);       // Get next codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
1468+RLAPI int GetCodepointPrevious(const char *text, int *codepointSize);   // Get previous codepoint in a UTF-8 encoded string, 0x3f('?') is returned on failure
1469+RLAPI const char *CodepointToUTF8(int codepoint, int *utf8Size);        // Encode one codepoint into UTF-8 byte array (array length returned as parameter)
1470+
1471+// Text strings management functions (no UTF-8 strings, only byte chars)
1472+// NOTE: Some strings allocate memory internally for returned strings, just be careful!
1473+RLAPI int TextCopy(char *dst, const char *src);                                             // Copy one string to another, returns bytes copied
1474+RLAPI bool TextIsEqual(const char *text1, const char *text2);                               // Check if two text string are equal
1475+RLAPI unsigned int TextLength(const char *text);                                            // Get text length, checks for '\0' ending
1476+RLAPI const char *TextFormat(const char *text, ...);                                        // Text formatting with variables (sprintf() style)
1477+RLAPI const char *TextSubtext(const char *text, int position, int length);                  // Get a piece of a text string
1478+RLAPI char *TextReplace(const char *text, const char *replace, const char *by);             // Replace text string (WARNING: memory must be freed!)
1479+RLAPI char *TextInsert(const char *text, const char *insert, int position);                 // Insert text in a position (WARNING: memory must be freed!)
1480+RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter);        // Join text strings with delimiter
1481+RLAPI const char **TextSplit(const char *text, char delimiter, int *count);                 // Split text into multiple strings
1482+RLAPI void TextAppend(char *text, const char *append, int *position);                       // Append text at specific position and move cursor!
1483+RLAPI int TextFindIndex(const char *text, const char *find);                                // Find first text occurrence within a string
1484+RLAPI const char *TextToUpper(const char *text);                      // Get upper case version of provided string
1485+RLAPI const char *TextToLower(const char *text);                      // Get lower case version of provided string
1486+RLAPI const char *TextToPascal(const char *text);                     // Get Pascal case notation version of provided string
1487+RLAPI int TextToInteger(const char *text);                            // Get integer value from text (negative values not supported)
1488+RLAPI float TextToFloat(const char *text);                            // Get float value from text (negative values not supported)
1489+
1490+//------------------------------------------------------------------------------------
1491+// Basic 3d Shapes Drawing Functions (Module: models)
1492+//------------------------------------------------------------------------------------
1493+
1494+// Basic geometric 3D shapes drawing functions
1495+RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color);                                    // Draw a line in 3D world space
1496+RLAPI void DrawPoint3D(Vector3 position, Color color);                                                   // Draw a point in 3D space, actually a small line
1497+RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
1498+RLAPI void DrawTriangle3D(Vector3 v1, Vector3 v2, Vector3 v3, Color color);                              // Draw a color-filled triangle (vertex in counter-clockwise order!)
1499+RLAPI void DrawTriangleStrip3D(Vector3 *points, int pointCount, Color color);                            // Draw a triangle strip defined by points
1500+RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color);             // Draw cube
1501+RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color);                                       // Draw cube (Vector version)
1502+RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color);        // Draw cube wires
1503+RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color);                                  // Draw cube wires (Vector version)
1504+RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color);                                     // Draw sphere
1505+RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color);            // Draw sphere with extended parameters
1506+RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color);         // Draw sphere wires
1507+RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
1508+RLAPI void DrawCylinderEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder with base at startPos and top at endPos
1509+RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
1510+RLAPI void DrawCylinderWiresEx(Vector3 startPos, Vector3 endPos, float startRadius, float endRadius, int sides, Color color); // Draw a cylinder wires with base at startPos and top at endPos
1511+RLAPI void DrawCapsule(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw a capsule with the center of its sphere caps at startPos and endPos
1512+RLAPI void DrawCapsuleWires(Vector3 startPos, Vector3 endPos, float radius, int slices, int rings, Color color); // Draw capsule wireframe with the center of its sphere caps at startPos and endPos
1513+RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color);                                      // Draw a plane XZ
1514+RLAPI void DrawRay(Ray ray, Color color);                                                                // Draw a ray line
1515+RLAPI void DrawGrid(int slices, float spacing);                                                          // Draw a grid (centered at (0, 0, 0))
1516+
1517+//------------------------------------------------------------------------------------
1518+// Model 3d Loading and Drawing Functions (Module: models)
1519+//------------------------------------------------------------------------------------
1520+
1521+// Model management functions
1522+RLAPI Model LoadModel(const char *fileName);                                                // Load model from files (meshes and materials)
1523+RLAPI Model LoadModelFromMesh(Mesh mesh);                                                   // Load model from generated mesh (default material)
1524+RLAPI bool IsModelReady(Model model);                                                       // Check if a model is ready
1525+RLAPI void UnloadModel(Model model);                                                        // Unload model (including meshes) from memory (RAM and/or VRAM)
1526+RLAPI BoundingBox GetModelBoundingBox(Model model);                                         // Compute model bounding box limits (considers all meshes)
1527+
1528+// Model drawing functions
1529+RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint);               // Draw a model (with texture if set)
1530+RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
1531+RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint);          // Draw a model wires (with texture if set)
1532+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
1533+RLAPI void DrawBoundingBox(BoundingBox box, Color color);                                   // Draw bounding box (wires)
1534+RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 position, float size, Color tint);   // Draw a billboard texture
1535+RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle source, Vector3 position, Vector2 size, Color tint); // Draw a billboard texture defined by source
1536+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
1537+
1538+// Mesh management functions
1539+RLAPI void UploadMesh(Mesh *mesh, bool dynamic);                                            // Upload mesh vertex data in GPU and provide VAO/VBO ids
1540+RLAPI void UpdateMeshBuffer(Mesh mesh, int index, const void *data, int dataSize, int offset); // Update mesh vertex data in GPU for a specific buffer index
1541+RLAPI void UnloadMesh(Mesh mesh);                                                           // Unload mesh data from CPU and GPU
1542+RLAPI void DrawMesh(Mesh mesh, Material material, Matrix transform);                        // Draw a 3d mesh with material and transform
1543+RLAPI void DrawMeshInstanced(Mesh mesh, Material material, const Matrix *transforms, int instances); // Draw multiple mesh instances with material and different transforms
1544+RLAPI BoundingBox GetMeshBoundingBox(Mesh mesh);                                            // Compute mesh bounding box limits
1545+RLAPI void GenMeshTangents(Mesh *mesh);                                                     // Compute mesh tangents
1546+RLAPI bool ExportMesh(Mesh mesh, const char *fileName);                                     // Export mesh data to file, returns true on success
1547+RLAPI bool ExportMeshAsCode(Mesh mesh, const char *fileName);                               // Export mesh as code file (.h) defining multiple arrays of vertex attributes
1548+
1549+// Mesh generation functions
1550+RLAPI Mesh GenMeshPoly(int sides, float radius);                                            // Generate polygonal mesh
1551+RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ);                     // Generate plane mesh (with subdivisions)
1552+RLAPI Mesh GenMeshCube(float width, float height, float length);                            // Generate cuboid mesh
1553+RLAPI Mesh GenMeshSphere(float radius, int rings, int slices);                              // Generate sphere mesh (standard sphere)
1554+RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices);                          // Generate half-sphere mesh (no bottom cap)
1555+RLAPI Mesh GenMeshCylinder(float radius, float height, int slices);                         // Generate cylinder mesh
1556+RLAPI Mesh GenMeshCone(float radius, float height, int slices);                             // Generate cone/pyramid mesh
1557+RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides);                   // Generate torus mesh
1558+RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides);                    // Generate trefoil knot mesh
1559+RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size);                                 // Generate heightmap mesh from image data
1560+RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize);                               // Generate cubes-based map mesh from image data
1561+
1562+// Material loading/unloading functions
1563+RLAPI Material *LoadMaterials(const char *fileName, int *materialCount);                    // Load materials from model file
1564+RLAPI Material LoadMaterialDefault(void);                                                   // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
1565+RLAPI bool IsMaterialReady(Material material);                                              // Check if a material is ready
1566+RLAPI void UnloadMaterial(Material material);                                               // Unload material from GPU memory (VRAM)
1567+RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture);          // Set texture for a material map type (MATERIAL_MAP_DIFFUSE, MATERIAL_MAP_SPECULAR...)
1568+RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId);                  // Set material for a mesh
1569+
1570+// Model animations loading/unloading functions
1571+RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animCount);            // Load model animations from file
1572+RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame);               // Update model animation pose
1573+RLAPI void UnloadModelAnimation(ModelAnimation anim);                                       // Unload animation data
1574+RLAPI void UnloadModelAnimations(ModelAnimation *animations, int animCount);                // Unload animation array data
1575+RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim);                         // Check model animation skeleton match
1576+
1577+// Collision detection functions
1578+RLAPI bool CheckCollisionSpheres(Vector3 center1, float radius1, Vector3 center2, float radius2);   // Check collision between two spheres
1579+RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2);                                 // Check collision between two bounding boxes
1580+RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius);                  // Check collision between box and sphere
1581+RLAPI RayCollision GetRayCollisionSphere(Ray ray, Vector3 center, float radius);                    // Get collision info between ray and sphere
1582+RLAPI RayCollision GetRayCollisionBox(Ray ray, BoundingBox box);                                    // Get collision info between ray and box
1583+RLAPI RayCollision GetRayCollisionMesh(Ray ray, Mesh mesh, Matrix transform);                       // Get collision info between ray and mesh
1584+RLAPI RayCollision GetRayCollisionTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3);            // Get collision info between ray and triangle
1585+RLAPI RayCollision GetRayCollisionQuad(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3, Vector3 p4);    // Get collision info between ray and quad
1586+
1587+//------------------------------------------------------------------------------------
1588+// Audio Loading and Playing Functions (Module: audio)
1589+//------------------------------------------------------------------------------------
1590+typedef void (*AudioCallback)(void *bufferData, unsigned int frames);
1591+
1592+// Audio device management functions
1593+RLAPI void InitAudioDevice(void);                                     // Initialize audio device and context
1594+RLAPI void CloseAudioDevice(void);                                    // Close the audio device and context
1595+RLAPI bool IsAudioDeviceReady(void);                                  // Check if audio device has been initialized successfully
1596+RLAPI void SetMasterVolume(float volume);                             // Set master volume (listener)
1597+RLAPI float GetMasterVolume(void);                                    // Get master volume (listener)
1598+
1599+// Wave/Sound loading/unloading functions
1600+RLAPI Wave LoadWave(const char *fileName);                            // Load wave data from file
1601+RLAPI Wave LoadWaveFromMemory(const char *fileType, const unsigned char *fileData, int dataSize); // Load wave from memory buffer, fileType refers to extension: i.e. '.wav'
1602+RLAPI bool IsWaveReady(Wave wave);                                    // Checks if wave data is ready
1603+RLAPI Sound LoadSound(const char *fileName);                          // Load sound from file
1604+RLAPI Sound LoadSoundFromWave(Wave wave);                             // Load sound from wave data
1605+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
1606+RLAPI bool IsSoundReady(Sound sound);                                 // Checks if a sound is ready
1607+RLAPI void UpdateSound(Sound sound, const void *data, int sampleCount); // Update sound buffer with new data
1608+RLAPI void UnloadWave(Wave wave);                                     // Unload wave data
1609+RLAPI void UnloadSound(Sound sound);                                  // Unload sound
1610+RLAPI void UnloadSoundAlias(Sound alias);                             // Unload a sound alias (does not deallocate sample data)
1611+RLAPI bool ExportWave(Wave wave, const char *fileName);               // Export wave data to file, returns true on success
1612+RLAPI bool ExportWaveAsCode(Wave wave, const char *fileName);         // Export wave sample data to code (.h), returns true on success
1613+
1614+// Wave/Sound management functions
1615+RLAPI void PlaySound(Sound sound);                                    // Play a sound
1616+RLAPI void StopSound(Sound sound);                                    // Stop playing a sound
1617+RLAPI void PauseSound(Sound sound);                                   // Pause a sound
1618+RLAPI void ResumeSound(Sound sound);                                  // Resume a paused sound
1619+RLAPI bool IsSoundPlaying(Sound sound);                               // Check if a sound is currently playing
1620+RLAPI void SetSoundVolume(Sound sound, float volume);                 // Set volume for a sound (1.0 is max level)
1621+RLAPI void SetSoundPitch(Sound sound, float pitch);                   // Set pitch for a sound (1.0 is base level)
1622+RLAPI void SetSoundPan(Sound sound, float pan);                       // Set pan for a sound (0.5 is center)
1623+RLAPI Wave WaveCopy(Wave wave);                                       // Copy a wave to a new wave
1624+RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample);     // Crop a wave to defined samples range
1625+RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
1626+RLAPI float *LoadWaveSamples(Wave wave);                              // Load samples data from wave as a 32bit float data array
1627+RLAPI void UnloadWaveSamples(float *samples);                         // Unload samples data loaded with LoadWaveSamples()
1628+
1629+// Music management functions
1630+RLAPI Music LoadMusicStream(const char *fileName);                    // Load music stream from file
1631+RLAPI Music LoadMusicStreamFromMemory(const char *fileType, const unsigned char *data, int dataSize); // Load music stream from data
1632+RLAPI bool IsMusicReady(Music music);                                 // Checks if a music stream is ready
1633+RLAPI void UnloadMusicStream(Music music);                            // Unload music stream
1634+RLAPI void PlayMusicStream(Music music);                              // Start music playing
1635+RLAPI bool IsMusicStreamPlaying(Music music);                         // Check if music is playing
1636+RLAPI void UpdateMusicStream(Music music);                            // Updates buffers for music streaming
1637+RLAPI void StopMusicStream(Music music);                              // Stop music playing
1638+RLAPI void PauseMusicStream(Music music);                             // Pause music playing
1639+RLAPI void ResumeMusicStream(Music music);                            // Resume playing paused music
1640+RLAPI void SeekMusicStream(Music music, float position);              // Seek music to a position (in seconds)
1641+RLAPI void SetMusicVolume(Music music, float volume);                 // Set volume for music (1.0 is max level)
1642+RLAPI void SetMusicPitch(Music music, float pitch);                   // Set pitch for a music (1.0 is base level)
1643+RLAPI void SetMusicPan(Music music, float pan);                       // Set pan for a music (0.5 is center)
1644+RLAPI float GetMusicTimeLength(Music music);                          // Get music time length (in seconds)
1645+RLAPI float GetMusicTimePlayed(Music music);                          // Get current music time played (in seconds)
1646+
1647+// AudioStream management functions
1648+RLAPI AudioStream LoadAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Load audio stream (to stream raw audio pcm data)
1649+RLAPI bool IsAudioStreamReady(AudioStream stream);                    // Checks if an audio stream is ready
1650+RLAPI void UnloadAudioStream(AudioStream stream);                     // Unload audio stream and free memory
1651+RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int frameCount); // Update audio stream buffers with data
1652+RLAPI bool IsAudioStreamProcessed(AudioStream stream);                // Check if any audio stream buffers requires refill
1653+RLAPI void PlayAudioStream(AudioStream stream);                       // Play audio stream
1654+RLAPI void PauseAudioStream(AudioStream stream);                      // Pause audio stream
1655+RLAPI void ResumeAudioStream(AudioStream stream);                     // Resume audio stream
1656+RLAPI bool IsAudioStreamPlaying(AudioStream stream);                  // Check if audio stream is playing
1657+RLAPI void StopAudioStream(AudioStream stream);                       // Stop audio stream
1658+RLAPI void SetAudioStreamVolume(AudioStream stream, float volume);    // Set volume for audio stream (1.0 is max level)
1659+RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch);      // Set pitch for audio stream (1.0 is base level)
1660+RLAPI void SetAudioStreamPan(AudioStream stream, float pan);          // Set pan for audio stream (0.5 is centered)
1661+RLAPI void SetAudioStreamBufferSizeDefault(int size);                 // Default size for new audio streams
1662+RLAPI void SetAudioStreamCallback(AudioStream stream, AudioCallback callback); // Audio thread callback to request new data
1663+
1664+RLAPI void AttachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Attach audio stream processor to stream, receives the samples as <float>s
1665+RLAPI void DetachAudioStreamProcessor(AudioStream stream, AudioCallback processor); // Detach audio stream processor from stream
1666+
1667+RLAPI void AttachAudioMixedProcessor(AudioCallback processor); // Attach audio stream processor to the entire audio pipeline, receives the samples as <float>s
1668+RLAPI void DetachAudioMixedProcessor(AudioCallback processor); // Detach audio stream processor from the entire audio pipeline
1669+
1670+#if defined(__cplusplus)
1671+}
1672+#endif
1673+
1674+#endif // RAYLIB_H
1675
1676