Skip to content

M
mini projet
Commit 30949fb0 authored by LE TENOUX--RACHIDI Isham's avatar LE TENOUX--RACHIDI Isham
Browse files
Options

Worms physics first commit

parents
Pipeline #890 canceled with stages
      Hide whitespace changes
      Inline Side-by-side
      Showing with 5066 additions and 0 deletions
      physac.h 0 → 100644
      View file @ 30949fb0
      /**********************************************************************************************
      *
      * Physac v1.0 - 2D Physics library for videogames
      *
      * DESCRIPTION:
      *
      * Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop
      * to simluate physics. A physics step contains the following phases: get collision information,
      * apply dynamics, collision solving and position correction. It uses a very simple struct for physic
      * bodies with a position vector to be used in any 3D rendering API.
      *
      * CONFIGURATION:
      *
      * #define PHYSAC_IMPLEMENTATION
      * Generates the implementation of the library into the included file.
      * If not defined, the library is in header only mode and can be included in other headers
      * or source files without problems. But only ONE file should hold the implementation.
      *
      * #define PHYSAC_STATIC (defined by default)
      * The generated implementation will stay private inside implementation file and all
      * internal symbols and functions will only be visible inside that file.
      *
      * #define PHYSAC_NO_THREADS
      * The generated implementation won't include pthread library and user must create a secondary thread to call PhysicsThread().
      * It is so important that the thread where PhysicsThread() is called must not have v-sync or any other CPU limitation.
      *
      * #define PHYSAC_STANDALONE
      * Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined
      * internally in the library and input management and drawing functions must be provided by
      * the user (check library implementation for further details).
      *
      * #define PHYSAC_DEBUG
      * Traces log messages when creating and destroying physics bodies and detects errors in physics
      * calculations and reference exceptions; it is useful for debug purposes
      *
      * #define PHYSAC_MALLOC()
      * #define PHYSAC_FREE()
      * You can define your own malloc/free implementation replacing stdlib.h malloc()/free() functions.
      * Otherwise it will include stdlib.h and use the C standard library malloc()/free() function.
      *
      *
      * NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
      * NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
      *
      * Use the following code to compile:
      * gcc -o $(NAME_PART).exe $(FILE_NAME) -s -static -lraylib -lpthread -lopengl32 -lgdi32 -lwinmm -std=c99
      *
      * VERY THANKS TO:
      * Ramon Santamaria (github: @raysan5)
      *
      *
      * LICENSE: zlib/libpng
      *
      * Copyright (c) 2016-2018 Victor Fisac (github: @victorfisac)
      *
      * This software is provided "as-is", without any express or implied warranty. In no event
      * will the authors be held liable for any damages arising from the use of this software.
      *
      * Permission is granted to anyone to use this software for any purpose, including commercial
      * applications, and to alter it and redistribute it freely, subject to the following restrictions:
      *
      * 1. The origin of this software must not be misrepresented; you must not claim that you
      * wrote the original software. If you use this software in a product, an acknowledgment
      * in the product documentation would be appreciated but is not required.
      *
      * 2. Altered source versions must be plainly marked as such, and must not be misrepresented
      * as being the original software.
      *
      * 3. This notice may not be removed or altered from any source distribution.
      *
      **********************************************************************************************/
      #if !defined(PHYSAC_H)
      #define PHYSAC_H
      #if defined(PHYSAC_STATIC)
      #define PHYSACDEF static // Functions just visible to module including this file
      #else
      #if defined(__cplusplus)
      #define PHYSACDEF extern "C" // Functions visible from other files (no name mangling of functions in C++)
      #else
      #define PHYSACDEF extern // Functions visible from other files
      #endif
      #endif
      // Allow custom memory allocators
      #ifndef PHYSAC_MALLOC
      #define PHYSAC_MALLOC(size) malloc(size)
      #endif
      #ifndef PHYSAC_FREE
      #define PHYSAC_FREE(ptr) free(ptr)
      #endif
      //----------------------------------------------------------------------------------
      // Defines and Macros
      //----------------------------------------------------------------------------------
      #define PHYSAC_MAX_BODIES 64
      #define PHYSAC_MAX_MANIFOLDS 4096
      #define PHYSAC_MAX_VERTICES 24
      #define PHYSAC_CIRCLE_VERTICES 24
      #define PHYSAC_COLLISION_ITERATIONS 100
      #define PHYSAC_PENETRATION_ALLOWANCE 0.05f
      #define PHYSAC_PENETRATION_CORRECTION 0.4f
      #define PHYSAC_PI 3.14159265358979323846
      #define PHYSAC_DEG2RAD (PHYSAC_PI/180.0f)
      //----------------------------------------------------------------------------------
      // Types and Structures Definition
      // NOTE: Below types are required for PHYSAC_STANDALONE usage
      //----------------------------------------------------------------------------------
      #if defined(PHYSAC_STANDALONE)
      // Boolean type
      #if defined(__STDC__) && __STDC_VERSION__ >= 199901L
      #include <stdbool.h>
      #elif !defined(__cplusplus) && !defined(bool)
      typedef enum { false, true } bool;
      #endif
      // Vector2 type
      typedef struct Vector2 {
      float x;
      float y;
      } Vector2;
      #endif
      typedef enum PhysicsShapeType { PHYSICS_CIRCLE, PHYSICS_POLYGON } PhysicsShapeType;
      // Previously defined to be used in PhysicsShape struct as circular dependencies
      typedef struct PhysicsBodyData *PhysicsBody;
      #if defined(__cplusplus)
      extern "C" { // Prevents name mangling of functions
      #endif
      //----------------------------------------------------------------------------------
      // Module Functions Declaration
      //----------------------------------------------------------------------------------
      PHYSACDEF void InitPhysics(void); // Initializes physics values, pointers and creates physics loop thread
      PHYSACDEF void RunPhysicsStep(void); // Run physics step, to be used if PHYSICS_NO_THREADS is set in your main loop
      PHYSACDEF void SetPhysicsTimeStep(double delta); // Sets physics fixed time step in milliseconds. 1.666666 by default
      PHYSACDEF bool IsPhysicsEnabled(void); // Returns true if physics thread is currently enabled
      PHYSACDEF void SetPhysicsGravity(float x, float y); // Sets physics global gravity force
      PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); // Creates a new circle physics body with generic parameters
      PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); // Creates a new rectangle physics body with generic parameters
      PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); // Creates a new polygon physics body with generic parameters
      PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force); // Adds a force to a physics body
      PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount); // Adds an angular force to a physics body
      PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force); // Shatters a polygon shape physics body to little physics bodies with explosion force
      PHYSACDEF int GetPhysicsBodiesCount(void); // Returns the current amount of created physics bodies
      PHYSACDEF PhysicsBody GetPhysicsBody(int index); // Returns a physics body of the bodies pool at a specific index
      PHYSACDEF int GetPhysicsShapeType(int index); // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
      PHYSACDEF int GetPhysicsShapeVerticesCount(int index); // Returns the amount of vertices of a physics body shape
      PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); // Returns transformed position of a body shape (body position + vertex transformed position)
      PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians); // Sets physics body shape transform based on radians parameter
      PHYSACDEF void DestroyPhysicsBody(PhysicsBody body); // Unitializes and destroy a physics body
      PHYSACDEF void ResetPhysics(void); // Destroys created physics bodies and manifolds and resets global values
      PHYSACDEF void ClosePhysics(void); // Unitializes physics pointers and closes physics loop thread
      #if defined(__cplusplus)
      }
      #endif
      #endif // PHYSAC_H
      /***********************************************************************************
      *
      * PHYSAC IMPLEMENTATION
      *
      ************************************************************************************/
      #if defined(PHYSAC_IMPLEMENTATION)
      #if !defined(PHYSAC_NO_THREADS)
      #include <pthread.h> // Required for: pthread_t, pthread_create()
      #endif
      #if defined(PHYSAC_DEBUG)
      #endif
      // Support TRACELOG macros
      #if defined(PHYSAC_DEBUG)
      #include <stdio.h> // Required for: printf()
      #define TRACELOG(...) printf(__VA_ARGS__)
      #else
      #define TRACELOG(...) (void)0
      #endif
      #include <stdlib.h> // Required for: malloc(), free(), srand(), rand()
      #include <math.h> // Required for: cosf(), sinf(), fabs(), sqrtf()
      #if !defined(PHYSAC_STANDALONE)
      #include "raymath.h" // Required for: Vector2Add(), Vector2Subtract()
      #endif
      // Time management functionality
      #include <time.h> // Required for: time(), clock_gettime()
      #if defined(_WIN32)
      // Functions required to query time on Windows
      int __stdcall QueryPerformanceCounter(unsigned long long int *lpPerformanceCount);
      int __stdcall QueryPerformanceFrequency(unsigned long long int *lpFrequency);
      #elif defined(__linux__)
      #if _POSIX_C_SOURCE < 199309L
      #undef _POSIX_C_SOURCE
      #define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
      #endif
      #include <sys/time.h> // Required for: timespec
      #elif defined(__APPLE__) // macOS also defines __MACH__
      #include <mach/mach_time.h> // Required for: mach_absolute_time()
      #endif
      //----------------------------------------------------------------------------------
      // Defines and Macros
      //----------------------------------------------------------------------------------
      #define min(a,b) (((a)<(b))?(a):(b))
      #define max(a,b) (((a)>(b))?(a):(b))
      #define PHYSAC_FLT_MAX 3.402823466e+38f
      #define PHYSAC_EPSILON 0.000001f
      #define PHYSAC_K 1.0f/3.0f
      #define PHYSAC_VECTOR_ZERO (Vector2){ 0.0f, 0.0f }
      //----------------------------------------------------------------------------------
      // Data Types Structure Definition
      //----------------------------------------------------------------------------------
      // Matrix2x2 type (used for polygon shape rotation matrix)
      typedef struct Matrix2x2 {
      float m00;
      float m01;
      float m10;
      float m11;
      } Matrix2x2;
      typedef struct PolygonData {
      unsigned int vertexCount; // Current used vertex and normals count
      Vector2 positions[PHYSAC_MAX_VERTICES]; // Polygon vertex positions vectors
      Vector2 normals[PHYSAC_MAX_VERTICES]; // Polygon vertex normals vectors
      } PolygonData;
      typedef struct PhysicsShape {
      PhysicsShapeType type; // Physics shape type (circle or polygon)
      PhysicsBody body; // Shape physics body reference
      float radius; // Circle shape radius (used for circle shapes)
      Matrix2x2 transform; // Vertices transform matrix 2x2
      PolygonData vertexData; // Polygon shape vertices position and normals data (just used for polygon shapes)
      } PhysicsShape;
      typedef struct PhysicsBodyData {
      unsigned int id; // Reference unique identifier
      bool enabled; // Enabled dynamics state (collisions are calculated anyway)
      Vector2 position; // Physics body shape pivot
      Vector2 velocity; // Current linear velocity applied to position
      Vector2 force; // Current linear force (reset to 0 every step)
      float angularVelocity; // Current angular velocity applied to orient
      float torque; // Current angular force (reset to 0 every step)
      float orient; // Rotation in radians
      float inertia; // Moment of inertia
      float inverseInertia; // Inverse value of inertia
      float mass; // Physics body mass
      float inverseMass; // Inverse value of mass
      float staticFriction; // Friction when the body has not movement (0 to 1)
      float dynamicFriction; // Friction when the body has movement (0 to 1)
      float restitution; // Restitution coefficient of the body (0 to 1)
      bool useGravity; // Apply gravity force to dynamics
      bool isGrounded; // Physics grounded on other body state
      bool freezeOrient; // Physics rotation constraint
      PhysicsShape shape; // Physics body shape information (type, radius, vertices, normals)
      } PhysicsBodyData;
      typedef struct PhysicsManifoldData {
      unsigned int id; // Reference unique identifier
      PhysicsBody bodyA; // Manifold first physics body reference
      PhysicsBody bodyB; // Manifold second physics body reference
      float penetration; // Depth of penetration from collision
      Vector2 normal; // Normal direction vector from 'a' to 'b'
      Vector2 contacts[2]; // Points of contact during collision
      unsigned int contactsCount; // Current collision number of contacts
      float restitution; // Mixed restitution during collision
      float dynamicFriction; // Mixed dynamic friction during collision
      float staticFriction; // Mixed static friction during collision
      } PhysicsManifoldData, *PhysicsManifold;
      //----------------------------------------------------------------------------------
      // Global Variables Definition
      //----------------------------------------------------------------------------------
      #if !defined(PHYSAC_NO_THREADS)
      static pthread_t physicsThreadId; // Physics thread id
      #endif
      static unsigned int usedMemory = 0; // Total allocated dynamic memory
      static bool physicsThreadEnabled = false; // Physics thread enabled state
      static double baseTime = 0.0; // Offset time for MONOTONIC clock
      static double startTime = 0.0; // Start time in milliseconds
      static double deltaTime = 1.0/60.0/10.0 * 1000; // Delta time used for physics steps, in milliseconds
      static double currentTime = 0.0; // Current time in milliseconds
      static unsigned long long int frequency = 0; // Hi-res clock frequency
      static double accumulator = 0.0; // Physics time step delta time accumulator
      static unsigned int stepsCount = 0; // Total physics steps processed
      static Vector2 gravityForce = { 0.0f, 9.81f }; // Physics world gravity force
      static PhysicsBody bodies[PHYSAC_MAX_BODIES]; // Physics bodies pointers array
      static unsigned int physicsBodiesCount = 0; // Physics world current bodies counter
      static PhysicsManifold contacts[PHYSAC_MAX_MANIFOLDS]; // Physics bodies pointers array
      static unsigned int physicsManifoldsCount = 0; // Physics world current manifolds counter
      //----------------------------------------------------------------------------------
      // Module Internal Functions Declaration
      //----------------------------------------------------------------------------------
      static int FindAvailableBodyIndex(); // Finds a valid index for a new physics body initialization
      static PolygonData CreateRandomPolygon(float radius, int sides); // Creates a random polygon shape with max vertex distance from polygon pivot
      static PolygonData CreateRectanglePolygon(Vector2 pos, Vector2 size); // Creates a rectangle polygon shape based on a min and max positions
      static void *PhysicsLoop(void *arg); // Physics loop thread function
      static void PhysicsStep(void); // Physics steps calculations (dynamics, collisions and position corrections)
      static int FindAvailableManifoldIndex(); // Finds a valid index for a new manifold initialization
      static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b); // Creates a new physics manifold to solve collision
      static void DestroyPhysicsManifold(PhysicsManifold manifold); // Unitializes and destroys a physics manifold
      static void SolvePhysicsManifold(PhysicsManifold manifold); // Solves a created physics manifold between two physics bodies
      static void SolveCircleToCircle(PhysicsManifold manifold); // Solves collision between two circle shape physics bodies
      static void SolveCircleToPolygon(PhysicsManifold manifold); // Solves collision between a circle to a polygon shape physics bodies
      static void SolvePolygonToCircle(PhysicsManifold manifold); // Solves collision between a polygon to a circle shape physics bodies
      static void SolvePolygonToPolygon(PhysicsManifold manifold); // Solves collision between two polygons shape physics bodies
      static void IntegratePhysicsForces(PhysicsBody body); // Integrates physics forces into velocity
      static void InitializePhysicsManifolds(PhysicsManifold manifold); // Initializes physics manifolds to solve collisions
      static void IntegratePhysicsImpulses(PhysicsManifold manifold); // Integrates physics collisions impulses to solve collisions
      static void IntegratePhysicsVelocity(PhysicsBody body); // Integrates physics velocity into position and forces
      static void CorrectPhysicsPositions(PhysicsManifold manifold); // Corrects physics bodies positions based on manifolds collision information
      static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB); // Finds polygon shapes axis least penetration
      static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index); // Finds two polygon shapes incident face
      static int Clip(Vector2 normal, float clip, Vector2 *faceA, Vector2 *faceB); // Calculates clipping based on a normal and two faces
      static bool BiasGreaterThan(float valueA, float valueB); // Check if values are between bias range
      static Vector2 TriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3); // Returns the barycenter of a triangle given by 3 points
      static void InitTimer(void); // Initializes hi-resolution MONOTONIC timer
      static unsigned long long int GetTimeCount(void); // Get hi-res MONOTONIC time measure in mseconds
      static double GetCurrentTime(void); // Get current time measure in milliseconds
      // Math functions
      static Vector2 MathCross(float value, Vector2 vector); // Returns the cross product of a vector and a value
      static float MathCrossVector2(Vector2 v1, Vector2 v2); // Returns the cross product of two vectors
      static float MathLenSqr(Vector2 vector); // Returns the len square root of a vector
      static float MathDot(Vector2 v1, Vector2 v2); // Returns the dot product of two vectors
      static inline float DistSqr(Vector2 v1, Vector2 v2); // Returns the square root of distance between two vectors
      static void MathNormalize(Vector2 *vector); // Returns the normalized values of a vector
      #if defined(PHYSAC_STANDALONE)
      static Vector2 Vector2Add(Vector2 v1, Vector2 v2); // Returns the sum of two given vectors
      static Vector2 Vector2Subtract(Vector2 v1, Vector2 v2); // Returns the subtract of two given vectors
      #endif
      static Matrix2x2 Mat2Radians(float radians); // Creates a matrix 2x2 from a given radians value
      static void Mat2Set(Matrix2x2 *matrix, float radians); // Set values from radians to a created matrix 2x2
      static inline Matrix2x2 Mat2Transpose(Matrix2x2 matrix); // Returns the transpose of a given matrix 2x2
      static inline Vector2 Mat2MultiplyVector2(Matrix2x2 matrix, Vector2 vector); // Multiplies a vector by a matrix 2x2
      //----------------------------------------------------------------------------------
      // Module Functions Definition
      //----------------------------------------------------------------------------------
      // Initializes physics values, pointers and creates physics loop thread
      PHYSACDEF void InitPhysics(void)
      {
      #if !defined(PHYSAC_NO_THREADS)
      // NOTE: if defined, user will need to create a thread for PhysicsThread function manually
      // Create physics thread using POSIXS thread libraries
      pthread_create(&physicsThreadId, NULL, &PhysicsLoop, NULL);
      #endif
      // Initialize high resolution timer
      InitTimer();
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] physics module initialized successfully\n");
      #endif
      accumulator = 0.0;
      }
      // Returns true if physics thread is currently enabled
      PHYSACDEF bool IsPhysicsEnabled(void)
      {
      return physicsThreadEnabled;
      }
      // Sets physics global gravity force
      PHYSACDEF void SetPhysicsGravity(float x, float y)
      {
      gravityForce.x = x;
      gravityForce.y = y;
      }
      // Creates a new circle physics body with generic parameters
      PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density)
      {
      PhysicsBody newBody = CreatePhysicsBodyPolygon(pos, radius, PHYSAC_CIRCLE_VERTICES, density);
      return newBody;
      }
      // Creates a new rectangle physics body with generic parameters
      PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density)
      {
      PhysicsBody newBody = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
      usedMemory += sizeof(PhysicsBodyData);
      int newId = FindAvailableBodyIndex();
      if (newId != -1)
      {
      // Initialize new body with generic values
      newBody->id = newId;
      newBody->enabled = true;
      newBody->position = pos;
      newBody->velocity = (Vector2){ 0.0f };
      newBody->force = (Vector2){ 0.0f };
      newBody->angularVelocity = 0.0f;
      newBody->torque = 0.0f;
      newBody->orient = 0.0f;
      newBody->shape.type = PHYSICS_POLYGON;
      newBody->shape.body = newBody;
      newBody->shape.radius = 0.0f;
      newBody->shape.transform = Mat2Radians(0.0f);
      newBody->shape.vertexData = CreateRectanglePolygon(pos, (Vector2){ width, height });
      // Calculate centroid and moment of inertia
      Vector2 center = { 0.0f, 0.0f };
      float area = 0.0f;
      float inertia = 0.0f;
      for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
      {
      // Triangle vertices, third vertex implied as (0, 0)
      Vector2 p1 = newBody->shape.vertexData.positions[i];
      int nextIndex = (((i + 1) < newBody->shape.vertexData.vertexCount) ? (i + 1) : 0);
      Vector2 p2 = newBody->shape.vertexData.positions[nextIndex];
      float D = MathCrossVector2(p1, p2);
      float triangleArea = D/2;
      area += triangleArea;
      // Use area to weight the centroid average, not just vertex position
      center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
      center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
      float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
      float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
      inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
      }
      center.x *= 1.0f/area;
      center.y *= 1.0f/area;
      // Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
      // Note: this is not really necessary
      for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
      {
      newBody->shape.vertexData.positions[i].x -= center.x;
      newBody->shape.vertexData.positions[i].y -= center.y;
      }
      newBody->mass = density*area;
      newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
      newBody->inertia = density*inertia;
      newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
      newBody->staticFriction = 0.4f;
      newBody->dynamicFriction = 0.2f;
      newBody->restitution = 0.0f;
      newBody->useGravity = true;
      newBody->isGrounded = false;
      newBody->freezeOrient = false;
      // Add new body to bodies pointers array and update bodies count
      bodies[physicsBodiesCount] = newBody;
      physicsBodiesCount++;
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] created polygon physics body id %i\n", newBody->id);
      #endif
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] new physics body creation failed because there is any available id to use\n");
      #endif
      return newBody;
      }
      // Creates a new polygon physics body with generic parameters
      PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density)
      {
      PhysicsBody newBody = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
      usedMemory += sizeof(PhysicsBodyData);
      int newId = FindAvailableBodyIndex();
      if (newId != -1)
      {
      // Initialize new body with generic values
      newBody->id = newId;
      newBody->enabled = true;
      newBody->position = pos;
      newBody->velocity = PHYSAC_VECTOR_ZERO;
      newBody->force = PHYSAC_VECTOR_ZERO;
      newBody->angularVelocity = 0.0f;
      newBody->torque = 0.0f;
      newBody->orient = 0.0f;
      newBody->shape.type = PHYSICS_POLYGON;
      newBody->shape.body = newBody;
      newBody->shape.transform = Mat2Radians(0.0f);
      newBody->shape.vertexData = CreateRandomPolygon(radius, sides);
      // Calculate centroid and moment of inertia
      Vector2 center = { 0.0f, 0.0f };
      float area = 0.0f;
      float inertia = 0.0f;
      for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
      {
      // Triangle vertices, third vertex implied as (0, 0)
      Vector2 position1 = newBody->shape.vertexData.positions[i];
      int nextIndex = (((i + 1) < newBody->shape.vertexData.vertexCount) ? (i + 1) : 0);
      Vector2 position2 = newBody->shape.vertexData.positions[nextIndex];
      float cross = MathCrossVector2(position1, position2);
      float triangleArea = cross/2;
      area += triangleArea;
      // Use area to weight the centroid average, not just vertex position
      center.x += triangleArea*PHYSAC_K*(position1.x + position2.x);
      center.y += triangleArea*PHYSAC_K*(position1.y + position2.y);
      float intx2 = position1.x*position1.x + position2.x*position1.x + position2.x*position2.x;
      float inty2 = position1.y*position1.y + position2.y*position1.y + position2.y*position2.y;
      inertia += (0.25f*PHYSAC_K*cross)*(intx2 + inty2);
      }
      center.x *= 1.0f/area;
      center.y *= 1.0f/area;
      // Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
      // Note: this is not really necessary
      for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
      {
      newBody->shape.vertexData.positions[i].x -= center.x;
      newBody->shape.vertexData.positions[i].y -= center.y;
      }
      newBody->mass = density*area;
      newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
      newBody->inertia = density*inertia;
      newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
      newBody->staticFriction = 0.4f;
      newBody->dynamicFriction = 0.2f;
      newBody->restitution = 0.0f;
      newBody->useGravity = true;
      newBody->isGrounded = false;
      newBody->freezeOrient = false;
      // Add new body to bodies pointers array and update bodies count
      bodies[physicsBodiesCount] = newBody;
      physicsBodiesCount++;
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] created polygon physics body id %i\n", newBody->id);
      #endif
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] new physics body creation failed because there is any available id to use\n");
      #endif
      return newBody;
      }
      // Adds a force to a physics body
      PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force)
      {
      if (body != NULL) body->force = Vector2Add(body->force, force);
      }
      // Adds an angular force to a physics body
      PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount)
      {
      if (body != NULL) body->torque += amount;
      }
      // Shatters a polygon shape physics body to little physics bodies with explosion force
      PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force)
      {
      if (body != NULL)
      {
      if (body->shape.type == PHYSICS_POLYGON)
      {
      PolygonData vertexData = body->shape.vertexData;
      bool collision = false;
      for (int i = 0; i < vertexData.vertexCount; i++)
      {
      Vector2 positionA = body->position;
      Vector2 positionB = Mat2MultiplyVector2(body->shape.transform, Vector2Add(body->position, vertexData.positions[i]));
      int nextIndex = (((i + 1) < vertexData.vertexCount) ? (i + 1) : 0);
      Vector2 positionC = Mat2MultiplyVector2(body->shape.transform, Vector2Add(body->position, vertexData.positions[nextIndex]));
      // Check collision between each triangle
      float alpha = ((positionB.y - positionC.y)*(position.x - positionC.x) + (positionC.x - positionB.x)*(position.y - positionC.y))/
      ((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
      float beta = ((positionC.y - positionA.y)*(position.x - positionC.x) + (positionA.x - positionC.x)*(position.y - positionC.y))/
      ((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
      float gamma = 1.0f - alpha - beta;
      if ((alpha > 0.0f) && (beta > 0.0f) & (gamma > 0.0f))
      {
      collision = true;
      break;
      }
      }
      if (collision)
      {
      int count = vertexData.vertexCount;
      Vector2 bodyPos = body->position;
      Vector2 *vertices = (Vector2 *)PHYSAC_MALLOC(sizeof(Vector2)*count);
      Matrix2x2 trans = body->shape.transform;
      for (int i = 0; i < count; i++) vertices[i] = vertexData.positions[i];
      // Destroy shattered physics body
      DestroyPhysicsBody(body);
      for (int i = 0; i < count; i++)
      {
      int nextIndex = (((i + 1) < count) ? (i + 1) : 0);
      Vector2 center = TriangleBarycenter(vertices[i], vertices[nextIndex], PHYSAC_VECTOR_ZERO);
      center = Vector2Add(bodyPos, center);
      Vector2 offset = Vector2Subtract(center, bodyPos);
      PhysicsBody newBody = CreatePhysicsBodyPolygon(center, 10, 3, 10); // Create polygon physics body with relevant values
      PolygonData newData = { 0 };
      newData.vertexCount = 3;
      newData.positions[0] = Vector2Subtract(vertices[i], offset);
      newData.positions[1] = Vector2Subtract(vertices[nextIndex], offset);
      newData.positions[2] = Vector2Subtract(position, center);
      // Separate vertices to avoid unnecessary physics collisions
      newData.positions[0].x *= 0.95f;
      newData.positions[0].y *= 0.95f;
      newData.positions[1].x *= 0.95f;
      newData.positions[1].y *= 0.95f;
      newData.positions[2].x *= 0.95f;
      newData.positions[2].y *= 0.95f;
      // Calculate polygon faces normals
      for (int j = 0; j < newData.vertexCount; j++)
      {
      int nextVertex = (((j + 1) < newData.vertexCount) ? (j + 1) : 0);
      Vector2 face = Vector2Subtract(newData.positions[nextVertex], newData.positions[j]);
      newData.normals[j] = (Vector2){ face.y, -face.x };
      MathNormalize(&newData.normals[j]);
      }
      // Apply computed vertex data to new physics body shape
      newBody->shape.vertexData = newData;
      newBody->shape.transform = trans;
      // Calculate centroid and moment of inertia
      center = PHYSAC_VECTOR_ZERO;
      float area = 0.0f;
      float inertia = 0.0f;
      for (int j = 0; j < newBody->shape.vertexData.vertexCount; j++)
      {
      // Triangle vertices, third vertex implied as (0, 0)
      Vector2 p1 = newBody->shape.vertexData.positions[j];
      int nextVertex = (((j + 1) < newBody->shape.vertexData.vertexCount) ? (j + 1) : 0);
      Vector2 p2 = newBody->shape.vertexData.positions[nextVertex];
      float D = MathCrossVector2(p1, p2);
      float triangleArea = D/2;
      area += triangleArea;
      // Use area to weight the centroid average, not just vertex position
      center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
      center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
      float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
      float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
      inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
      }
      center.x *= 1.0f/area;
      center.y *= 1.0f/area;
      newBody->mass = area;
      newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
      newBody->inertia = inertia;
      newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
      // Calculate explosion force direction
      Vector2 pointA = newBody->position;
      Vector2 pointB = Vector2Subtract(newData.positions[1], newData.positions[0]);
      pointB.x /= 2.0f;
      pointB.y /= 2.0f;
      Vector2 forceDirection = Vector2Subtract(Vector2Add(pointA, Vector2Add(newData.positions[0], pointB)), newBody->position);
      MathNormalize(&forceDirection);
      forceDirection.x *= force;
      forceDirection.y *= force;
      // Apply force to new physics body
      PhysicsAddForce(newBody, forceDirection);
      }
      PHYSAC_FREE(vertices);
      }
      }
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error when trying to shatter a null reference physics body");
      #endif
      }
      // Returns the current amount of created physics bodies
      PHYSACDEF int GetPhysicsBodiesCount(void)
      {
      return physicsBodiesCount;
      }
      // Returns a physics body of the bodies pool at a specific index
      PHYSACDEF PhysicsBody GetPhysicsBody(int index)
      {
      PhysicsBody body = NULL;
      if (index < physicsBodiesCount)
      {
      body = bodies[index];
      if (body == NULL)
      {
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] error when trying to get a null reference physics body");
      #endif
      }
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] physics body index is out of bounds");
      #endif
      return body;
      }
      // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
      PHYSACDEF int GetPhysicsShapeType(int index)
      {
      int result = -1;
      if (index < physicsBodiesCount)
      {
      PhysicsBody body = bodies[index];
      if (body != NULL) result = body->shape.type;
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error when trying to get a null reference physics body");
      #endif
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] physics body index is out of bounds");
      #endif
      return result;
      }
      // Returns the amount of vertices of a physics body shape
      PHYSACDEF int GetPhysicsShapeVerticesCount(int index)
      {
      int result = 0;
      if (index < physicsBodiesCount)
      {
      PhysicsBody body = bodies[index];
      if (body != NULL)
      {
      switch (body->shape.type)
      {
      case PHYSICS_CIRCLE: result = PHYSAC_CIRCLE_VERTICES; break;
      case PHYSICS_POLYGON: result = body->shape.vertexData.vertexCount; break;
      default: break;
      }
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error when trying to get a null reference physics body");
      #endif
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] physics body index is out of bounds");
      #endif
      return result;
      }
      // Returns transformed position of a body shape (body position + vertex transformed position)
      PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex)
      {
      Vector2 position = { 0.0f, 0.0f };
      if (body != NULL)
      {
      switch (body->shape.type)
      {
      case PHYSICS_CIRCLE:
      {
      position.x = body->position.x + cosf(360.0f/PHYSAC_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
      position.y = body->position.y + sinf(360.0f/PHYSAC_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
      } break;
      case PHYSICS_POLYGON:
      {
      PolygonData vertexData = body->shape.vertexData;
      position = Vector2Add(body->position, Mat2MultiplyVector2(body->shape.transform, vertexData.positions[vertex]));
      } break;
      default: break;
      }
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error when trying to get a null reference physics body");
      #endif
      return position;
      }
      // Sets physics body shape transform based on radians parameter
      PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians)
      {
      if (body != NULL)
      {
      body->orient = radians;
      if (body->shape.type == PHYSICS_POLYGON) body->shape.transform = Mat2Radians(radians);
      }
      }
      // Unitializes and destroys a physics body
      PHYSACDEF void DestroyPhysicsBody(PhysicsBody body)
      {
      if (body != NULL)
      {
      int id = body->id;
      int index = -1;
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      if (bodies[i]->id == id)
      {
      index = i;
      break;
      }
      }
      if (index == -1)
      {
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] Not possible to find body id %i in pointers array\n", id);
      #endif
      return; // Prevent access to index -1
      }
      // Free body allocated memory
      PHYSAC_FREE(body);
      usedMemory -= sizeof(PhysicsBodyData);
      bodies[index] = NULL;
      // Reorder physics bodies pointers array and its catched index
      for (int i = index; i < physicsBodiesCount; i++)
      {
      if ((i + 1) < physicsBodiesCount) bodies[i] = bodies[i + 1];
      }
      // Update physics bodies count
      physicsBodiesCount--;
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] destroyed physics body id %i\n", id);
      #endif
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error trying to destroy a null referenced body\n");
      #endif
      }
      // Destroys created physics bodies and manifolds and resets global values
      PHYSACDEF void ResetPhysics(void)
      {
      // Unitialize physics bodies dynamic memory allocations
      for (int i = physicsBodiesCount - 1; i >= 0; i--)
      {
      PhysicsBody body = bodies[i];
      if (body != NULL)
      {
      PHYSAC_FREE(body);
      bodies[i] = NULL;
      usedMemory -= sizeof(PhysicsBodyData);
      }
      }
      physicsBodiesCount = 0;
      // Unitialize physics manifolds dynamic memory allocations
      for (int i = physicsManifoldsCount - 1; i >= 0; i--)
      {
      PhysicsManifold manifold = contacts[i];
      if (manifold != NULL)
      {
      PHYSAC_FREE(manifold);
      contacts[i] = NULL;
      usedMemory -= sizeof(PhysicsManifoldData);
      }
      }
      physicsManifoldsCount = 0;
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] physics module reset successfully\n");
      #endif
      }
      // Unitializes physics pointers and exits physics loop thread
      PHYSACDEF void ClosePhysics(void)
      {
      // Exit physics loop thread
      physicsThreadEnabled = false;
      #if !defined(PHYSAC_NO_THREADS)
      pthread_join(physicsThreadId, NULL);
      #endif
      // Unitialize physics manifolds dynamic memory allocations
      for (int i = physicsManifoldsCount - 1; i >= 0; i--) DestroyPhysicsManifold(contacts[i]);
      // Unitialize physics bodies dynamic memory allocations
      for (int i = physicsBodiesCount - 1; i >= 0; i--) DestroyPhysicsBody(bodies[i]);
      #if defined(PHYSAC_DEBUG)
      if (physicsBodiesCount > 0 || usedMemory != 0) TRACELOG("[PHYSAC] physics module closed with %i still allocated bodies [MEMORY: %i bytes]\n", physicsBodiesCount, usedMemory);
      else if (physicsManifoldsCount > 0 || usedMemory != 0) TRACELOG("[PHYSAC] physics module closed with %i still allocated manifolds [MEMORY: %i bytes]\n", physicsManifoldsCount, usedMemory);
      else TRACELOG("[PHYSAC] physics module closed successfully\n");
      #endif
      }
      //----------------------------------------------------------------------------------
      // Module Internal Functions Definition
      //----------------------------------------------------------------------------------
      // Finds a valid index for a new physics body initialization
      static int FindAvailableBodyIndex()
      {
      int index = -1;
      for (int i = 0; i < PHYSAC_MAX_BODIES; i++)
      {
      int currentId = i;
      // Check if current id already exist in other physics body
      for (int k = 0; k < physicsBodiesCount; k++)
      {
      if (bodies[k]->id == currentId)
      {
      currentId++;
      break;
      }
      }
      // If it is not used, use it as new physics body id
      if (currentId == i)
      {
      index = i;
      break;
      }
      }
      return index;
      }
      // Creates a random polygon shape with max vertex distance from polygon pivot
      static PolygonData CreateRandomPolygon(float radius, int sides)
      {
      PolygonData data = { 0 };
      data.vertexCount = sides;
      // Calculate polygon vertices positions
      for (int i = 0; i < data.vertexCount; i++)
      {
      data.positions[i].x = cosf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
      data.positions[i].y = sinf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
      }
      // Calculate polygon faces normals
      for (int i = 0; i < data.vertexCount; i++)
      {
      int nextIndex = (((i + 1) < sides) ? (i + 1) : 0);
      Vector2 face = Vector2Subtract(data.positions[nextIndex], data.positions[i]);
      data.normals[i] = (Vector2){ face.y, -face.x };
      MathNormalize(&data.normals[i]);
      }
      return data;
      }
      // Creates a rectangle polygon shape based on a min and max positions
      static PolygonData CreateRectanglePolygon(Vector2 pos, Vector2 size)
      {
      PolygonData data = { 0 };
      data.vertexCount = 4;
      // Calculate polygon vertices positions
      data.positions[0] = (Vector2){ pos.x + size.x/2, pos.y - size.y/2 };
      data.positions[1] = (Vector2){ pos.x + size.x/2, pos.y + size.y/2 };
      data.positions[2] = (Vector2){ pos.x - size.x/2, pos.y + size.y/2 };
      data.positions[3] = (Vector2){ pos.x - size.x/2, pos.y - size.y/2 };
      // Calculate polygon faces normals
      for (int i = 0; i < data.vertexCount; i++)
      {
      int nextIndex = (((i + 1) < data.vertexCount) ? (i + 1) : 0);
      Vector2 face = Vector2Subtract(data.positions[nextIndex], data.positions[i]);
      data.normals[i] = (Vector2){ face.y, -face.x };
      MathNormalize(&data.normals[i]);
      }
      return data;
      }
      // Physics loop thread function
      static void *PhysicsLoop(void *arg)
      {
      #if !defined(PHYSAC_NO_THREADS)
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] physics thread created successfully\n");
      #endif
      // Initialize physics loop thread values
      physicsThreadEnabled = true;
      // Physics update loop
      while (physicsThreadEnabled)
      {
      RunPhysicsStep();
      }
      #endif
      return NULL;
      }
      // Physics steps calculations (dynamics, collisions and position corrections)
      static void PhysicsStep(void)
      {
      // Update current steps count
      stepsCount++;
      // Clear previous generated collisions information
      for (int i = physicsManifoldsCount - 1; i >= 0; i--)
      {
      PhysicsManifold manifold = contacts[i];
      if (manifold != NULL) DestroyPhysicsManifold(manifold);
      }
      // Reset physics bodies grounded state
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      PhysicsBody body = bodies[i];
      body->isGrounded = false;
      }
      // Generate new collision information
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      PhysicsBody bodyA = bodies[i];
      if (bodyA != NULL)
      {
      for (int j = i + 1; j < physicsBodiesCount; j++)
      {
      PhysicsBody bodyB = bodies[j];
      if (bodyB != NULL)
      {
      if ((bodyA->inverseMass == 0) && (bodyB->inverseMass == 0)) continue;
      PhysicsManifold manifold = CreatePhysicsManifold(bodyA, bodyB);
      SolvePhysicsManifold(manifold);
      if (manifold->contactsCount > 0)
      {
      // Create a new manifold with same information as previously solved manifold and add it to the manifolds pool last slot
      PhysicsManifold newManifold = CreatePhysicsManifold(bodyA, bodyB);
      newManifold->penetration = manifold->penetration;
      newManifold->normal = manifold->normal;
      newManifold->contacts[0] = manifold->contacts[0];
      newManifold->contacts[1] = manifold->contacts[1];
      newManifold->contactsCount = manifold->contactsCount;
      newManifold->restitution = manifold->restitution;
      newManifold->dynamicFriction = manifold->dynamicFriction;
      newManifold->staticFriction = manifold->staticFriction;
      }
      }
      }
      }
      }
      // Integrate forces to physics bodies
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      PhysicsBody body = bodies[i];
      if (body != NULL) IntegratePhysicsForces(body);
      }
      // Initialize physics manifolds to solve collisions
      for (int i = 0; i < physicsManifoldsCount; i++)
      {
      PhysicsManifold manifold = contacts[i];
      if (manifold != NULL) InitializePhysicsManifolds(manifold);
      }
      // Integrate physics collisions impulses to solve collisions
      for (int i = 0; i < PHYSAC_COLLISION_ITERATIONS; i++)
      {
      for (int j = 0; j < physicsManifoldsCount; j++)
      {
      PhysicsManifold manifold = contacts[i];
      if (manifold != NULL) IntegratePhysicsImpulses(manifold);
      }
      }
      // Integrate velocity to physics bodies
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      PhysicsBody body = bodies[i];
      if (body != NULL) IntegratePhysicsVelocity(body);
      }
      // Correct physics bodies positions based on manifolds collision information
      for (int i = 0; i < physicsManifoldsCount; i++)
      {
      PhysicsManifold manifold = contacts[i];
      if (manifold != NULL) CorrectPhysicsPositions(manifold);
      }
      // Clear physics bodies forces
      for (int i = 0; i < physicsBodiesCount; i++)
      {
      PhysicsBody body = bodies[i];
      if (body != NULL)
      {
      body->force = PHYSAC_VECTOR_ZERO;
      body->torque = 0.0f;
      }
      }
      }
      // Wrapper to ensure PhysicsStep is run with at a fixed time step
      PHYSACDEF void RunPhysicsStep(void)
      {
      // Calculate current time
      currentTime = GetCurrentTime();
      // Calculate current delta time
      const double delta = currentTime - startTime;
      // Store the time elapsed since the last frame began
      accumulator += delta;
      // Fixed time stepping loop
      while (accumulator >= deltaTime)
      {
      #ifdef PHYSAC_DEBUG
      //TRACELOG("currentTime %f, startTime %f, accumulator-pre %f, accumulator-post %f, delta %f, deltaTime %f\n",
      // currentTime, startTime, accumulator, accumulator-deltaTime, delta, deltaTime);
      #endif
      PhysicsStep();
      accumulator -= deltaTime;
      }
      // Record the starting of this frame
      startTime = currentTime;
      }
      PHYSACDEF void SetPhysicsTimeStep(double delta)
      {
      deltaTime = delta;
      }
      // Finds a valid index for a new manifold initialization
      static int FindAvailableManifoldIndex()
      {
      int index = -1;
      for (int i = 0; i < PHYSAC_MAX_MANIFOLDS; i++)
      {
      int currentId = i;
      // Check if current id already exist in other physics body
      for (int k = 0; k < physicsManifoldsCount; k++)
      {
      if (contacts[k]->id == currentId)
      {
      currentId++;
      break;
      }
      }
      // If it is not used, use it as new physics body id
      if (currentId == i)
      {
      index = i;
      break;
      }
      }
      return index;
      }
      // Creates a new physics manifold to solve collision
      static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b)
      {
      PhysicsManifold newManifold = (PhysicsManifold)PHYSAC_MALLOC(sizeof(PhysicsManifoldData));
      usedMemory += sizeof(PhysicsManifoldData);
      int newId = FindAvailableManifoldIndex();
      if (newId != -1)
      {
      // Initialize new manifold with generic values
      newManifold->id = newId;
      newManifold->bodyA = a;
      newManifold->bodyB = b;
      newManifold->penetration = 0;
      newManifold->normal = PHYSAC_VECTOR_ZERO;
      newManifold->contacts[0] = PHYSAC_VECTOR_ZERO;
      newManifold->contacts[1] = PHYSAC_VECTOR_ZERO;
      newManifold->contactsCount = 0;
      newManifold->restitution = 0.0f;
      newManifold->dynamicFriction = 0.0f;
      newManifold->staticFriction = 0.0f;
      // Add new body to bodies pointers array and update bodies count
      contacts[physicsManifoldsCount] = newManifold;
      physicsManifoldsCount++;
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] new physics manifold creation failed because there is any available id to use\n");
      #endif
      return newManifold;
      }
      // Unitializes and destroys a physics manifold
      static void DestroyPhysicsManifold(PhysicsManifold manifold)
      {
      if (manifold != NULL)
      {
      int id = manifold->id;
      int index = -1;
      for (int i = 0; i < physicsManifoldsCount; i++)
      {
      if (contacts[i]->id == id)
      {
      index = i;
      break;
      }
      }
      if (index == -1)
      {
      #if defined(PHYSAC_DEBUG)
      TRACELOG("[PHYSAC] Not possible to manifold id %i in pointers array\n", id);
      #endif
      return; // Prevent access to index -1
      }
      // Free manifold allocated memory
      PHYSAC_FREE(manifold);
      usedMemory -= sizeof(PhysicsManifoldData);
      contacts[index] = NULL;
      // Reorder physics manifolds pointers array and its catched index
      for (int i = index; i < physicsManifoldsCount; i++)
      {
      if ((i + 1) < physicsManifoldsCount) contacts[i] = contacts[i + 1];
      }
      // Update physics manifolds count
      physicsManifoldsCount--;
      }
      #if defined(PHYSAC_DEBUG)
      else TRACELOG("[PHYSAC] error trying to destroy a null referenced manifold\n");
      #endif
      }
      // Solves a created physics manifold between two physics bodies
      static void SolvePhysicsManifold(PhysicsManifold manifold)
      {
      switch (manifold->bodyA->shape.type)
      {
      case PHYSICS_CIRCLE:
      {
      switch (manifold->bodyB->shape.type)
      {
      case PHYSICS_CIRCLE: SolveCircleToCircle(manifold); break;
      case PHYSICS_POLYGON: SolveCircleToPolygon(manifold); break;
      default: break;
      }
      } break;
      case PHYSICS_POLYGON:
      {
      switch (manifold->bodyB->shape.type)
      {
      case PHYSICS_CIRCLE: SolvePolygonToCircle(manifold); break;
      case PHYSICS_POLYGON: SolvePolygonToPolygon(manifold); break;
      default: break;
      }
      } break;
      default: break;
      }
      // Update physics body grounded state if normal direction is down and grounded state is not set yet in previous manifolds
      if (!manifold->bodyB->isGrounded) manifold->bodyB->isGrounded = (manifold->normal.y < 0);
      }
      // Solves collision between two circle shape physics bodies
      static void SolveCircleToCircle(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      // Calculate translational vector, which is normal
      Vector2 normal = Vector2Subtract(bodyB->position, bodyA->position);
      float distSqr = MathLenSqr(normal);
      float radius = bodyA->shape.radius + bodyB->shape.radius;
      // Check if circles are not in contact
      if (distSqr >= radius*radius)
      {
      manifold->contactsCount = 0;
      return;
      }
      float distance = sqrtf(distSqr);
      manifold->contactsCount = 1;
      if (distance == 0.0f)
      {
      manifold->penetration = bodyA->shape.radius;
      manifold->normal = (Vector2){ 1.0f, 0.0f };
      manifold->contacts[0] = bodyA->position;
      }
      else
      {
      manifold->penetration = radius - distance;
      manifold->normal = (Vector2){ normal.x/distance, normal.y/distance }; // Faster than using MathNormalize() due to sqrt is already performed
      manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
      }
      // Update physics body grounded state if normal direction is down
      if (!bodyA->isGrounded) bodyA->isGrounded = (manifold->normal.y < 0);
      }
      // Solves collision between a circle to a polygon shape physics bodies
      static void SolveCircleToPolygon(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      manifold->contactsCount = 0;
      // Transform circle center to polygon transform space
      Vector2 center = bodyA->position;
      center = Mat2MultiplyVector2(Mat2Transpose(bodyB->shape.transform), Vector2Subtract(center, bodyB->position));
      // Find edge with minimum penetration
      // It is the same concept as using support points in SolvePolygonToPolygon
      float separation = -PHYSAC_FLT_MAX;
      int faceNormal = 0;
      PolygonData vertexData = bodyB->shape.vertexData;
      for (int i = 0; i < vertexData.vertexCount; i++)
      {
      float currentSeparation = MathDot(vertexData.normals[i], Vector2Subtract(center, vertexData.positions[i]));
      if (currentSeparation > bodyA->shape.radius) return;
      if (currentSeparation > separation)
      {
      separation = currentSeparation;
      faceNormal = i;
      }
      }
      // Grab face's vertices
      Vector2 v1 = vertexData.positions[faceNormal];
      int nextIndex = (((faceNormal + 1) < vertexData.vertexCount) ? (faceNormal + 1) : 0);
      Vector2 v2 = vertexData.positions[nextIndex];
      // Check to see if center is within polygon
      if (separation < PHYSAC_EPSILON)
      {
      manifold->contactsCount = 1;
      Vector2 normal = Mat2MultiplyVector2(bodyB->shape.transform, vertexData.normals[faceNormal]);
      manifold->normal = (Vector2){ -normal.x, -normal.y };
      manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
      manifold->penetration = bodyA->shape.radius;
      return;
      }
      // Determine which voronoi region of the edge center of circle lies within
      float dot1 = MathDot(Vector2Subtract(center, v1), Vector2Subtract(v2, v1));
      float dot2 = MathDot(Vector2Subtract(center, v2), Vector2Subtract(v1, v2));
      manifold->penetration = bodyA->shape.radius - separation;
      if (dot1 <= 0.0f) // Closest to v1
      {
      if (DistSqr(center, v1) > bodyA->shape.radius*bodyA->shape.radius) return;
      manifold->contactsCount = 1;
      Vector2 normal = Vector2Subtract(v1, center);
      normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
      MathNormalize(&normal);
      manifold->normal = normal;
      v1 = Mat2MultiplyVector2(bodyB->shape.transform, v1);
      v1 = Vector2Add(v1, bodyB->position);
      manifold->contacts[0] = v1;
      }
      else if (dot2 <= 0.0f) // Closest to v2
      {
      if (DistSqr(center, v2) > bodyA->shape.radius*bodyA->shape.radius) return;
      manifold->contactsCount = 1;
      Vector2 normal = Vector2Subtract(v2, center);
      v2 = Mat2MultiplyVector2(bodyB->shape.transform, v2);
      v2 = Vector2Add(v2, bodyB->position);
      manifold->contacts[0] = v2;
      normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
      MathNormalize(&normal);
      manifold->normal = normal;
      }
      else // Closest to face
      {
      Vector2 normal = vertexData.normals[faceNormal];
      if (MathDot(Vector2Subtract(center, v1), normal) > bodyA->shape.radius) return;
      normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
      manifold->normal = (Vector2){ -normal.x, -normal.y };
      manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
      manifold->contactsCount = 1;
      }
      }
      // Solves collision between a polygon to a circle shape physics bodies
      static void SolvePolygonToCircle(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      manifold->bodyA = bodyB;
      manifold->bodyB = bodyA;
      SolveCircleToPolygon(manifold);
      manifold->normal.x *= -1.0f;
      manifold->normal.y *= -1.0f;
      }
      // Solves collision between two polygons shape physics bodies
      static void SolvePolygonToPolygon(PhysicsManifold manifold)
      {
      if ((manifold->bodyA == NULL) || (manifold->bodyB == NULL)) return;
      PhysicsShape bodyA = manifold->bodyA->shape;
      PhysicsShape bodyB = manifold->bodyB->shape;
      manifold->contactsCount = 0;
      // Check for separating axis with A shape's face planes
      int faceA = 0;
      float penetrationA = FindAxisLeastPenetration(&faceA, bodyA, bodyB);
      if (penetrationA >= 0.0f) return;
      // Check for separating axis with B shape's face planes
      int faceB = 0;
      float penetrationB = FindAxisLeastPenetration(&faceB, bodyB, bodyA);
      if (penetrationB >= 0.0f) return;
      int referenceIndex = 0;
      bool flip = false; // Always point from A shape to B shape
      PhysicsShape refPoly; // Reference
      PhysicsShape incPoly; // Incident
      // Determine which shape contains reference face
      if (BiasGreaterThan(penetrationA, penetrationB))
      {
      refPoly = bodyA;
      incPoly = bodyB;
      referenceIndex = faceA;
      }
      else
      {
      refPoly = bodyB;
      incPoly = bodyA;
      referenceIndex = faceB;
      flip = true;
      }
      // World space incident face
      Vector2 incidentFace[2];
      FindIncidentFace(&incidentFace[0], &incidentFace[1], refPoly, incPoly, referenceIndex);
      // Setup reference face vertices
      PolygonData refData = refPoly.vertexData;
      Vector2 v1 = refData.positions[referenceIndex];
      referenceIndex = (((referenceIndex + 1) < refData.vertexCount) ? (referenceIndex + 1) : 0);
      Vector2 v2 = refData.positions[referenceIndex];
      // Transform vertices to world space
      v1 = Mat2MultiplyVector2(refPoly.transform, v1);
      v1 = Vector2Add(v1, refPoly.body->position);
      v2 = Mat2MultiplyVector2(refPoly.transform, v2);
      v2 = Vector2Add(v2, refPoly.body->position);
      // Calculate reference face side normal in world space
      Vector2 sidePlaneNormal = Vector2Subtract(v2, v1);
      MathNormalize(&sidePlaneNormal);
      // Orthogonalize
      Vector2 refFaceNormal = { sidePlaneNormal.y, -sidePlaneNormal.x };
      float refC = MathDot(refFaceNormal, v1);
      float negSide = MathDot(sidePlaneNormal, v1)*-1;
      float posSide = MathDot(sidePlaneNormal, v2);
      // Clip incident face to reference face side planes (due to floating point error, possible to not have required points
      if (Clip((Vector2){ -sidePlaneNormal.x, -sidePlaneNormal.y }, negSide, &incidentFace[0], &incidentFace[1]) < 2) return;
      if (Clip(sidePlaneNormal, posSide, &incidentFace[0], &incidentFace[1]) < 2) return;
      // Flip normal if required
      manifold->normal = (flip ? (Vector2){ -refFaceNormal.x, -refFaceNormal.y } : refFaceNormal);
      // Keep points behind reference face
      int currentPoint = 0; // Clipped points behind reference face
      float separation = MathDot(refFaceNormal, incidentFace[0]) - refC;
      if (separation <= 0.0f)
      {
      manifold->contacts[currentPoint] = incidentFace[0];
      manifold->penetration = -separation;
      currentPoint++;
      }
      else manifold->penetration = 0.0f;
      separation = MathDot(refFaceNormal, incidentFace[1]) - refC;
      if (separation <= 0.0f)
      {
      manifold->contacts[currentPoint] = incidentFace[1];
      manifold->penetration += -separation;
      currentPoint++;
      // Calculate total penetration average
      manifold->penetration /= currentPoint;
      }
      manifold->contactsCount = currentPoint;
      }
      // Integrates physics forces into velocity
      static void IntegratePhysicsForces(PhysicsBody body)
      {
      if ((body == NULL) || (body->inverseMass == 0.0f) || !body->enabled) return;
      body->velocity.x += (body->force.x*body->inverseMass)*(deltaTime/2.0);
      body->velocity.y += (body->force.y*body->inverseMass)*(deltaTime/2.0);
      if (body->useGravity)
      {
      body->velocity.x += gravityForce.x*(deltaTime/1000/2.0);
      body->velocity.y += gravityForce.y*(deltaTime/1000/2.0);
      }
      if (!body->freezeOrient) body->angularVelocity += body->torque*body->inverseInertia*(deltaTime/2.0);
      }
      // Initializes physics manifolds to solve collisions
      static void InitializePhysicsManifolds(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      // Calculate average restitution, static and dynamic friction
      manifold->restitution = sqrtf(bodyA->restitution*bodyB->restitution);
      manifold->staticFriction = sqrtf(bodyA->staticFriction*bodyB->staticFriction);
      manifold->dynamicFriction = sqrtf(bodyA->dynamicFriction*bodyB->dynamicFriction);
      for (int i = 0; i < manifold->contactsCount; i++)
      {
      // Caculate radius from center of mass to contact
      Vector2 radiusA = Vector2Subtract(manifold->contacts[i], bodyA->position);
      Vector2 radiusB = Vector2Subtract(manifold->contacts[i], bodyB->position);
      Vector2 crossA = MathCross(bodyA->angularVelocity, radiusA);
      Vector2 crossB = MathCross(bodyB->angularVelocity, radiusB);
      Vector2 radiusV = { 0.0f, 0.0f };
      radiusV.x = bodyB->velocity.x + crossB.x - bodyA->velocity.x - crossA.x;
      radiusV.y = bodyB->velocity.y + crossB.y - bodyA->velocity.y - crossA.y;
      // Determine if we should perform a resting collision or not;
      // The idea is if the only thing moving this object is gravity, then the collision should be performed without any restitution
      if (MathLenSqr(radiusV) < (MathLenSqr((Vector2){ gravityForce.x*deltaTime/1000, gravityForce.y*deltaTime/1000 }) + PHYSAC_EPSILON)) manifold->restitution = 0;
      }
      }
      // Integrates physics collisions impulses to solve collisions
      static void IntegratePhysicsImpulses(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      // Early out and positional correct if both objects have infinite mass
      if (fabs(bodyA->inverseMass + bodyB->inverseMass) <= PHYSAC_EPSILON)
      {
      bodyA->velocity = PHYSAC_VECTOR_ZERO;
      bodyB->velocity = PHYSAC_VECTOR_ZERO;
      return;
      }
      for (int i = 0; i < manifold->contactsCount; i++)
      {
      // Calculate radius from center of mass to contact
      Vector2 radiusA = Vector2Subtract(manifold->contacts[i], bodyA->position);
      Vector2 radiusB = Vector2Subtract(manifold->contacts[i], bodyB->position);
      // Calculate relative velocity
      Vector2 radiusV = { 0.0f, 0.0f };
      radiusV.x = bodyB->velocity.x + MathCross(bodyB->angularVelocity, radiusB).x - bodyA->velocity.x - MathCross(bodyA->angularVelocity, radiusA).x;
      radiusV.y = bodyB->velocity.y + MathCross(bodyB->angularVelocity, radiusB).y - bodyA->velocity.y - MathCross(bodyA->angularVelocity, radiusA).y;
      // Relative velocity along the normal
      float contactVelocity = MathDot(radiusV, manifold->normal);
      // Do not resolve if velocities are separating
      if (contactVelocity > 0.0f) return;
      float raCrossN = MathCrossVector2(radiusA, manifold->normal);
      float rbCrossN = MathCrossVector2(radiusB, manifold->normal);
      float inverseMassSum = bodyA->inverseMass + bodyB->inverseMass + (raCrossN*raCrossN)*bodyA->inverseInertia + (rbCrossN*rbCrossN)*bodyB->inverseInertia;
      // Calculate impulse scalar value
      float impulse = -(1.0f + manifold->restitution)*contactVelocity;
      impulse /= inverseMassSum;
      impulse /= (float)manifold->contactsCount;
      // Apply impulse to each physics body
      Vector2 impulseV = { manifold->normal.x*impulse, manifold->normal.y*impulse };
      if (bodyA->enabled)
      {
      bodyA->velocity.x += bodyA->inverseMass*(-impulseV.x);
      bodyA->velocity.y += bodyA->inverseMass*(-impulseV.y);
      if (!bodyA->freezeOrient) bodyA->angularVelocity += bodyA->inverseInertia*MathCrossVector2(radiusA, (Vector2){ -impulseV.x, -impulseV.y });
      }
      if (bodyB->enabled)
      {
      bodyB->velocity.x += bodyB->inverseMass*(impulseV.x);
      bodyB->velocity.y += bodyB->inverseMass*(impulseV.y);
      if (!bodyB->freezeOrient) bodyB->angularVelocity += bodyB->inverseInertia*MathCrossVector2(radiusB, impulseV);
      }
      // Apply friction impulse to each physics body
      radiusV.x = bodyB->velocity.x + MathCross(bodyB->angularVelocity, radiusB).x - bodyA->velocity.x - MathCross(bodyA->angularVelocity, radiusA).x;
      radiusV.y = bodyB->velocity.y + MathCross(bodyB->angularVelocity, radiusB).y - bodyA->velocity.y - MathCross(bodyA->angularVelocity, radiusA).y;
      Vector2 tangent = { radiusV.x - (manifold->normal.x*MathDot(radiusV, manifold->normal)), radiusV.y - (manifold->normal.y*MathDot(radiusV, manifold->normal)) };
      MathNormalize(&tangent);
      // Calculate impulse tangent magnitude
      float impulseTangent = -MathDot(radiusV, tangent);
      impulseTangent /= inverseMassSum;
      impulseTangent /= (float)manifold->contactsCount;
      float absImpulseTangent = fabs(impulseTangent);
      // Don't apply tiny friction impulses
      if (absImpulseTangent <= PHYSAC_EPSILON) return;
      // Apply coulumb's law
      Vector2 tangentImpulse = { 0.0f, 0.0f };
      if (absImpulseTangent < impulse*manifold->staticFriction) tangentImpulse = (Vector2){ tangent.x*impulseTangent, tangent.y*impulseTangent };
      else tangentImpulse = (Vector2){ tangent.x*-impulse*manifold->dynamicFriction, tangent.y*-impulse*manifold->dynamicFriction };
      // Apply friction impulse
      if (bodyA->enabled)
      {
      bodyA->velocity.x += bodyA->inverseMass*(-tangentImpulse.x);
      bodyA->velocity.y += bodyA->inverseMass*(-tangentImpulse.y);
      if (!bodyA->freezeOrient) bodyA->angularVelocity += bodyA->inverseInertia*MathCrossVector2(radiusA, (Vector2){ -tangentImpulse.x, -tangentImpulse.y });
      }
      if (bodyB->enabled)
      {
      bodyB->velocity.x += bodyB->inverseMass*(tangentImpulse.x);
      bodyB->velocity.y += bodyB->inverseMass*(tangentImpulse.y);
      if (!bodyB->freezeOrient) bodyB->angularVelocity += bodyB->inverseInertia*MathCrossVector2(radiusB, tangentImpulse);
      }
      }
      }
      // Integrates physics velocity into position and forces
      static void IntegratePhysicsVelocity(PhysicsBody body)
      {
      if ((body == NULL) ||!body->enabled) return;
      body->position.x += body->velocity.x*deltaTime;
      body->position.y += body->velocity.y*deltaTime;
      if (!body->freezeOrient) body->orient += body->angularVelocity*deltaTime;
      Mat2Set(&body->shape.transform, body->orient);
      IntegratePhysicsForces(body);
      }
      // Corrects physics bodies positions based on manifolds collision information
      static void CorrectPhysicsPositions(PhysicsManifold manifold)
      {
      PhysicsBody bodyA = manifold->bodyA;
      PhysicsBody bodyB = manifold->bodyB;
      if ((bodyA == NULL) || (bodyB == NULL)) return;
      Vector2 correction = { 0.0f, 0.0f };
      correction.x = (max(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.x*PHYSAC_PENETRATION_CORRECTION;
      correction.y = (max(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.y*PHYSAC_PENETRATION_CORRECTION;
      if (bodyA->enabled)
      {
      bodyA->position.x -= correction.x*bodyA->inverseMass;
      bodyA->position.y -= correction.y*bodyA->inverseMass;
      }
      if (bodyB->enabled)
      {
      bodyB->position.x += correction.x*bodyB->inverseMass;
      bodyB->position.y += correction.y*bodyB->inverseMass;
      }
      }
      // Returns the extreme point along a direction within a polygon
      static Vector2 GetSupport(PhysicsShape shape, Vector2 dir)
      {
      float bestProjection = -PHYSAC_FLT_MAX;
      Vector2 bestVertex = { 0.0f, 0.0f };
      PolygonData data = shape.vertexData;
      for (int i = 0; i < data.vertexCount; i++)
      {
      Vector2 vertex = data.positions[i];
      float projection = MathDot(vertex, dir);
      if (projection > bestProjection)
      {
      bestVertex = vertex;
      bestProjection = projection;
      }
      }
      return bestVertex;
      }
      // Finds polygon shapes axis least penetration
      static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB)
      {
      float bestDistance = -PHYSAC_FLT_MAX;
      int bestIndex = 0;
      PolygonData dataA = shapeA.vertexData;
      //PolygonData dataB = shapeB.vertexData;
      for (int i = 0; i < dataA.vertexCount; i++)
      {
      // Retrieve a face normal from A shape
      Vector2 normal = dataA.normals[i];
      Vector2 transNormal = Mat2MultiplyVector2(shapeA.transform, normal);
      // Transform face normal into B shape's model space
      Matrix2x2 buT = Mat2Transpose(shapeB.transform);
      normal = Mat2MultiplyVector2(buT, transNormal);
      // Retrieve support point from B shape along -n
      Vector2 support = GetSupport(shapeB, (Vector2){ -normal.x, -normal.y });
      // Retrieve vertex on face from A shape, transform into B shape's model space
      Vector2 vertex = dataA.positions[i];
      vertex = Mat2MultiplyVector2(shapeA.transform, vertex);
      vertex = Vector2Add(vertex, shapeA.body->position);
      vertex = Vector2Subtract(vertex, shapeB.body->position);
      vertex = Mat2MultiplyVector2(buT, vertex);
      // Compute penetration distance in B shape's model space
      float distance = MathDot(normal, Vector2Subtract(support, vertex));
      // Store greatest distance
      if (distance > bestDistance)
      {
      bestDistance = distance;
      bestIndex = i;
      }
      }
      *faceIndex = bestIndex;
      return bestDistance;
      }
      // Finds two polygon shapes incident face
      static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index)
      {
      PolygonData refData = ref.vertexData;
      PolygonData incData = inc.vertexData;
      Vector2 referenceNormal = refData.normals[index];
      // Calculate normal in incident's frame of reference
      referenceNormal = Mat2MultiplyVector2(ref.transform, referenceNormal); // To world space
      referenceNormal = Mat2MultiplyVector2(Mat2Transpose(inc.transform), referenceNormal); // To incident's model space
      // Find most anti-normal face on polygon
      int incidentFace = 0;
      float minDot = PHYSAC_FLT_MAX;
      for (int i = 0; i < incData.vertexCount; i++)
      {
      float dot = MathDot(referenceNormal, incData.normals[i]);
      if (dot < minDot)
      {
      minDot = dot;
      incidentFace = i;
      }
      }
      // Assign face vertices for incident face
      *v0 = Mat2MultiplyVector2(inc.transform, incData.positions[incidentFace]);
      *v0 = Vector2Add(*v0, inc.body->position);
      incidentFace = (((incidentFace + 1) < incData.vertexCount) ? (incidentFace + 1) : 0);
      *v1 = Mat2MultiplyVector2(inc.transform, incData.positions[incidentFace]);
      *v1 = Vector2Add(*v1, inc.body->position);
      }
      // Calculates clipping based on a normal and two faces
      static int Clip(Vector2 normal, float clip, Vector2 *faceA, Vector2 *faceB)
      {
      int sp = 0;
      Vector2 out[2] = { *faceA, *faceB };
      // Retrieve distances from each endpoint to the line
      float distanceA = MathDot(normal, *faceA) - clip;
      float distanceB = MathDot(normal, *faceB) - clip;
      // If negative (behind plane)
      if (distanceA <= 0.0f) out[sp++] = *faceA;
      if (distanceB <= 0.0f) out[sp++] = *faceB;
      // If the points are on different sides of the plane
      if ((distanceA*distanceB) < 0.0f)
      {
      // Push intersection point
      float alpha = distanceA/(distanceA - distanceB);
      out[sp] = *faceA;
      Vector2 delta = Vector2Subtract(*faceB, *faceA);
      delta.x *= alpha;
      delta.y *= alpha;
      out[sp] = Vector2Add(out[sp], delta);
      sp++;
      }
      // Assign the new converted values
      *faceA = out[0];
      *faceB = out[1];
      return sp;
      }
      // Check if values are between bias range
      static bool BiasGreaterThan(float valueA, float valueB)
      {
      return (valueA >= (valueB*0.95f + valueA*0.01f));
      }
      // Returns the barycenter of a triangle given by 3 points
      static Vector2 TriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3)
      {
      Vector2 result = { 0.0f, 0.0f };
      result.x = (v1.x + v2.x + v3.x)/3;
      result.y = (v1.y + v2.y + v3.y)/3;
      return result;
      }
      // Initializes hi-resolution MONOTONIC timer
      static void InitTimer(void)
      {
      srand(time(NULL)); // Initialize random seed
      #if defined(_WIN32)
      QueryPerformanceFrequency((unsigned long long int *) &frequency);
      #endif
      #if defined(__EMSCRIPTEN__) || defined(__linux__)
      struct timespec now;
      if (clock_gettime(CLOCK_MONOTONIC, &now) == 0) frequency = 1000000000;
      #endif
      #if defined(__APPLE__)
      mach_timebase_info_data_t timebase;
      mach_timebase_info(&timebase);
      frequency = (timebase.denom*1e9)/timebase.numer;
      #endif
      baseTime = GetTimeCount(); // Get MONOTONIC clock time offset
      startTime = GetCurrentTime(); // Get current time
      }
      // Get hi-res MONOTONIC time measure in seconds
      static unsigned long long int GetTimeCount(void)
      {
      unsigned long long int value = 0;
      #if defined(_WIN32)
      QueryPerformanceCounter((unsigned long long int *) &value);
      #endif
      #if defined(__linux__)
      struct timespec now;
      clock_gettime(CLOCK_MONOTONIC, &now);
      value = (unsigned long long int)now.tv_sec*(unsigned long long int)1000000000 + (unsigned long long int)now.tv_nsec;
      #endif
      #if defined(__APPLE__)
      value = mach_absolute_time();
      #endif
      return value;
      }
      // Get current time in milliseconds
      static double GetCurrentTime(void)
      {
      return (double)(GetTimeCount() - baseTime)/frequency*1000;
      }
      // Returns the cross product of a vector and a value
      static inline Vector2 MathCross(float value, Vector2 vector)
      {
      return (Vector2){ -value*vector.y, value*vector.x };
      }
      // Returns the cross product of two vectors
      static inline float MathCrossVector2(Vector2 v1, Vector2 v2)
      {
      return (v1.x*v2.y - v1.y*v2.x);
      }
      // Returns the len square root of a vector
      static inline float MathLenSqr(Vector2 vector)
      {
      return (vector.x*vector.x + vector.y*vector.y);
      }
      // Returns the dot product of two vectors
      static inline float MathDot(Vector2 v1, Vector2 v2)
      {
      return (v1.x*v2.x + v1.y*v2.y);
      }
      // Returns the square root of distance between two vectors
      static inline float DistSqr(Vector2 v1, Vector2 v2)
      {
      Vector2 dir = Vector2Subtract(v1, v2);
      return MathDot(dir, dir);
      }
      // Returns the normalized values of a vector
      static void MathNormalize(Vector2 *vector)
      {
      float length, ilength;
      Vector2 aux = *vector;
      length = sqrtf(aux.x*aux.x + aux.y*aux.y);
      if (length == 0) length = 1.0f;
      ilength = 1.0f/length;
      vector->x *= ilength;
      vector->y *= ilength;
      }
      #if defined(PHYSAC_STANDALONE)
      // Returns the sum of two given vectors
      static inline Vector2 Vector2Add(Vector2 v1, Vector2 v2)
      {
      return (Vector2){ v1.x + v2.x, v1.y + v2.y };
      }
      // Returns the subtract of two given vectors
      static inline Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
      {
      return (Vector2){ v1.x - v2.x, v1.y - v2.y };
      }
      #endif
      // Creates a matrix 2x2 from a given radians value
      static Matrix2x2 Mat2Radians(float radians)
      {
      float c = cosf(radians);
      float s = sinf(radians);
      return (Matrix2x2){ c, -s, s, c };
      }
      // Set values from radians to a created matrix 2x2
      static void Mat2Set(Matrix2x2 *matrix, float radians)
      {
      float cos = cosf(radians);
      float sin = sinf(radians);
      matrix->m00 = cos;
      matrix->m01 = -sin;
      matrix->m10 = sin;
      matrix->m11 = cos;
      }
      // Returns the transpose of a given matrix 2x2
      static inline Matrix2x2 Mat2Transpose(Matrix2x2 matrix)
      {
      return (Matrix2x2){ matrix.m00, matrix.m10, matrix.m01, matrix.m11 };
      }
      // Multiplies a vector by a matrix 2x2
      static inline Vector2 Mat2MultiplyVector2(Matrix2x2 matrix, Vector2 vector)
      {
      return (Vector2){ matrix.m00*vector.x + matrix.m01*vector.y, matrix.m10*vector.x + matrix.m11*vector.y };
      }
      #endif // PHYSAC_IMPLEMENTATION
      physics_movement.c 0 → 100644
      View file @ 30949fb0
      /*******************************************************************************************
      *
      * Physac - Physics movement
      *
      * NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
      * NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
      *
      * Use the following line to compile:
      *
      * gcc -o $(NAME_PART).exe $(FILE_NAME) -s -static /
      * -lraylib -lpthread -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm /
      * -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
      *
      * Copyright (c) 2016-2018 Victor Fisac
      *
      ********************************************************************************************/
      #include "raylib.h"
      #define PHYSAC_IMPLEMENTATION
      #define PHYSAC_NO_THREADS
      #include "physac.h"
      #define VELOCITY 0.5f
      int main(void)
      {
      // Initialization
      //--------------------------------------------------------------------------------------
      const int screenWidth = 800;
      const int screenHeight = 450;
      SetConfigFlags(FLAG_MSAA_4X_HINT);
      InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
      // Physac logo drawing position
      int logoX = screenWidth - MeasureText("Physac", 30) - 10;
      int logoY = 15;
      // Initialize physics and default physics bodies
      InitPhysics();
      // Create floor and walls rectangle physics body
      PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
      PhysicsBody platformLeft = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.25f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
      PhysicsBody platformRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.75f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
      PhysicsBody wallLeft = CreatePhysicsBodyRectangle((Vector2){ -5, screenHeight/2 }, 10, screenHeight, 10);
      PhysicsBody wallRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth + 5, screenHeight/2 }, 10, screenHeight, 10);
      // Disable dynamics to floor and walls physics bodies
      floor->enabled = false;
      platformLeft->enabled = false;
      platformRight->enabled = false;
      wallLeft->enabled = false;
      wallRight->enabled = false;
      // Create movement physics body
      PhysicsBody body = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight/2 }, 50, 50, 1);
      body->freezeOrient = true; // Constrain body rotation to avoid little collision torque amounts
      SetTargetFPS(60); // Set our game to run at 60 frames-per-second
      //--------------------------------------------------------------------------------------
      // Main game loop
      while (!WindowShouldClose()) // Detect window close button or ESC key
      {
      // Update
      //----------------------------------------------------------------------------------
      RunPhysicsStep();
      if (IsKeyPressed('R')) // Reset physics input
      {
      // Reset movement physics body position, velocity and rotation
      body->position = (Vector2){ screenWidth/2, screenHeight/2 };
      body->velocity = (Vector2){ 0, 0 };
      SetPhysicsBodyRotation(body, 0);
      }
      // Horizontal movement input
      if (IsKeyDown(KEY_RIGHT)) body->velocity.x = VELOCITY;
      else if (IsKeyDown(KEY_LEFT)) body->velocity.x = -VELOCITY;
      // Vertical movement input checking if player physics body is grounded
      if (IsKeyDown(KEY_UP) && body->isGrounded) body->velocity.y = -VELOCITY*4;
      //----------------------------------------------------------------------------------
      // Draw
      //----------------------------------------------------------------------------------
      BeginDrawing();
      ClearBackground(BLACK);
      DrawFPS(screenWidth - 90, screenHeight - 30);
      // Draw created physics bodies
      int bodiesCount = GetPhysicsBodiesCount();
      for (int i = 0; i < bodiesCount; i++)
      {
      PhysicsBody body = GetPhysicsBody(i);
      int vertexCount = GetPhysicsShapeVerticesCount(i);
      for (int j = 0; j < vertexCount; j++)
      {
      // Get physics bodies shape vertices to draw lines
      // Note: GetPhysicsShapeVertex() already calculates rotation transformations
      Vector2 vertexA = GetPhysicsShapeVertex(body, j);
      int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
      Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
      DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
      }
      }
      DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
      DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
      DrawText("Physac", logoX, logoY, 30, WHITE);
      DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
      EndDrawing();
      //----------------------------------------------------------------------------------
      }
      // De-Initialization
      //--------------------------------------------------------------------------------------
      ClosePhysics(); // Unitialize physics
      CloseWindow(); // Close window and OpenGL context
      //--------------------------------------------------------------------------------------
      return 0;
      }
      raylib.h 0 → 100644
      View file @ 30949fb0
      /**********************************************************************************************
      *
      * raylib - A simple and easy-to-use library to enjoy videogames programming (www.raylib.com)
      *
      * FEATURES:
      * - NO external dependencies, all required libraries included with raylib
      * - Multiplatform: Windows, Linux, FreeBSD, OpenBSD, NetBSD, DragonFly, MacOS, UWP, Android, Raspberry Pi, HTML5.
      * - Written in plain C code (C99) in PascalCase/camelCase notation
      * - Hardware accelerated with OpenGL (1.1, 2.1, 3.3 or ES2 - choose at compile)
      * - Unique OpenGL abstraction layer (usable as standalone module): [rlgl]
      * - Multiple Fonts formats supported (TTF, XNA fonts, AngelCode fonts)
      * - Outstanding texture formats support, including compressed formats (DXT, ETC, ASTC)
      * - Full 3d support for 3d Shapes, Models, Billboards, Heightmaps and more!
      * - Flexible Materials system, supporting classic maps and PBR maps
      * - Skeletal Animation support (CPU bones-based animation)
      * - Shaders support, including Model shaders and Postprocessing shaders
      * - Powerful math module for Vector, Matrix and Quaternion operations: [raymath]
      * - Audio loading and playing with streaming support (WAV, OGG, MP3, FLAC, XM, MOD)
      * - VR stereo rendering with configurable HMD device parameters
      * - Bindings to multiple programming languages available!
      *
      * NOTES:
      * One custom font is loaded by default when InitWindow() [core]
      * If using OpenGL 3.3 or ES2, one default shader is loaded automatically (internally defined) [rlgl]
      * If using OpenGL 3.3 or ES2, several vertex buffers (VAO/VBO) are created to manage lines-triangles-quads
      *
      * DEPENDENCIES (included):
      * [core] rglfw (github.com/glfw/glfw) for window/context management and input (only PLATFORM_DESKTOP)
      * [rlgl] glad (github.com/Dav1dde/glad) for OpenGL 3.3 extensions loading (only PLATFORM_DESKTOP)
      * [raudio] miniaudio (github.com/dr-soft/miniaudio) for audio device/context management
      *
      * OPTIONAL DEPENDENCIES (included):
      * [core] rgif (Charlie Tangora, Ramon Santamaria) for GIF recording
      * [textures] stb_image (Sean Barret) for images loading (BMP, TGA, PNG, JPEG, HDR...)
      * [textures] stb_image_write (Sean Barret) for image writting (BMP, TGA, PNG, JPG)
      * [textures] stb_image_resize (Sean Barret) for image resizing algorithms
      * [textures] stb_perlin (Sean Barret) for Perlin noise image generation
      * [text] stb_truetype (Sean Barret) for ttf fonts loading
      * [text] stb_rect_pack (Sean Barret) for rectangles packing
      * [models] par_shapes (Philip Rideout) for parametric 3d shapes generation
      * [models] tinyobj_loader_c (Syoyo Fujita) for models loading (OBJ, MTL)
      * [models] cgltf (Johannes Kuhlmann) for models loading (glTF)
      * [raudio] stb_vorbis (Sean Barret) for OGG audio loading
      * [raudio] dr_flac (David Reid) for FLAC audio file loading
      * [raudio] dr_mp3 (David Reid) for MP3 audio file loading
      * [raudio] jar_xm (Joshua Reisenauer) for XM audio module loading
      * [raudio] jar_mod (Joshua Reisenauer) for MOD audio module loading
      *
      *
      * LICENSE: zlib/libpng
      *
      * raylib is licensed under an unmodified zlib/libpng license, which is an OSI-certified,
      * BSD-like license that allows static linking with closed source software:
      *
      * Copyright (c) 2013-2020 Ramon Santamaria (@raysan5)
      *
      * This software is provided "as-is", without any express or implied warranty. In no event
      * will the authors be held liable for any damages arising from the use of this software.
      *
      * Permission is granted to anyone to use this software for any purpose, including commercial
      * applications, and to alter it and redistribute it freely, subject to the following restrictions:
      *
      * 1. The origin of this software must not be misrepresented; you must not claim that you
      * wrote the original software. If you use this software in a product, an acknowledgment
      * in the product documentation would be appreciated but is not required.
      *
      * 2. Altered source versions must be plainly marked as such, and must not be misrepresented
      * as being the original software.
      *
      * 3. This notice may not be removed or altered from any source distribution.
      *
      **********************************************************************************************/
      #ifndef RAYLIB_H
      #define RAYLIB_H
      #include <stdarg.h> // Required for: va_list - Only used by TraceLogCallback
      #if defined(_WIN32)
      // Microsoft attibutes to tell compiler that symbols are imported/exported from a .dll
      #if defined(BUILD_LIBTYPE_SHARED)
      #define RLAPI __declspec(dllexport) // We are building raylib as a Win32 shared library (.dll)
      #elif defined(USE_LIBTYPE_SHARED)
      #define RLAPI __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll)
      #else
      #define RLAPI // We are building or using raylib as a static library
      #endif
      #else
      #define RLAPI // We are building or using raylib as a static library (or Linux shared library)
      #endif
      //----------------------------------------------------------------------------------
      // Some basic Defines
      //----------------------------------------------------------------------------------
      #ifndef PI
      #define PI 3.14159265358979323846f
      #endif
      #define DEG2RAD (PI/180.0f)
      #define RAD2DEG (180.0f/PI)
      #define MAX_TOUCH_POINTS 10 // Maximum number of touch points supported
      // Allow custom memory allocators
      #ifndef RL_MALLOC
      #define RL_MALLOC(sz) malloc(sz)
      #endif
      #ifndef RL_CALLOC
      #define RL_CALLOC(n,sz) calloc(n,sz)
      #endif
      #ifndef RL_REALLOC
      #define RL_REALLOC(ptr,sz) realloc(ptr,sz)
      #endif
      #ifndef RL_FREE
      #define RL_FREE(ptr) free(ptr)
      #endif
      // NOTE: MSC C++ compiler does not support compound literals (C99 feature)
      // Plain structures in C++ (without constructors) can be initialized from { } initializers.
      #if defined(__cplusplus)
      #define CLITERAL(type) type
      #else
      #define CLITERAL(type) (type)
      #endif
      // Some Basic Colors
      // NOTE: Custom raylib color palette for amazing visuals on WHITE background
      #define LIGHTGRAY CLITERAL(Color){ 200, 200, 200, 255 } // Light Gray
      #define GRAY CLITERAL(Color){ 130, 130, 130, 255 } // Gray
      #define DARKGRAY CLITERAL(Color){ 80, 80, 80, 255 } // Dark Gray
      #define YELLOW CLITERAL(Color){ 253, 249, 0, 255 } // Yellow
      #define GOLD CLITERAL(Color){ 255, 203, 0, 255 } // Gold
      #define ORANGE CLITERAL(Color){ 255, 161, 0, 255 } // Orange
      #define PINK CLITERAL(Color){ 255, 109, 194, 255 } // Pink
      #define RED CLITERAL(Color){ 230, 41, 55, 255 } // Red
      #define MAROON CLITERAL(Color){ 190, 33, 55, 255 } // Maroon
      #define GREEN CLITERAL(Color){ 0, 228, 48, 255 } // Green
      #define LIME CLITERAL(Color){ 0, 158, 47, 255 } // Lime
      #define DARKGREEN CLITERAL(Color){ 0, 117, 44, 255 } // Dark Green
      #define SKYBLUE CLITERAL(Color){ 102, 191, 255, 255 } // Sky Blue
      #define BLUE CLITERAL(Color){ 0, 121, 241, 255 } // Blue
      #define DARKBLUE CLITERAL(Color){ 0, 82, 172, 255 } // Dark Blue
      #define PURPLE CLITERAL(Color){ 200, 122, 255, 255 } // Purple
      #define VIOLET CLITERAL(Color){ 135, 60, 190, 255 } // Violet
      #define DARKPURPLE CLITERAL(Color){ 112, 31, 126, 255 } // Dark Purple
      #define BEIGE CLITERAL(Color){ 211, 176, 131, 255 } // Beige
      #define BROWN CLITERAL(Color){ 127, 106, 79, 255 } // Brown
      #define DARKBROWN CLITERAL(Color){ 76, 63, 47, 255 } // Dark Brown
      #define WHITE CLITERAL(Color){ 255, 255, 255, 255 } // White
      #define BLACK CLITERAL(Color){ 0, 0, 0, 255 } // Black
      #define BLANK CLITERAL(Color){ 0, 0, 0, 0 } // Blank (Transparent)
      #define MAGENTA CLITERAL(Color){ 255, 0, 255, 255 } // Magenta
      #define RAYWHITE CLITERAL(Color){ 245, 245, 245, 255 } // My own White (raylib logo)
      // Temporal hack to avoid breaking old codebases using
      // deprecated raylib implementation of these functions
      #define FormatText TextFormat
      #define SubText TextSubtext
      #define ShowWindow UnhideWindow
      #define LoadText LoadFileText
      //----------------------------------------------------------------------------------
      // Structures Definition
      //----------------------------------------------------------------------------------
      // Boolean type
      #if defined(__STDC__) && __STDC_VERSION__ >= 199901L
      #include <stdbool.h>
      #elif !defined(__cplusplus) && !defined(bool)
      typedef enum { false, true } bool;
      #endif
      // Vector2 type
      typedef struct Vector2 {
      float x;
      float y;
      } Vector2;
      // Vector3 type
      typedef struct Vector3 {
      float x;
      float y;
      float z;
      } Vector3;
      // Vector4 type
      typedef struct Vector4 {
      float x;
      float y;
      float z;
      float w;
      } Vector4;
      // Quaternion type, same as Vector4
      typedef Vector4 Quaternion;
      // Matrix type (OpenGL style 4x4 - right handed, column major)
      typedef struct Matrix {
      float m0, m4, m8, m12;
      float m1, m5, m9, m13;
      float m2, m6, m10, m14;
      float m3, m7, m11, m15;
      } Matrix;
      // Color type, RGBA (32bit)
      typedef struct Color {
      unsigned char r;
      unsigned char g;
      unsigned char b;
      unsigned char a;
      } Color;
      // Rectangle type
      typedef struct Rectangle {
      float x;
      float y;
      float width;
      float height;
      } Rectangle;
      // Image type, bpp always RGBA (32bit)
      // NOTE: Data stored in CPU memory (RAM)
      typedef struct Image {
      void *data; // Image raw data
      int width; // Image base width
      int height; // Image base height
      int mipmaps; // Mipmap levels, 1 by default
      int format; // Data format (PixelFormat type)
      } Image;
      // Texture2D type
      // NOTE: Data stored in GPU memory
      typedef struct Texture2D {
      unsigned int id; // OpenGL texture id
      int width; // Texture base width
      int height; // Texture base height
      int mipmaps; // Mipmap levels, 1 by default
      int format; // Data format (PixelFormat type)
      } Texture2D;
      // Texture type, same as Texture2D
      typedef Texture2D Texture;
      // TextureCubemap type, actually, same as Texture2D
      typedef Texture2D TextureCubemap;
      // RenderTexture2D type, for texture rendering
      typedef struct RenderTexture2D {
      unsigned int id; // OpenGL Framebuffer Object (FBO) id
      Texture2D texture; // Color buffer attachment texture
      Texture2D depth; // Depth buffer attachment texture
      bool depthTexture; // Track if depth attachment is a texture or renderbuffer
      } RenderTexture2D;
      // RenderTexture type, same as RenderTexture2D
      typedef RenderTexture2D RenderTexture;
      // N-Patch layout info
      typedef struct NPatchInfo {
      Rectangle sourceRec; // Region in the texture
      int left; // left border offset
      int top; // top border offset
      int right; // right border offset
      int bottom; // bottom border offset
      int type; // layout of the n-patch: 3x3, 1x3 or 3x1
      } NPatchInfo;
      // Font character info
      typedef struct CharInfo {
      int value; // Character value (Unicode)
      int offsetX; // Character offset X when drawing
      int offsetY; // Character offset Y when drawing
      int advanceX; // Character advance position X
      Image image; // Character image data
      } CharInfo;
      // Font type, includes texture and charSet array data
      typedef struct Font {
      int baseSize; // Base size (default chars height)
      int charsCount; // Number of characters
      Texture2D texture; // Characters texture atlas
      Rectangle *recs; // Characters rectangles in texture
      CharInfo *chars; // Characters info data
      } Font;
      #define SpriteFont Font // SpriteFont type fallback, defaults to Font
      // Camera type, defines a camera position/orientation in 3d space
      typedef struct Camera3D {
      Vector3 position; // Camera position
      Vector3 target; // Camera target it looks-at
      Vector3 up; // Camera up vector (rotation over its axis)
      float fovy; // Camera field-of-view apperture in Y (degrees) in perspective, used as near plane width in orthographic
      int type; // Camera type, defines projection type: CAMERA_PERSPECTIVE or CAMERA_ORTHOGRAPHIC
      } Camera3D;
      typedef Camera3D Camera; // Camera type fallback, defaults to Camera3D
      // Camera2D type, defines a 2d camera
      typedef struct Camera2D {
      Vector2 offset; // Camera offset (displacement from target)
      Vector2 target; // Camera target (rotation and zoom origin)
      float rotation; // Camera rotation in degrees
      float zoom; // Camera zoom (scaling), should be 1.0f by default
      } Camera2D;
      // Vertex data definning a mesh
      // NOTE: Data stored in CPU memory (and GPU)
      typedef struct Mesh {
      int vertexCount; // Number of vertices stored in arrays
      int triangleCount; // Number of triangles stored (indexed or not)
      // Default vertex data
      float *vertices; // Vertex position (XYZ - 3 components per vertex) (shader-location = 0)
      float *texcoords; // Vertex texture coordinates (UV - 2 components per vertex) (shader-location = 1)
      float *texcoords2; // Vertex second texture coordinates (useful for lightmaps) (shader-location = 5)
      float *normals; // Vertex normals (XYZ - 3 components per vertex) (shader-location = 2)
      float *tangents; // Vertex tangents (XYZW - 4 components per vertex) (shader-location = 4)
      unsigned char *colors; // Vertex colors (RGBA - 4 components per vertex) (shader-location = 3)
      unsigned short *indices;// Vertex indices (in case vertex data comes indexed)
      // Animation vertex data
      float *animVertices; // Animated vertex positions (after bones transformations)
      float *animNormals; // Animated normals (after bones transformations)
      int *boneIds; // Vertex bone ids, up to 4 bones influence by vertex (skinning)
      float *boneWeights; // Vertex bone weight, up to 4 bones influence by vertex (skinning)
      // OpenGL identifiers
      unsigned int vaoId; // OpenGL Vertex Array Object id
      unsigned int *vboId; // OpenGL Vertex Buffer Objects id (default vertex data)
      } Mesh;
      // Shader type (generic)
      typedef struct Shader {
      unsigned int id; // Shader program id
      int *locs; // Shader locations array (MAX_SHADER_LOCATIONS)
      } Shader;
      // Material texture map
      typedef struct MaterialMap {
      Texture2D texture; // Material map texture
      Color color; // Material map color
      float value; // Material map value
      } MaterialMap;
      // Material type (generic)
      typedef struct Material {
      Shader shader; // Material shader
      MaterialMap *maps; // Material maps array (MAX_MATERIAL_MAPS)
      float *params; // Material generic parameters (if required)
      } Material;
      // Transformation properties
      typedef struct Transform {
      Vector3 translation; // Translation
      Quaternion rotation; // Rotation
      Vector3 scale; // Scale
      } Transform;
      // Bone information
      typedef struct BoneInfo {
      char name[32]; // Bone name
      int parent; // Bone parent
      } BoneInfo;
      // Model type
      typedef struct Model {
      Matrix transform; // Local transform matrix
      int meshCount; // Number of meshes
      Mesh *meshes; // Meshes array
      int materialCount; // Number of materials
      Material *materials; // Materials array
      int *meshMaterial; // Mesh material number
      // Animation data
      int boneCount; // Number of bones
      BoneInfo *bones; // Bones information (skeleton)
      Transform *bindPose; // Bones base transformation (pose)
      } Model;
      // Model animation
      typedef struct ModelAnimation {
      int boneCount; // Number of bones
      BoneInfo *bones; // Bones information (skeleton)
      int frameCount; // Number of animation frames
      Transform **framePoses; // Poses array by frame
      } ModelAnimation;
      // Ray type (useful for raycast)
      typedef struct Ray {
      Vector3 position; // Ray position (origin)
      Vector3 direction; // Ray direction
      } Ray;
      // Raycast hit information
      typedef struct RayHitInfo {
      bool hit; // Did the ray hit something?
      float distance; // Distance to nearest hit
      Vector3 position; // Position of nearest hit
      Vector3 normal; // Surface normal of hit
      } RayHitInfo;
      // Bounding box type
      typedef struct BoundingBox {
      Vector3 min; // Minimum vertex box-corner
      Vector3 max; // Maximum vertex box-corner
      } BoundingBox;
      // Wave type, defines audio wave data
      typedef struct Wave {
      unsigned int sampleCount; // Total number of samples
      unsigned int sampleRate; // Frequency (samples per second)
      unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
      unsigned int channels; // Number of channels (1-mono, 2-stereo)
      void *data; // Buffer data pointer
      } Wave;
      typedef struct rAudioBuffer rAudioBuffer;
      // Audio stream type
      // NOTE: Useful to create custom audio streams not bound to a specific file
      typedef struct AudioStream {
      unsigned int sampleRate; // Frequency (samples per second)
      unsigned int sampleSize; // Bit depth (bits per sample): 8, 16, 32 (24 not supported)
      unsigned int channels; // Number of channels (1-mono, 2-stereo)
      rAudioBuffer *buffer; // Pointer to internal data used by the audio system
      } AudioStream;
      // Sound source type
      typedef struct Sound {
      unsigned int sampleCount; // Total number of samples
      AudioStream stream; // Audio stream
      } Sound;
      // Music stream type (audio file streaming from memory)
      // NOTE: Anything longer than ~10 seconds should be streamed
      typedef struct Music {
      int ctxType; // Type of music context (audio filetype)
      void *ctxData; // Audio context data, depends on type
      unsigned int sampleCount; // Total number of samples
      unsigned int loopCount; // Loops count (times music will play), 0 means infinite loop
      AudioStream stream; // Audio stream
      } Music;
      // Head-Mounted-Display device parameters
      typedef struct VrDeviceInfo {
      int hResolution; // HMD horizontal resolution in pixels
      int vResolution; // HMD vertical resolution in pixels
      float hScreenSize; // HMD horizontal size in meters
      float vScreenSize; // HMD vertical size in meters
      float vScreenCenter; // HMD screen center in meters
      float eyeToScreenDistance; // HMD distance between eye and display in meters
      float lensSeparationDistance; // HMD lens separation distance in meters
      float interpupillaryDistance; // HMD IPD (distance between pupils) in meters
      float lensDistortionValues[4]; // HMD lens distortion constant parameters
      float chromaAbCorrection[4]; // HMD chromatic aberration correction parameters
      } VrDeviceInfo;
      //----------------------------------------------------------------------------------
      // Enumerators Definition
      //----------------------------------------------------------------------------------
      // System config flags
      // NOTE: Used for bit masks
      typedef enum {
      FLAG_RESERVED = 1, // Reserved
      FLAG_FULLSCREEN_MODE = 2, // Set to run program in fullscreen
      FLAG_WINDOW_RESIZABLE = 4, // Set to allow resizable window
      FLAG_WINDOW_UNDECORATED = 8, // Set to disable window decoration (frame and buttons)
      FLAG_WINDOW_TRANSPARENT = 16, // Set to allow transparent window
      FLAG_WINDOW_HIDDEN = 128, // Set to create the window initially hidden
      FLAG_WINDOW_ALWAYS_RUN = 256, // Set to allow windows running while minimized
      FLAG_MSAA_4X_HINT = 32, // Set to try enabling MSAA 4X
      FLAG_VSYNC_HINT = 64 // Set to try enabling V-Sync on GPU
      } ConfigFlag;
      // Trace log type
      typedef enum {
      LOG_ALL = 0, // Display all logs
      LOG_TRACE,
      LOG_DEBUG,
      LOG_INFO,
      LOG_WARNING,
      LOG_ERROR,
      LOG_FATAL,
      LOG_NONE // Disable logging
      } TraceLogType;
      // Keyboard keys
      typedef enum {
      // Alphanumeric keys
      KEY_APOSTROPHE = 39,
      KEY_COMMA = 44,
      KEY_MINUS = 45,
      KEY_PERIOD = 46,
      KEY_SLASH = 47,
      KEY_ZERO = 48,
      KEY_ONE = 49,
      KEY_TWO = 50,
      KEY_THREE = 51,
      KEY_FOUR = 52,
      KEY_FIVE = 53,
      KEY_SIX = 54,
      KEY_SEVEN = 55,
      KEY_EIGHT = 56,
      KEY_NINE = 57,
      KEY_SEMICOLON = 59,
      KEY_EQUAL = 61,
      KEY_A = 65,
      KEY_B = 66,
      KEY_C = 67,
      KEY_D = 68,
      KEY_E = 69,
      KEY_F = 70,
      KEY_G = 71,
      KEY_H = 72,
      KEY_I = 73,
      KEY_J = 74,
      KEY_K = 75,
      KEY_L = 76,
      KEY_M = 77,
      KEY_N = 78,
      KEY_O = 79,
      KEY_P = 80,
      KEY_Q = 81,
      KEY_R = 82,
      KEY_S = 83,
      KEY_T = 84,
      KEY_U = 85,
      KEY_V = 86,
      KEY_W = 87,
      KEY_X = 88,
      KEY_Y = 89,
      KEY_Z = 90,
      // Function keys
      KEY_SPACE = 32,
      KEY_ESCAPE = 256,
      KEY_ENTER = 257,
      KEY_TAB = 258,
      KEY_BACKSPACE = 259,
      KEY_INSERT = 260,
      KEY_DELETE = 261,
      KEY_RIGHT = 262,
      KEY_LEFT = 263,
      KEY_DOWN = 264,
      KEY_UP = 265,
      KEY_PAGE_UP = 266,
      KEY_PAGE_DOWN = 267,
      KEY_HOME = 268,
      KEY_END = 269,
      KEY_CAPS_LOCK = 280,
      KEY_SCROLL_LOCK = 281,
      KEY_NUM_LOCK = 282,
      KEY_PRINT_SCREEN = 283,
      KEY_PAUSE = 284,
      KEY_F1 = 290,
      KEY_F2 = 291,
      KEY_F3 = 292,
      KEY_F4 = 293,
      KEY_F5 = 294,
      KEY_F6 = 295,
      KEY_F7 = 296,
      KEY_F8 = 297,
      KEY_F9 = 298,
      KEY_F10 = 299,
      KEY_F11 = 300,
      KEY_F12 = 301,
      KEY_LEFT_SHIFT = 340,
      KEY_LEFT_CONTROL = 341,
      KEY_LEFT_ALT = 342,
      KEY_LEFT_SUPER = 343,
      KEY_RIGHT_SHIFT = 344,
      KEY_RIGHT_CONTROL = 345,
      KEY_RIGHT_ALT = 346,
      KEY_RIGHT_SUPER = 347,
      KEY_KB_MENU = 348,
      KEY_LEFT_BRACKET = 91,
      KEY_BACKSLASH = 92,
      KEY_RIGHT_BRACKET = 93,
      KEY_GRAVE = 96,
      // Keypad keys
      KEY_KP_0 = 320,
      KEY_KP_1 = 321,
      KEY_KP_2 = 322,
      KEY_KP_3 = 323,
      KEY_KP_4 = 324,
      KEY_KP_5 = 325,
      KEY_KP_6 = 326,
      KEY_KP_7 = 327,
      KEY_KP_8 = 328,
      KEY_KP_9 = 329,
      KEY_KP_DECIMAL = 330,
      KEY_KP_DIVIDE = 331,
      KEY_KP_MULTIPLY = 332,
      KEY_KP_SUBTRACT = 333,
      KEY_KP_ADD = 334,
      KEY_KP_ENTER = 335,
      KEY_KP_EQUAL = 336
      } KeyboardKey;
      // Android buttons
      typedef enum {
      KEY_BACK = 4,
      KEY_MENU = 82,
      KEY_VOLUME_UP = 24,
      KEY_VOLUME_DOWN = 25
      } AndroidButton;
      // Mouse buttons
      typedef enum {
      MOUSE_LEFT_BUTTON = 0,
      MOUSE_RIGHT_BUTTON = 1,
      MOUSE_MIDDLE_BUTTON = 2
      } MouseButton;
      // Gamepad number
      typedef enum {
      GAMEPAD_PLAYER1 = 0,
      GAMEPAD_PLAYER2 = 1,
      GAMEPAD_PLAYER3 = 2,
      GAMEPAD_PLAYER4 = 3
      } GamepadNumber;
      // Gamepad Buttons
      typedef enum {
      // This is here just for error checking
      GAMEPAD_BUTTON_UNKNOWN = 0,
      // This is normally a DPAD
      GAMEPAD_BUTTON_LEFT_FACE_UP,
      GAMEPAD_BUTTON_LEFT_FACE_RIGHT,
      GAMEPAD_BUTTON_LEFT_FACE_DOWN,
      GAMEPAD_BUTTON_LEFT_FACE_LEFT,
      // This normally corresponds with PlayStation and Xbox controllers
      // XBOX: [Y,X,A,B]
      // PS3: [Triangle,Square,Cross,Circle]
      // No support for 6 button controllers though..
      GAMEPAD_BUTTON_RIGHT_FACE_UP,
      GAMEPAD_BUTTON_RIGHT_FACE_RIGHT,
      GAMEPAD_BUTTON_RIGHT_FACE_DOWN,
      GAMEPAD_BUTTON_RIGHT_FACE_LEFT,
      // Triggers
      GAMEPAD_BUTTON_LEFT_TRIGGER_1,
      GAMEPAD_BUTTON_LEFT_TRIGGER_2,
      GAMEPAD_BUTTON_RIGHT_TRIGGER_1,
      GAMEPAD_BUTTON_RIGHT_TRIGGER_2,
      // These are buttons in the center of the gamepad
      GAMEPAD_BUTTON_MIDDLE_LEFT, //PS3 Select
      GAMEPAD_BUTTON_MIDDLE, //PS Button/XBOX Button
      GAMEPAD_BUTTON_MIDDLE_RIGHT, //PS3 Start
      // These are the joystick press in buttons
      GAMEPAD_BUTTON_LEFT_THUMB,
      GAMEPAD_BUTTON_RIGHT_THUMB
      } GamepadButton;
      typedef enum {
      // This is here just for error checking
      GAMEPAD_AXIS_UNKNOWN = 0,
      // Left stick
      GAMEPAD_AXIS_LEFT_X,
      GAMEPAD_AXIS_LEFT_Y,
      // Right stick
      GAMEPAD_AXIS_RIGHT_X,
      GAMEPAD_AXIS_RIGHT_Y,
      // Pressure levels for the back triggers
      GAMEPAD_AXIS_LEFT_TRIGGER, // [1..-1] (pressure-level)
      GAMEPAD_AXIS_RIGHT_TRIGGER // [1..-1] (pressure-level)
      } GamepadAxis;
      // Shader location point type
      typedef enum {
      LOC_VERTEX_POSITION = 0,
      LOC_VERTEX_TEXCOORD01,
      LOC_VERTEX_TEXCOORD02,
      LOC_VERTEX_NORMAL,
      LOC_VERTEX_TANGENT,
      LOC_VERTEX_COLOR,
      LOC_MATRIX_MVP,
      LOC_MATRIX_MODEL,
      LOC_MATRIX_VIEW,
      LOC_MATRIX_PROJECTION,
      LOC_VECTOR_VIEW,
      LOC_COLOR_DIFFUSE,
      LOC_COLOR_SPECULAR,
      LOC_COLOR_AMBIENT,
      LOC_MAP_ALBEDO, // LOC_MAP_DIFFUSE
      LOC_MAP_METALNESS, // LOC_MAP_SPECULAR
      LOC_MAP_NORMAL,
      LOC_MAP_ROUGHNESS,
      LOC_MAP_OCCLUSION,
      LOC_MAP_EMISSION,
      LOC_MAP_HEIGHT,
      LOC_MAP_CUBEMAP,
      LOC_MAP_IRRADIANCE,
      LOC_MAP_PREFILTER,
      LOC_MAP_BRDF
      } ShaderLocationIndex;
      #define LOC_MAP_DIFFUSE LOC_MAP_ALBEDO
      #define LOC_MAP_SPECULAR LOC_MAP_METALNESS
      // Shader uniform data types
      typedef enum {
      UNIFORM_FLOAT = 0,
      UNIFORM_VEC2,
      UNIFORM_VEC3,
      UNIFORM_VEC4,
      UNIFORM_INT,
      UNIFORM_IVEC2,
      UNIFORM_IVEC3,
      UNIFORM_IVEC4,
      UNIFORM_SAMPLER2D
      } ShaderUniformDataType;
      // Material map type
      typedef enum {
      MAP_ALBEDO = 0, // MAP_DIFFUSE
      MAP_METALNESS = 1, // MAP_SPECULAR
      MAP_NORMAL = 2,
      MAP_ROUGHNESS = 3,
      MAP_OCCLUSION,
      MAP_EMISSION,
      MAP_HEIGHT,
      MAP_CUBEMAP, // NOTE: Uses GL_TEXTURE_CUBE_MAP
      MAP_IRRADIANCE, // NOTE: Uses GL_TEXTURE_CUBE_MAP
      MAP_PREFILTER, // NOTE: Uses GL_TEXTURE_CUBE_MAP
      MAP_BRDF
      } MaterialMapType;
      #define MAP_DIFFUSE MAP_ALBEDO
      #define MAP_SPECULAR MAP_METALNESS
      // Pixel formats
      // NOTE: Support depends on OpenGL version and platform
      typedef enum {
      UNCOMPRESSED_GRAYSCALE = 1, // 8 bit per pixel (no alpha)
      UNCOMPRESSED_GRAY_ALPHA, // 8*2 bpp (2 channels)
      UNCOMPRESSED_R5G6B5, // 16 bpp
      UNCOMPRESSED_R8G8B8, // 24 bpp
      UNCOMPRESSED_R5G5B5A1, // 16 bpp (1 bit alpha)
      UNCOMPRESSED_R4G4B4A4, // 16 bpp (4 bit alpha)
      UNCOMPRESSED_R8G8B8A8, // 32 bpp
      UNCOMPRESSED_R32, // 32 bpp (1 channel - float)
      UNCOMPRESSED_R32G32B32, // 32*3 bpp (3 channels - float)
      UNCOMPRESSED_R32G32B32A32, // 32*4 bpp (4 channels - float)
      COMPRESSED_DXT1_RGB, // 4 bpp (no alpha)
      COMPRESSED_DXT1_RGBA, // 4 bpp (1 bit alpha)
      COMPRESSED_DXT3_RGBA, // 8 bpp
      COMPRESSED_DXT5_RGBA, // 8 bpp
      COMPRESSED_ETC1_RGB, // 4 bpp
      COMPRESSED_ETC2_RGB, // 4 bpp
      COMPRESSED_ETC2_EAC_RGBA, // 8 bpp
      COMPRESSED_PVRT_RGB, // 4 bpp
      COMPRESSED_PVRT_RGBA, // 4 bpp
      COMPRESSED_ASTC_4x4_RGBA, // 8 bpp
      COMPRESSED_ASTC_8x8_RGBA // 2 bpp
      } PixelFormat;
      // Texture parameters: filter mode
      // NOTE 1: Filtering considers mipmaps if available in the texture
      // NOTE 2: Filter is accordingly set for minification and magnification
      typedef enum {
      FILTER_POINT = 0, // No filter, just pixel aproximation
      FILTER_BILINEAR, // Linear filtering
      FILTER_TRILINEAR, // Trilinear filtering (linear with mipmaps)
      FILTER_ANISOTROPIC_4X, // Anisotropic filtering 4x
      FILTER_ANISOTROPIC_8X, // Anisotropic filtering 8x
      FILTER_ANISOTROPIC_16X, // Anisotropic filtering 16x
      } TextureFilterMode;
      // Cubemap layout type
      typedef enum {
      CUBEMAP_AUTO_DETECT = 0, // Automatically detect layout type
      CUBEMAP_LINE_VERTICAL, // Layout is defined by a vertical line with faces
      CUBEMAP_LINE_HORIZONTAL, // Layout is defined by an horizontal line with faces
      CUBEMAP_CROSS_THREE_BY_FOUR, // Layout is defined by a 3x4 cross with cubemap faces
      CUBEMAP_CROSS_FOUR_BY_THREE, // Layout is defined by a 4x3 cross with cubemap faces
      CUBEMAP_PANORAMA // Layout is defined by a panorama image (equirectangular map)
      } CubemapLayoutType;
      // Texture parameters: wrap mode
      typedef enum {
      WRAP_REPEAT = 0, // Repeats texture in tiled mode
      WRAP_CLAMP, // Clamps texture to edge pixel in tiled mode
      WRAP_MIRROR_REPEAT, // Mirrors and repeats the texture in tiled mode
      WRAP_MIRROR_CLAMP // Mirrors and clamps to border the texture in tiled mode
      } TextureWrapMode;
      // Font type, defines generation method
      typedef enum {
      FONT_DEFAULT = 0, // Default font generation, anti-aliased
      FONT_BITMAP, // Bitmap font generation, no anti-aliasing
      FONT_SDF // SDF font generation, requires external shader
      } FontType;
      // Color blending modes (pre-defined)
      typedef enum {
      BLEND_ALPHA = 0, // Blend textures considering alpha (default)
      BLEND_ADDITIVE, // Blend textures adding colors
      BLEND_MULTIPLIED // Blend textures multiplying colors
      } BlendMode;
      // Gestures type
      // NOTE: It could be used as flags to enable only some gestures
      typedef enum {
      GESTURE_NONE = 0,
      GESTURE_TAP = 1,
      GESTURE_DOUBLETAP = 2,
      GESTURE_HOLD = 4,
      GESTURE_DRAG = 8,
      GESTURE_SWIPE_RIGHT = 16,
      GESTURE_SWIPE_LEFT = 32,
      GESTURE_SWIPE_UP = 64,
      GESTURE_SWIPE_DOWN = 128,
      GESTURE_PINCH_IN = 256,
      GESTURE_PINCH_OUT = 512
      } GestureType;
      // Camera system modes
      typedef enum {
      CAMERA_CUSTOM = 0,
      CAMERA_FREE,
      CAMERA_ORBITAL,
      CAMERA_FIRST_PERSON,
      CAMERA_THIRD_PERSON
      } CameraMode;
      // Camera projection modes
      typedef enum {
      CAMERA_PERSPECTIVE = 0,
      CAMERA_ORTHOGRAPHIC
      } CameraType;
      // Type of n-patch
      typedef enum {
      NPT_9PATCH = 0, // Npatch defined by 3x3 tiles
      NPT_3PATCH_VERTICAL, // Npatch defined by 1x3 tiles
      NPT_3PATCH_HORIZONTAL // Npatch defined by 3x1 tiles
      } NPatchType;
      // Callbacks to be implemented by users
      typedef void (*TraceLogCallback)(int logType, const char *text, va_list args);
      #if defined(__cplusplus)
      extern "C" { // Prevents name mangling of functions
      #endif
      //------------------------------------------------------------------------------------
      // Global Variables Definition
      //------------------------------------------------------------------------------------
      // It's lonely here...
      //------------------------------------------------------------------------------------
      // Window and Graphics Device Functions (Module: core)
      //------------------------------------------------------------------------------------
      // Window-related functions
      RLAPI void InitWindow(int width, int height, const char *title); // Initialize window and OpenGL context
      RLAPI bool WindowShouldClose(void); // Check if KEY_ESCAPE pressed or Close icon pressed
      RLAPI void CloseWindow(void); // Close window and unload OpenGL context
      RLAPI bool IsWindowReady(void); // Check if window has been initialized successfully
      RLAPI bool IsWindowMinimized(void); // Check if window has been minimized (or lost focus)
      RLAPI bool IsWindowResized(void); // Check if window has been resized
      RLAPI bool IsWindowHidden(void); // Check if window is currently hidden
      RLAPI bool IsWindowFullscreen(void); // Check if window is currently fullscreen
      RLAPI void ToggleFullscreen(void); // Toggle fullscreen mode (only PLATFORM_DESKTOP)
      RLAPI void UnhideWindow(void); // Show the window
      RLAPI void HideWindow(void); // Hide the window
      RLAPI void SetWindowIcon(Image image); // Set icon for window (only PLATFORM_DESKTOP)
      RLAPI void SetWindowTitle(const char *title); // Set title for window (only PLATFORM_DESKTOP)
      RLAPI void SetWindowPosition(int x, int y); // Set window position on screen (only PLATFORM_DESKTOP)
      RLAPI void SetWindowMonitor(int monitor); // Set monitor for the current window (fullscreen mode)
      RLAPI void SetWindowMinSize(int width, int height); // Set window minimum dimensions (for FLAG_WINDOW_RESIZABLE)
      RLAPI void SetWindowSize(int width, int height); // Set window dimensions
      RLAPI void *GetWindowHandle(void); // Get native window handle
      RLAPI int GetScreenWidth(void); // Get current screen width
      RLAPI int GetScreenHeight(void); // Get current screen height
      RLAPI int GetMonitorCount(void); // Get number of connected monitors
      RLAPI int GetMonitorWidth(int monitor); // Get primary monitor width
      RLAPI int GetMonitorHeight(int monitor); // Get primary monitor height
      RLAPI int GetMonitorPhysicalWidth(int monitor); // Get primary monitor physical width in millimetres
      RLAPI int GetMonitorPhysicalHeight(int monitor); // Get primary monitor physical height in millimetres
      RLAPI Vector2 GetWindowPosition(void); // Get window position XY on monitor
      RLAPI const char *GetMonitorName(int monitor); // Get the human-readable, UTF-8 encoded name of the primary monitor
      RLAPI const char *GetClipboardText(void); // Get clipboard text content
      RLAPI void SetClipboardText(const char *text); // Set clipboard text content
      // Cursor-related functions
      RLAPI void ShowCursor(void); // Shows cursor
      RLAPI void HideCursor(void); // Hides cursor
      RLAPI bool IsCursorHidden(void); // Check if cursor is not visible
      RLAPI void EnableCursor(void); // Enables cursor (unlock cursor)
      RLAPI void DisableCursor(void); // Disables cursor (lock cursor)
      // Drawing-related functions
      RLAPI void ClearBackground(Color color); // Set background color (framebuffer clear color)
      RLAPI void BeginDrawing(void); // Setup canvas (framebuffer) to start drawing
      RLAPI void EndDrawing(void); // End canvas drawing and swap buffers (double buffering)
      RLAPI void BeginMode2D(Camera2D camera); // Initialize 2D mode with custom camera (2D)
      RLAPI void EndMode2D(void); // Ends 2D mode with custom camera
      RLAPI void BeginMode3D(Camera3D camera); // Initializes 3D mode with custom camera (3D)
      RLAPI void EndMode3D(void); // Ends 3D mode and returns to default 2D orthographic mode
      RLAPI void BeginTextureMode(RenderTexture2D target); // Initializes render texture for drawing
      RLAPI void EndTextureMode(void); // Ends drawing to render texture
      RLAPI void BeginScissorMode(int x, int y, int width, int height); // Begin scissor mode (define screen area for following drawing)
      RLAPI void EndScissorMode(void); // End scissor mode
      // Screen-space-related functions
      RLAPI Ray GetMouseRay(Vector2 mousePosition, Camera camera); // Returns a ray trace from mouse position
      RLAPI Matrix GetCameraMatrix(Camera camera); // Returns camera transform matrix (view matrix)
      RLAPI Matrix GetCameraMatrix2D(Camera2D camera); // Returns camera 2d transform matrix
      RLAPI Vector2 GetWorldToScreen(Vector3 position, Camera camera); // Returns the screen space position for a 3d world space position
      RLAPI Vector2 GetWorldToScreenEx(Vector3 position, Camera camera, int width, int height); // Returns size position for a 3d world space position
      RLAPI Vector2 GetWorldToScreen2D(Vector2 position, Camera2D camera); // Returns the screen space position for a 2d camera world space position
      RLAPI Vector2 GetScreenToWorld2D(Vector2 position, Camera2D camera); // Returns the world space position for a 2d camera screen space position
      // Timing-related functions
      RLAPI void SetTargetFPS(int fps); // Set target FPS (maximum)
      RLAPI int GetFPS(void); // Returns current FPS
      RLAPI float GetFrameTime(void); // Returns time in seconds for last frame drawn
      RLAPI double GetTime(void); // Returns elapsed time in seconds since InitWindow()
      // Color-related functions
      RLAPI int ColorToInt(Color color); // Returns hexadecimal value for a Color
      RLAPI Vector4 ColorNormalize(Color color); // Returns color normalized as float [0..1]
      RLAPI Color ColorFromNormalized(Vector4 normalized); // Returns color from normalized values [0..1]
      RLAPI Vector3 ColorToHSV(Color color); // Returns HSV values for a Color
      RLAPI Color ColorFromHSV(Vector3 hsv); // Returns a Color from HSV values
      RLAPI Color GetColor(int hexValue); // Returns a Color struct from hexadecimal value
      RLAPI Color Fade(Color color, float alpha); // Color fade-in or fade-out, alpha goes from 0.0f to 1.0f
      // Misc. functions
      RLAPI void SetConfigFlags(unsigned int flags); // Setup window configuration flags (view FLAGS)
      RLAPI void SetTraceLogLevel(int logType); // Set the current threshold (minimum) log level
      RLAPI void SetTraceLogExit(int logType); // Set the exit threshold (minimum) log level
      RLAPI void SetTraceLogCallback(TraceLogCallback callback); // Set a trace log callback to enable custom logging
      RLAPI void TraceLog(int logType, const char *text, ...); // Show trace log messages (LOG_DEBUG, LOG_INFO, LOG_WARNING, LOG_ERROR)
      RLAPI void TakeScreenshot(const char *fileName); // Takes a screenshot of current screen (saved a .png)
      RLAPI int GetRandomValue(int min, int max); // Returns a random value between min and max (both included)
      // Files management functions
      RLAPI unsigned char *LoadFileData(const char *fileName, unsigned int *bytesRead); // Load file data as byte array (read)
      RLAPI void SaveFileData(const char *fileName, void *data, unsigned int bytesToWrite); // Save data to file from byte array (write)
      RLAPI char *LoadFileText(const char *fileName); // Load text data from file (read), returns a '\0' terminated string
      RLAPI void SaveFileText(const char *fileName, char *text); // Save text data to file (write), string must be '\0' terminated
      RLAPI bool FileExists(const char *fileName); // Check if file exists
      RLAPI bool IsFileExtension(const char *fileName, const char *ext);// Check file extension
      RLAPI bool DirectoryExists(const char *dirPath); // Check if a directory path exists
      RLAPI const char *GetExtension(const char *fileName); // Get pointer to extension for a filename string
      RLAPI const char *GetFileName(const char *filePath); // Get pointer to filename for a path string
      RLAPI const char *GetFileNameWithoutExt(const char *filePath); // Get filename string without extension (uses static string)
      RLAPI const char *GetDirectoryPath(const char *filePath); // Get full path for a given fileName with path (uses static string)
      RLAPI const char *GetPrevDirectoryPath(const char *dirPath); // Get previous directory path for a given path (uses static string)
      RLAPI const char *GetWorkingDirectory(void); // Get current working directory (uses static string)
      RLAPI char **GetDirectoryFiles(const char *dirPath, int *count); // Get filenames in a directory path (memory should be freed)
      RLAPI void ClearDirectoryFiles(void); // Clear directory files paths buffers (free memory)
      RLAPI bool ChangeDirectory(const char *dir); // Change working directory, returns true if success
      RLAPI bool IsFileDropped(void); // Check if a file has been dropped into window
      RLAPI char **GetDroppedFiles(int *count); // Get dropped files names (memory should be freed)
      RLAPI void ClearDroppedFiles(void); // Clear dropped files paths buffer (free memory)
      RLAPI long GetFileModTime(const char *fileName); // Get file modification time (last write time)
      RLAPI unsigned char *CompressData(unsigned char *data, int dataLength, int *compDataLength); // Compress data (DEFLATE algorythm)
      RLAPI unsigned char *DecompressData(unsigned char *compData, int compDataLength, int *dataLength); // Decompress data (DEFLATE algorythm)
      // Persistent storage management
      RLAPI void SaveStorageValue(unsigned int position, int value); // Save integer value to storage file (to defined position)
      RLAPI int LoadStorageValue(unsigned int position); // Load integer value from storage file (from defined position)
      RLAPI void OpenURL(const char *url); // Open URL with default system browser (if available)
      //------------------------------------------------------------------------------------
      // Input Handling Functions (Module: core)
      //------------------------------------------------------------------------------------
      // Input-related functions: keyboard
      RLAPI bool IsKeyPressed(int key); // Detect if a key has been pressed once
      RLAPI bool IsKeyDown(int key); // Detect if a key is being pressed
      RLAPI bool IsKeyReleased(int key); // Detect if a key has been released once
      RLAPI bool IsKeyUp(int key); // Detect if a key is NOT being pressed
      RLAPI void SetExitKey(int key); // Set a custom key to exit program (default is ESC)
      RLAPI int GetKeyPressed(void); // Get key pressed, call it multiple times for chars queued
      // Input-related functions: gamepads
      RLAPI bool IsGamepadAvailable(int gamepad); // Detect if a gamepad is available
      RLAPI bool IsGamepadName(int gamepad, const char *name); // Check gamepad name (if available)
      RLAPI const char *GetGamepadName(int gamepad); // Return gamepad internal name id
      RLAPI bool IsGamepadButtonPressed(int gamepad, int button); // Detect if a gamepad button has been pressed once
      RLAPI bool IsGamepadButtonDown(int gamepad, int button); // Detect if a gamepad button is being pressed
      RLAPI bool IsGamepadButtonReleased(int gamepad, int button); // Detect if a gamepad button has been released once
      RLAPI bool IsGamepadButtonUp(int gamepad, int button); // Detect if a gamepad button is NOT being pressed
      RLAPI int GetGamepadButtonPressed(void); // Get the last gamepad button pressed
      RLAPI int GetGamepadAxisCount(int gamepad); // Return gamepad axis count for a gamepad
      RLAPI float GetGamepadAxisMovement(int gamepad, int axis); // Return axis movement value for a gamepad axis
      // Input-related functions: mouse
      RLAPI bool IsMouseButtonPressed(int button); // Detect if a mouse button has been pressed once
      RLAPI bool IsMouseButtonDown(int button); // Detect if a mouse button is being pressed
      RLAPI bool IsMouseButtonReleased(int button); // Detect if a mouse button has been released once
      RLAPI bool IsMouseButtonUp(int button); // Detect if a mouse button is NOT being pressed
      RLAPI int GetMouseX(void); // Returns mouse position X
      RLAPI int GetMouseY(void); // Returns mouse position Y
      RLAPI Vector2 GetMousePosition(void); // Returns mouse position XY
      RLAPI void SetMousePosition(int x, int y); // Set mouse position XY
      RLAPI void SetMouseOffset(int offsetX, int offsetY); // Set mouse offset
      RLAPI void SetMouseScale(float scaleX, float scaleY); // Set mouse scaling
      RLAPI int GetMouseWheelMove(void); // Returns mouse wheel movement Y
      // Input-related functions: touch
      RLAPI int GetTouchX(void); // Returns touch position X for touch point 0 (relative to screen size)
      RLAPI int GetTouchY(void); // Returns touch position Y for touch point 0 (relative to screen size)
      RLAPI Vector2 GetTouchPosition(int index); // Returns touch position XY for a touch point index (relative to screen size)
      //------------------------------------------------------------------------------------
      // Gestures and Touch Handling Functions (Module: gestures)
      //------------------------------------------------------------------------------------
      RLAPI void SetGesturesEnabled(unsigned int gestureFlags); // Enable a set of gestures using flags
      RLAPI bool IsGestureDetected(int gesture); // Check if a gesture have been detected
      RLAPI int GetGestureDetected(void); // Get latest detected gesture
      RLAPI int GetTouchPointsCount(void); // Get touch points count
      RLAPI float GetGestureHoldDuration(void); // Get gesture hold time in milliseconds
      RLAPI Vector2 GetGestureDragVector(void); // Get gesture drag vector
      RLAPI float GetGestureDragAngle(void); // Get gesture drag angle
      RLAPI Vector2 GetGesturePinchVector(void); // Get gesture pinch delta
      RLAPI float GetGesturePinchAngle(void); // Get gesture pinch angle
      //------------------------------------------------------------------------------------
      // Camera System Functions (Module: camera)
      //------------------------------------------------------------------------------------
      RLAPI void SetCameraMode(Camera camera, int mode); // Set camera mode (multiple camera modes available)
      RLAPI void UpdateCamera(Camera *camera); // Update camera position for selected mode
      RLAPI void SetCameraPanControl(int panKey); // Set camera pan key to combine with mouse movement (free camera)
      RLAPI void SetCameraAltControl(int altKey); // Set camera alt key to combine with mouse movement (free camera)
      RLAPI void SetCameraSmoothZoomControl(int szKey); // Set camera smooth zoom key to combine with mouse (free camera)
      RLAPI void SetCameraMoveControls(int frontKey, int backKey, int rightKey, int leftKey, int upKey, int downKey); // Set camera move controls (1st person and 3rd person cameras)
      //------------------------------------------------------------------------------------
      // Basic Shapes Drawing Functions (Module: shapes)
      //------------------------------------------------------------------------------------
      // Basic shapes drawing functions
      RLAPI void DrawPixel(int posX, int posY, Color color); // Draw a pixel
      RLAPI void DrawPixelV(Vector2 position, Color color); // Draw a pixel (Vector version)
      RLAPI void DrawLine(int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw a line
      RLAPI void DrawLineV(Vector2 startPos, Vector2 endPos, Color color); // Draw a line (Vector version)
      RLAPI void DrawLineEx(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line defining thickness
      RLAPI void DrawLineBezier(Vector2 startPos, Vector2 endPos, float thick, Color color); // Draw a line using cubic-bezier curves in-out
      RLAPI void DrawLineStrip(Vector2 *points, int numPoints, Color color); // Draw lines sequence
      RLAPI void DrawCircle(int centerX, int centerY, float radius, Color color); // Draw a color-filled circle
      RLAPI void DrawCircleSector(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw a piece of a circle
      RLAPI void DrawCircleSectorLines(Vector2 center, float radius, int startAngle, int endAngle, int segments, Color color); // Draw circle sector outline
      RLAPI void DrawCircleGradient(int centerX, int centerY, float radius, Color color1, Color color2); // Draw a gradient-filled circle
      RLAPI void DrawCircleV(Vector2 center, float radius, Color color); // Draw a color-filled circle (Vector version)
      RLAPI void DrawCircleLines(int centerX, int centerY, float radius, Color color); // Draw circle outline
      RLAPI void DrawEllipse(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse
      RLAPI void DrawEllipseLines(int centerX, int centerY, float radiusH, float radiusV, Color color); // Draw ellipse outline
      RLAPI void DrawRing(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring
      RLAPI void DrawRingLines(Vector2 center, float innerRadius, float outerRadius, int startAngle, int endAngle, int segments, Color color); // Draw ring outline
      RLAPI void DrawRectangle(int posX, int posY, int width, int height, Color color); // Draw a color-filled rectangle
      RLAPI void DrawRectangleV(Vector2 position, Vector2 size, Color color); // Draw a color-filled rectangle (Vector version)
      RLAPI void DrawRectangleRec(Rectangle rec, Color color); // Draw a color-filled rectangle
      RLAPI void DrawRectanglePro(Rectangle rec, Vector2 origin, float rotation, Color color); // Draw a color-filled rectangle with pro parameters
      RLAPI void DrawRectangleGradientV(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a vertical-gradient-filled rectangle
      RLAPI void DrawRectangleGradientH(int posX, int posY, int width, int height, Color color1, Color color2);// Draw a horizontal-gradient-filled rectangle
      RLAPI void DrawRectangleGradientEx(Rectangle rec, Color col1, Color col2, Color col3, Color col4); // Draw a gradient-filled rectangle with custom vertex colors
      RLAPI void DrawRectangleLines(int posX, int posY, int width, int height, Color color); // Draw rectangle outline
      RLAPI void DrawRectangleLinesEx(Rectangle rec, int lineThick, Color color); // Draw rectangle outline with extended parameters
      RLAPI void DrawRectangleRounded(Rectangle rec, float roundness, int segments, Color color); // Draw rectangle with rounded edges
      RLAPI void DrawRectangleRoundedLines(Rectangle rec, float roundness, int segments, int lineThick, Color color); // Draw rectangle with rounded edges outline
      RLAPI void DrawTriangle(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw a color-filled triangle (vertex in counter-clockwise order!)
      RLAPI void DrawTriangleLines(Vector2 v1, Vector2 v2, Vector2 v3, Color color); // Draw triangle outline (vertex in counter-clockwise order!)
      RLAPI void DrawTriangleFan(Vector2 *points, int numPoints, Color color); // Draw a triangle fan defined by points (first vertex is the center)
      RLAPI void DrawTriangleStrip(Vector2 *points, int pointsCount, Color color); // Draw a triangle strip defined by points
      RLAPI void DrawPoly(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a regular polygon (Vector version)
      RLAPI void DrawPolyLines(Vector2 center, int sides, float radius, float rotation, Color color); // Draw a polygon outline of n sides
      // Basic shapes collision detection functions
      RLAPI bool CheckCollisionRecs(Rectangle rec1, Rectangle rec2); // Check collision between two rectangles
      RLAPI bool CheckCollisionCircles(Vector2 center1, float radius1, Vector2 center2, float radius2); // Check collision between two circles
      RLAPI bool CheckCollisionCircleRec(Vector2 center, float radius, Rectangle rec); // Check collision between circle and rectangle
      RLAPI Rectangle GetCollisionRec(Rectangle rec1, Rectangle rec2); // Get collision rectangle for two rectangles collision
      RLAPI bool CheckCollisionPointRec(Vector2 point, Rectangle rec); // Check if point is inside rectangle
      RLAPI bool CheckCollisionPointCircle(Vector2 point, Vector2 center, float radius); // Check if point is inside circle
      RLAPI bool CheckCollisionPointTriangle(Vector2 point, Vector2 p1, Vector2 p2, Vector2 p3); // Check if point is inside a triangle
      //------------------------------------------------------------------------------------
      // Texture Loading and Drawing Functions (Module: textures)
      //------------------------------------------------------------------------------------
      // Image loading functions
      // NOTE: This functions do not require GPU access
      RLAPI Image LoadImage(const char *fileName); // Load image from file into CPU memory (RAM)
      RLAPI Image LoadImageEx(Color *pixels, int width, int height); // Load image from Color array data (RGBA - 32bit)
      RLAPI Image LoadImagePro(void *data, int width, int height, int format); // Load image from raw data with parameters
      RLAPI Image LoadImageRaw(const char *fileName, int width, int height, int format, int headerSize); // Load image from RAW file data
      RLAPI void UnloadImage(Image image); // Unload image from CPU memory (RAM)
      RLAPI void ExportImage(Image image, const char *fileName); // Export image data to file
      RLAPI void ExportImageAsCode(Image image, const char *fileName); // Export image as code file defining an array of bytes
      RLAPI Color *GetImageData(Image image); // Get pixel data from image as a Color struct array
      RLAPI Vector4 *GetImageDataNormalized(Image image); // Get pixel data from image as Vector4 array (float normalized)
      // Image generation functions
      RLAPI Image GenImageColor(int width, int height, Color color); // Generate image: plain color
      RLAPI Image GenImageGradientV(int width, int height, Color top, Color bottom); // Generate image: vertical gradient
      RLAPI Image GenImageGradientH(int width, int height, Color left, Color right); // Generate image: horizontal gradient
      RLAPI Image GenImageGradientRadial(int width, int height, float density, Color inner, Color outer); // Generate image: radial gradient
      RLAPI Image GenImageChecked(int width, int height, int checksX, int checksY, Color col1, Color col2); // Generate image: checked
      RLAPI Image GenImageWhiteNoise(int width, int height, float factor); // Generate image: white noise
      RLAPI Image GenImagePerlinNoise(int width, int height, int offsetX, int offsetY, float scale); // Generate image: perlin noise
      RLAPI Image GenImageCellular(int width, int height, int tileSize); // Generate image: cellular algorithm. Bigger tileSize means bigger cells
      // Image manipulation functions
      RLAPI Image ImageCopy(Image image); // Create an image duplicate (useful for transformations)
      RLAPI Image ImageFromImage(Image image, Rectangle rec); // Create an image from another image piece
      RLAPI Image ImageText(const char *text, int fontSize, Color color); // Create an image from text (default font)
      RLAPI Image ImageTextEx(Font font, const char *text, float fontSize, float spacing, Color tint); // Create an image from text (custom sprite font)
      RLAPI void ImageToPOT(Image *image, Color fillColor); // Convert image to POT (power-of-two)
      RLAPI void ImageFormat(Image *image, int newFormat); // Convert image data to desired format
      RLAPI void ImageAlphaMask(Image *image, Image alphaMask); // Apply alpha mask to image
      RLAPI void ImageAlphaClear(Image *image, Color color, float threshold); // Clear alpha channel to desired color
      RLAPI void ImageAlphaCrop(Image *image, float threshold); // Crop image depending on alpha value
      RLAPI void ImageAlphaPremultiply(Image *image); // Premultiply alpha channel
      RLAPI void ImageCrop(Image *image, Rectangle crop); // Crop an image to a defined rectangle
      RLAPI void ImageResize(Image *image, int newWidth, int newHeight); // Resize image (Bicubic scaling algorithm)
      RLAPI void ImageResizeNN(Image *image, int newWidth,int newHeight); // Resize image (Nearest-Neighbor scaling algorithm)
      RLAPI void ImageResizeCanvas(Image *image, int newWidth, int newHeight, int offsetX, int offsetY, Color color); // Resize canvas and fill with color
      RLAPI void ImageMipmaps(Image *image); // Generate all mipmap levels for a provided image
      RLAPI void ImageDither(Image *image, int rBpp, int gBpp, int bBpp, int aBpp); // Dither image data to 16bpp or lower (Floyd-Steinberg dithering)
      RLAPI void ImageFlipVertical(Image *image); // Flip image vertically
      RLAPI void ImageFlipHorizontal(Image *image); // Flip image horizontally
      RLAPI void ImageRotateCW(Image *image); // Rotate image clockwise 90deg
      RLAPI void ImageRotateCCW(Image *image); // Rotate image counter-clockwise 90deg
      RLAPI void ImageColorTint(Image *image, Color color); // Modify image color: tint
      RLAPI void ImageColorInvert(Image *image); // Modify image color: invert
      RLAPI void ImageColorGrayscale(Image *image); // Modify image color: grayscale
      RLAPI void ImageColorContrast(Image *image, float contrast); // Modify image color: contrast (-100 to 100)
      RLAPI void ImageColorBrightness(Image *image, int brightness); // Modify image color: brightness (-255 to 255)
      RLAPI void ImageColorReplace(Image *image, Color color, Color replace); // Modify image color: replace color
      RLAPI Color *ImageExtractPalette(Image image, int maxPaletteSize, int *extractCount); // Extract color palette from image to maximum size (memory should be freed)
      RLAPI Rectangle GetImageAlphaBorder(Image image, float threshold); // Get image alpha border rectangle
      // Image drawing functions
      // NOTE: Image software-rendering functions (CPU)
      RLAPI void ImageClearBackground(Image *dst, Color color); // Clear image background with given color
      RLAPI void ImageDrawPixel(Image *dst, int posX, int posY, Color color); // Draw pixel within an image
      RLAPI void ImageDrawPixelV(Image *dst, Vector2 position, Color color); // Draw pixel within an image (Vector version)
      RLAPI void ImageDrawLine(Image *dst, int startPosX, int startPosY, int endPosX, int endPosY, Color color); // Draw line within an image
      RLAPI void ImageDrawLineV(Image *dst, Vector2 start, Vector2 end, Color color); // Draw line within an image (Vector version)
      RLAPI void ImageDrawCircle(Image *dst, int centerX, int centerY, int radius, Color color); // Draw circle within an image
      RLAPI void ImageDrawCircleV(Image *dst, Vector2 center, int radius, Color color); // Draw circle within an image (Vector version)
      RLAPI void ImageDrawRectangle(Image *dst, int posX, int posY, int width, int height, Color color); // Draw rectangle within an image
      RLAPI void ImageDrawRectangleV(Image *dst, Vector2 position, Vector2 size, Color color); // Draw rectangle within an image (Vector version)
      RLAPI void ImageDrawRectangleRec(Image *dst, Rectangle rec, Color color); // Draw rectangle within an image
      RLAPI void ImageDrawRectangleLines(Image *dst, Rectangle rec, int thick, Color color); // Draw rectangle lines within an image
      RLAPI void ImageDraw(Image *dst, Image src, Rectangle srcRec, Rectangle dstRec, Color tint); // Draw a source image within a destination image (tint applied to source)
      RLAPI void ImageDrawText(Image *dst, Vector2 position, const char *text, int fontSize, Color color); // Draw text (default font) within an image (destination)
      RLAPI void ImageDrawTextEx(Image *dst, Vector2 position, Font font, const char *text, float fontSize, float spacing, Color color); // Draw text (custom sprite font) within an image (destination)
      // Texture loading functions
      // NOTE: These functions require GPU access
      RLAPI Texture2D LoadTexture(const char *fileName); // Load texture from file into GPU memory (VRAM)
      RLAPI Texture2D LoadTextureFromImage(Image image); // Load texture from image data
      RLAPI TextureCubemap LoadTextureCubemap(Image image, int layoutType); // Load cubemap from image, multiple image cubemap layouts supported
      RLAPI RenderTexture2D LoadRenderTexture(int width, int height); // Load texture for rendering (framebuffer)
      RLAPI void UnloadTexture(Texture2D texture); // Unload texture from GPU memory (VRAM)
      RLAPI void UnloadRenderTexture(RenderTexture2D target); // Unload render texture from GPU memory (VRAM)
      RLAPI void UpdateTexture(Texture2D texture, const void *pixels); // Update GPU texture with new data
      RLAPI Image GetTextureData(Texture2D texture); // Get pixel data from GPU texture and return an Image
      RLAPI Image GetScreenData(void); // Get pixel data from screen buffer and return an Image (screenshot)
      // Texture configuration functions
      RLAPI void GenTextureMipmaps(Texture2D *texture); // Generate GPU mipmaps for a texture
      RLAPI void SetTextureFilter(Texture2D texture, int filterMode); // Set texture scaling filter mode
      RLAPI void SetTextureWrap(Texture2D texture, int wrapMode); // Set texture wrapping mode
      // Texture drawing functions
      RLAPI void DrawTexture(Texture2D texture, int posX, int posY, Color tint); // Draw a Texture2D
      RLAPI void DrawTextureV(Texture2D texture, Vector2 position, Color tint); // Draw a Texture2D with position defined as Vector2
      RLAPI void DrawTextureEx(Texture2D texture, Vector2 position, float rotation, float scale, Color tint); // Draw a Texture2D with extended parameters
      RLAPI void DrawTextureRec(Texture2D texture, Rectangle sourceRec, Vector2 position, Color tint); // Draw a part of a texture defined by a rectangle
      RLAPI void DrawTextureQuad(Texture2D texture, Vector2 tiling, Vector2 offset, Rectangle quad, Color tint); // Draw texture quad with tiling and offset parameters
      RLAPI void DrawTexturePro(Texture2D texture, Rectangle sourceRec, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draw a part of a texture defined by a rectangle with 'pro' parameters
      RLAPI void DrawTextureNPatch(Texture2D texture, NPatchInfo nPatchInfo, Rectangle destRec, Vector2 origin, float rotation, Color tint); // Draws a texture (or part of it) that stretches or shrinks nicely
      // Image/Texture misc functions
      RLAPI int GetPixelDataSize(int width, int height, int format); // Get pixel data size in bytes (image or texture)
      //------------------------------------------------------------------------------------
      // Font Loading and Text Drawing Functions (Module: text)
      //------------------------------------------------------------------------------------
      // Font loading/unloading functions
      RLAPI Font GetFontDefault(void); // Get the default Font
      RLAPI Font LoadFont(const char *fileName); // Load font from file into GPU memory (VRAM)
      RLAPI Font LoadFontEx(const char *fileName, int fontSize, int *fontChars, int charsCount); // Load font from file with extended parameters
      RLAPI Font LoadFontFromImage(Image image, Color key, int firstChar); // Load font from Image (XNA style)
      RLAPI CharInfo *LoadFontData(const char *fileName, int fontSize, int *fontChars, int charsCount, int type); // Load font data for further use
      RLAPI Image GenImageFontAtlas(const CharInfo *chars, Rectangle **recs, int charsCount, int fontSize, int padding, int packMethod); // Generate image font atlas using chars info
      RLAPI void UnloadFont(Font font); // Unload Font from GPU memory (VRAM)
      // Text drawing functions
      RLAPI void DrawFPS(int posX, int posY); // Shows current FPS
      RLAPI void DrawText(const char *text, int posX, int posY, int fontSize, Color color); // Draw text (using default font)
      RLAPI void DrawTextEx(Font font, const char *text, Vector2 position, float fontSize, float spacing, Color tint); // Draw text using font and additional parameters
      RLAPI void DrawTextRec(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint); // Draw text using font inside rectangle limits
      RLAPI void DrawTextRecEx(Font font, const char *text, Rectangle rec, float fontSize, float spacing, bool wordWrap, Color tint,
      int selectStart, int selectLength, Color selectTint, Color selectBackTint); // Draw text using font inside rectangle limits with support for text selection
      RLAPI void DrawTextCodepoint(Font font, int codepoint, Vector2 position, float scale, Color tint); // Draw one character (codepoint)
      // Text misc. functions
      RLAPI int MeasureText(const char *text, int fontSize); // Measure string width for default font
      RLAPI Vector2 MeasureTextEx(Font font, const char *text, float fontSize, float spacing); // Measure string size for Font
      RLAPI int GetGlyphIndex(Font font, int codepoint); // Get index position for a unicode character on font
      // Text strings management functions (no utf8 strings, only byte chars)
      // NOTE: Some strings allocate memory internally for returned strings, just be careful!
      RLAPI int TextCopy(char *dst, const char *src); // Copy one string to another, returns bytes copied
      RLAPI bool TextIsEqual(const char *text1, const char *text2); // Check if two text string are equal
      RLAPI unsigned int TextLength(const char *text); // Get text length, checks for '\0' ending
      RLAPI const char *TextFormat(const char *text, ...); // Text formatting with variables (sprintf style)
      RLAPI const char *TextSubtext(const char *text, int position, int length); // Get a piece of a text string
      RLAPI char *TextReplace(char *text, const char *replace, const char *by); // Replace text string (memory must be freed!)
      RLAPI char *TextInsert(const char *text, const char *insert, int position); // Insert text in a position (memory must be freed!)
      RLAPI const char *TextJoin(const char **textList, int count, const char *delimiter); // Join text strings with delimiter
      RLAPI const char **TextSplit(const char *text, char delimiter, int *count); // Split text into multiple strings
      RLAPI void TextAppend(char *text, const char *append, int *position); // Append text at specific position and move cursor!
      RLAPI int TextFindIndex(const char *text, const char *find); // Find first text occurrence within a string
      RLAPI const char *TextToUpper(const char *text); // Get upper case version of provided string
      RLAPI const char *TextToLower(const char *text); // Get lower case version of provided string
      RLAPI const char *TextToPascal(const char *text); // Get Pascal case notation version of provided string
      RLAPI int TextToInteger(const char *text); // Get integer value from text (negative values not supported)
      RLAPI char *TextToUtf8(int *codepoints, int length); // Encode text codepoint into utf8 text (memory must be freed!)
      // UTF8 text strings management functions
      RLAPI int *GetCodepoints(const char *text, int *count); // Get all codepoints in a string, codepoints count returned by parameters
      RLAPI int GetCodepointsCount(const char *text); // Get total number of characters (codepoints) in a UTF8 encoded string
      RLAPI int GetNextCodepoint(const char *text, int *bytesProcessed); // Returns next codepoint in a UTF8 encoded string; 0x3f('?') is returned on failure
      RLAPI const char *CodepointToUtf8(int codepoint, int *byteLength); // Encode codepoint into utf8 text (char array length returned as parameter)
      //------------------------------------------------------------------------------------
      // Basic 3d Shapes Drawing Functions (Module: models)
      //------------------------------------------------------------------------------------
      // Basic geometric 3D shapes drawing functions
      RLAPI void DrawLine3D(Vector3 startPos, Vector3 endPos, Color color); // Draw a line in 3D world space
      RLAPI void DrawPoint3D(Vector3 position, Color color); // Draw a point in 3D space, actually a small line
      RLAPI void DrawCircle3D(Vector3 center, float radius, Vector3 rotationAxis, float rotationAngle, Color color); // Draw a circle in 3D world space
      RLAPI void DrawCube(Vector3 position, float width, float height, float length, Color color); // Draw cube
      RLAPI void DrawCubeV(Vector3 position, Vector3 size, Color color); // Draw cube (Vector version)
      RLAPI void DrawCubeWires(Vector3 position, float width, float height, float length, Color color); // Draw cube wires
      RLAPI void DrawCubeWiresV(Vector3 position, Vector3 size, Color color); // Draw cube wires (Vector version)
      RLAPI void DrawCubeTexture(Texture2D texture, Vector3 position, float width, float height, float length, Color color); // Draw cube textured
      RLAPI void DrawSphere(Vector3 centerPos, float radius, Color color); // Draw sphere
      RLAPI void DrawSphereEx(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere with extended parameters
      RLAPI void DrawSphereWires(Vector3 centerPos, float radius, int rings, int slices, Color color); // Draw sphere wires
      RLAPI void DrawCylinder(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone
      RLAPI void DrawCylinderWires(Vector3 position, float radiusTop, float radiusBottom, float height, int slices, Color color); // Draw a cylinder/cone wires
      RLAPI void DrawPlane(Vector3 centerPos, Vector2 size, Color color); // Draw a plane XZ
      RLAPI void DrawRay(Ray ray, Color color); // Draw a ray line
      RLAPI void DrawGrid(int slices, float spacing); // Draw a grid (centered at (0, 0, 0))
      RLAPI void DrawGizmo(Vector3 position); // Draw simple gizmo
      //DrawTorus(), DrawTeapot() could be useful?
      //------------------------------------------------------------------------------------
      // Model 3d Loading and Drawing Functions (Module: models)
      //------------------------------------------------------------------------------------
      // Model loading/unloading functions
      RLAPI Model LoadModel(const char *fileName); // Load model from files (meshes and materials)
      RLAPI Model LoadModelFromMesh(Mesh mesh); // Load model from generated mesh (default material)
      RLAPI void UnloadModel(Model model); // Unload model from memory (RAM and/or VRAM)
      // Mesh loading/unloading functions
      RLAPI Mesh *LoadMeshes(const char *fileName, int *meshCount); // Load meshes from model file
      RLAPI void ExportMesh(Mesh mesh, const char *fileName); // Export mesh data to file
      RLAPI void UnloadMesh(Mesh mesh); // Unload mesh from memory (RAM and/or VRAM)
      // Material loading/unloading functions
      RLAPI Material *LoadMaterials(const char *fileName, int *materialCount); // Load materials from model file
      RLAPI Material LoadMaterialDefault(void); // Load default material (Supports: DIFFUSE, SPECULAR, NORMAL maps)
      RLAPI void UnloadMaterial(Material material); // Unload material from GPU memory (VRAM)
      RLAPI void SetMaterialTexture(Material *material, int mapType, Texture2D texture); // Set texture for a material map type (MAP_DIFFUSE, MAP_SPECULAR...)
      RLAPI void SetModelMeshMaterial(Model *model, int meshId, int materialId); // Set material for a mesh
      // Model animations loading/unloading functions
      RLAPI ModelAnimation *LoadModelAnimations(const char *fileName, int *animsCount); // Load model animations from file
      RLAPI void UpdateModelAnimation(Model model, ModelAnimation anim, int frame); // Update model animation pose
      RLAPI void UnloadModelAnimation(ModelAnimation anim); // Unload animation data
      RLAPI bool IsModelAnimationValid(Model model, ModelAnimation anim); // Check model animation skeleton match
      // Mesh generation functions
      RLAPI Mesh GenMeshPoly(int sides, float radius); // Generate polygonal mesh
      RLAPI Mesh GenMeshPlane(float width, float length, int resX, int resZ); // Generate plane mesh (with subdivisions)
      RLAPI Mesh GenMeshCube(float width, float height, float length); // Generate cuboid mesh
      RLAPI Mesh GenMeshSphere(float radius, int rings, int slices); // Generate sphere mesh (standard sphere)
      RLAPI Mesh GenMeshHemiSphere(float radius, int rings, int slices); // Generate half-sphere mesh (no bottom cap)
      RLAPI Mesh GenMeshCylinder(float radius, float height, int slices); // Generate cylinder mesh
      RLAPI Mesh GenMeshTorus(float radius, float size, int radSeg, int sides); // Generate torus mesh
      RLAPI Mesh GenMeshKnot(float radius, float size, int radSeg, int sides); // Generate trefoil knot mesh
      RLAPI Mesh GenMeshHeightmap(Image heightmap, Vector3 size); // Generate heightmap mesh from image data
      RLAPI Mesh GenMeshCubicmap(Image cubicmap, Vector3 cubeSize); // Generate cubes-based map mesh from image data
      // Mesh manipulation functions
      RLAPI BoundingBox MeshBoundingBox(Mesh mesh); // Compute mesh bounding box limits
      RLAPI void MeshTangents(Mesh *mesh); // Compute mesh tangents
      RLAPI void MeshBinormals(Mesh *mesh); // Compute mesh binormals
      // Model drawing functions
      RLAPI void DrawModel(Model model, Vector3 position, float scale, Color tint); // Draw a model (with texture if set)
      RLAPI void DrawModelEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model with extended parameters
      RLAPI void DrawModelWires(Model model, Vector3 position, float scale, Color tint); // Draw a model wires (with texture if set)
      RLAPI void DrawModelWiresEx(Model model, Vector3 position, Vector3 rotationAxis, float rotationAngle, Vector3 scale, Color tint); // Draw a model wires (with texture if set) with extended parameters
      RLAPI void DrawBoundingBox(BoundingBox box, Color color); // Draw bounding box (wires)
      RLAPI void DrawBillboard(Camera camera, Texture2D texture, Vector3 center, float size, Color tint); // Draw a billboard texture
      RLAPI void DrawBillboardRec(Camera camera, Texture2D texture, Rectangle sourceRec, Vector3 center, float size, Color tint); // Draw a billboard texture defined by sourceRec
      // Collision detection functions
      RLAPI bool CheckCollisionSpheres(Vector3 centerA, float radiusA, Vector3 centerB, float radiusB); // Detect collision between two spheres
      RLAPI bool CheckCollisionBoxes(BoundingBox box1, BoundingBox box2); // Detect collision between two bounding boxes
      RLAPI bool CheckCollisionBoxSphere(BoundingBox box, Vector3 center, float radius); // Detect collision between box and sphere
      RLAPI bool CheckCollisionRaySphere(Ray ray, Vector3 center, float radius); // Detect collision between ray and sphere
      RLAPI bool CheckCollisionRaySphereEx(Ray ray, Vector3 center, float radius, Vector3 *collisionPoint); // Detect collision between ray and sphere, returns collision point
      RLAPI bool CheckCollisionRayBox(Ray ray, BoundingBox box); // Detect collision between ray and box
      RLAPI RayHitInfo GetCollisionRayModel(Ray ray, Model model); // Get collision info between ray and model
      RLAPI RayHitInfo GetCollisionRayTriangle(Ray ray, Vector3 p1, Vector3 p2, Vector3 p3); // Get collision info between ray and triangle
      RLAPI RayHitInfo GetCollisionRayGround(Ray ray, float groundHeight); // Get collision info between ray and ground plane (Y-normal plane)
      //------------------------------------------------------------------------------------
      // Shaders System Functions (Module: rlgl)
      // NOTE: This functions are useless when using OpenGL 1.1
      //------------------------------------------------------------------------------------
      // Shader loading/unloading functions
      RLAPI Shader LoadShader(const char *vsFileName, const char *fsFileName); // Load shader from files and bind default locations
      RLAPI Shader LoadShaderCode(const char *vsCode, const char *fsCode); // Load shader from code strings and bind default locations
      RLAPI void UnloadShader(Shader shader); // Unload shader from GPU memory (VRAM)
      RLAPI Shader GetShaderDefault(void); // Get default shader
      RLAPI Texture2D GetTextureDefault(void); // Get default texture
      RLAPI Texture2D GetShapesTexture(void); // Get texture to draw shapes
      RLAPI Rectangle GetShapesTextureRec(void); // Get texture rectangle to draw shapes
      RLAPI void SetShapesTexture(Texture2D texture, Rectangle source); // Define default texture used to draw shapes
      // Shader configuration functions
      RLAPI int GetShaderLocation(Shader shader, const char *uniformName); // Get shader uniform location
      RLAPI void SetShaderValue(Shader shader, int uniformLoc, const void *value, int uniformType); // Set shader uniform value
      RLAPI void SetShaderValueV(Shader shader, int uniformLoc, const void *value, int uniformType, int count); // Set shader uniform value vector
      RLAPI void SetShaderValueMatrix(Shader shader, int uniformLoc, Matrix mat); // Set shader uniform value (matrix 4x4)
      RLAPI void SetShaderValueTexture(Shader shader, int uniformLoc, Texture2D texture); // Set shader uniform value for texture
      RLAPI void SetMatrixProjection(Matrix proj); // Set a custom projection matrix (replaces internal projection matrix)
      RLAPI void SetMatrixModelview(Matrix view); // Set a custom modelview matrix (replaces internal modelview matrix)
      RLAPI Matrix GetMatrixModelview(void); // Get internal modelview matrix
      RLAPI Matrix GetMatrixProjection(void); // Get internal projection matrix
      // Texture maps generation (PBR)
      // NOTE: Required shaders should be provided
      RLAPI Texture2D GenTextureCubemap(Shader shader, Texture2D map, int size); // Generate cubemap texture from 2D texture
      RLAPI Texture2D GenTextureIrradiance(Shader shader, Texture2D cubemap, int size); // Generate irradiance texture using cubemap data
      RLAPI Texture2D GenTexturePrefilter(Shader shader, Texture2D cubemap, int size); // Generate prefilter texture using cubemap data
      RLAPI Texture2D GenTextureBRDF(Shader shader, int size); // Generate BRDF texture
      // Shading begin/end functions
      RLAPI void BeginShaderMode(Shader shader); // Begin custom shader drawing
      RLAPI void EndShaderMode(void); // End custom shader drawing (use default shader)
      RLAPI void BeginBlendMode(int mode); // Begin blending mode (alpha, additive, multiplied)
      RLAPI void EndBlendMode(void); // End blending mode (reset to default: alpha blending)
      // VR control functions
      RLAPI void InitVrSimulator(void); // Init VR simulator for selected device parameters
      RLAPI void CloseVrSimulator(void); // Close VR simulator for current device
      RLAPI void UpdateVrTracking(Camera *camera); // Update VR tracking (position and orientation) and camera
      RLAPI void SetVrConfiguration(VrDeviceInfo info, Shader distortion); // Set stereo rendering configuration parameters
      RLAPI bool IsVrSimulatorReady(void); // Detect if VR simulator is ready
      RLAPI void ToggleVrMode(void); // Enable/Disable VR experience
      RLAPI void BeginVrDrawing(void); // Begin VR simulator stereo rendering
      RLAPI void EndVrDrawing(void); // End VR simulator stereo rendering
      //------------------------------------------------------------------------------------
      // Audio Loading and Playing Functions (Module: audio)
      //------------------------------------------------------------------------------------
      // Audio device management functions
      RLAPI void InitAudioDevice(void); // Initialize audio device and context
      RLAPI void CloseAudioDevice(void); // Close the audio device and context
      RLAPI bool IsAudioDeviceReady(void); // Check if audio device has been initialized successfully
      RLAPI void SetMasterVolume(float volume); // Set master volume (listener)
      // Wave/Sound loading/unloading functions
      RLAPI Wave LoadWave(const char *fileName); // Load wave data from file
      RLAPI Sound LoadSound(const char *fileName); // Load sound from file
      RLAPI Sound LoadSoundFromWave(Wave wave); // Load sound from wave data
      RLAPI void UpdateSound(Sound sound, const void *data, int samplesCount);// Update sound buffer with new data
      RLAPI void UnloadWave(Wave wave); // Unload wave data
      RLAPI void UnloadSound(Sound sound); // Unload sound
      RLAPI void ExportWave(Wave wave, const char *fileName); // Export wave data to file
      RLAPI void ExportWaveAsCode(Wave wave, const char *fileName); // Export wave sample data to code (.h)
      // Wave/Sound management functions
      RLAPI void PlaySound(Sound sound); // Play a sound
      RLAPI void StopSound(Sound sound); // Stop playing a sound
      RLAPI void PauseSound(Sound sound); // Pause a sound
      RLAPI void ResumeSound(Sound sound); // Resume a paused sound
      RLAPI void PlaySoundMulti(Sound sound); // Play a sound (using multichannel buffer pool)
      RLAPI void StopSoundMulti(void); // Stop any sound playing (using multichannel buffer pool)
      RLAPI int GetSoundsPlaying(void); // Get number of sounds playing in the multichannel
      RLAPI bool IsSoundPlaying(Sound sound); // Check if a sound is currently playing
      RLAPI void SetSoundVolume(Sound sound, float volume); // Set volume for a sound (1.0 is max level)
      RLAPI void SetSoundPitch(Sound sound, float pitch); // Set pitch for a sound (1.0 is base level)
      RLAPI void WaveFormat(Wave *wave, int sampleRate, int sampleSize, int channels); // Convert wave data to desired format
      RLAPI Wave WaveCopy(Wave wave); // Copy a wave to a new wave
      RLAPI void WaveCrop(Wave *wave, int initSample, int finalSample); // Crop a wave to defined samples range
      RLAPI float *GetWaveData(Wave wave); // Get samples data from wave as a floats array
      // Music management functions
      RLAPI Music LoadMusicStream(const char *fileName); // Load music stream from file
      RLAPI void UnloadMusicStream(Music music); // Unload music stream
      RLAPI void PlayMusicStream(Music music); // Start music playing
      RLAPI void UpdateMusicStream(Music music); // Updates buffers for music streaming
      RLAPI void StopMusicStream(Music music); // Stop music playing
      RLAPI void PauseMusicStream(Music music); // Pause music playing
      RLAPI void ResumeMusicStream(Music music); // Resume playing paused music
      RLAPI bool IsMusicPlaying(Music music); // Check if music is playing
      RLAPI void SetMusicVolume(Music music, float volume); // Set volume for music (1.0 is max level)
      RLAPI void SetMusicPitch(Music music, float pitch); // Set pitch for a music (1.0 is base level)
      RLAPI void SetMusicLoopCount(Music music, int count); // Set music loop count (loop repeats)
      RLAPI float GetMusicTimeLength(Music music); // Get music time length (in seconds)
      RLAPI float GetMusicTimePlayed(Music music); // Get current music time played (in seconds)
      // AudioStream management functions
      RLAPI AudioStream InitAudioStream(unsigned int sampleRate, unsigned int sampleSize, unsigned int channels); // Init audio stream (to stream raw audio pcm data)
      RLAPI void UpdateAudioStream(AudioStream stream, const void *data, int samplesCount); // Update audio stream buffers with data
      RLAPI void CloseAudioStream(AudioStream stream); // Close audio stream and free memory
      RLAPI bool IsAudioStreamProcessed(AudioStream stream); // Check if any audio stream buffers requires refill
      RLAPI void PlayAudioStream(AudioStream stream); // Play audio stream
      RLAPI void PauseAudioStream(AudioStream stream); // Pause audio stream
      RLAPI void ResumeAudioStream(AudioStream stream); // Resume audio stream
      RLAPI bool IsAudioStreamPlaying(AudioStream stream); // Check if audio stream is playing
      RLAPI void StopAudioStream(AudioStream stream); // Stop audio stream
      RLAPI void SetAudioStreamVolume(AudioStream stream, float volume); // Set volume for audio stream (1.0 is max level)
      RLAPI void SetAudioStreamPitch(AudioStream stream, float pitch); // Set pitch for audio stream (1.0 is base level)
      RLAPI void SetAudioStreamBufferSizeDefault(int size); // Default size for new audio streams
      //------------------------------------------------------------------------------------
      // Network (Module: network)
      //------------------------------------------------------------------------------------
      // IN PROGRESS: Check rnet.h for reference
      #if defined(__cplusplus)
      }
      #endif
      #endif // RAYLIB_H
      raymath.h 0 → 100644
      View file @ 30949fb0
      /**********************************************************************************************
      *
      * raymath v1.2 - Math functions to work with Vector3, Matrix and Quaternions
      *
      * CONFIGURATION:
      *
      * #define RAYMATH_IMPLEMENTATION
      * Generates the implementation of the library into the included file.
      * If not defined, the library is in header only mode and can be included in other headers
      * or source files without problems. But only ONE file should hold the implementation.
      *
      * #define RAYMATH_HEADER_ONLY
      * Define static inline functions code, so #include header suffices for use.
      * This may use up lots of memory.
      *
      * #define RAYMATH_STANDALONE
      * Avoid raylib.h header inclusion in this file.
      * Vector3 and Matrix data types are defined internally in raymath module.
      *
      *
      * LICENSE: zlib/libpng
      *
      * Copyright (c) 2015-2020 Ramon Santamaria (@raysan5)
      *
      * This software is provided "as-is", without any express or implied warranty. In no event
      * will the authors be held liable for any damages arising from the use of this software.
      *
      * Permission is granted to anyone to use this software for any purpose, including commercial
      * applications, and to alter it and redistribute it freely, subject to the following restrictions:
      *
      * 1. The origin of this software must not be misrepresented; you must not claim that you
      * wrote the original software. If you use this software in a product, an acknowledgment
      * in the product documentation would be appreciated but is not required.
      *
      * 2. Altered source versions must be plainly marked as such, and must not be misrepresented
      * as being the original software.
      *
      * 3. This notice may not be removed or altered from any source distribution.
      *
      **********************************************************************************************/
      #ifndef RAYMATH_H
      #define RAYMATH_H
      //#define RAYMATH_STANDALONE // NOTE: To use raymath as standalone lib, just uncomment this line
      //#define RAYMATH_HEADER_ONLY // NOTE: To compile functions as static inline, uncomment this line
      #ifndef RAYMATH_STANDALONE
      #include "raylib.h" // Required for structs: Vector3, Matrix
      #endif
      #if defined(RAYMATH_IMPLEMENTATION) && defined(RAYMATH_HEADER_ONLY)
      #error "Specifying both RAYMATH_IMPLEMENTATION and RAYMATH_HEADER_ONLY is contradictory"
      #endif
      #if defined(RAYMATH_IMPLEMENTATION)
      #if defined(_WIN32) && defined(BUILD_LIBTYPE_SHARED)
      #define RMDEF __declspec(dllexport) extern inline // We are building raylib as a Win32 shared library (.dll).
      #elif defined(_WIN32) && defined(USE_LIBTYPE_SHARED)
      #define RMDEF __declspec(dllimport) // We are using raylib as a Win32 shared library (.dll)
      #else
      #define RMDEF extern inline // Provide external definition
      #endif
      #elif defined(RAYMATH_HEADER_ONLY)
      #define RMDEF static inline // Functions may be inlined, no external out-of-line definition
      #else
      #if defined(__TINYC__)
      #define RMDEF static inline // plain inline not supported by tinycc (See issue #435)
      #else
      #define RMDEF inline // Functions may be inlined or external definition used
      #endif
      #endif
      //----------------------------------------------------------------------------------
      // Defines and Macros
      //----------------------------------------------------------------------------------
      #ifndef PI
      #define PI 3.14159265358979323846
      #endif
      #ifndef DEG2RAD
      #define DEG2RAD (PI/180.0f)
      #endif
      #ifndef RAD2DEG
      #define RAD2DEG (180.0f/PI)
      #endif
      // Return float vector for Matrix
      #ifndef MatrixToFloat
      #define MatrixToFloat(mat) (MatrixToFloatV(mat).v)
      #endif
      // Return float vector for Vector3
      #ifndef Vector3ToFloat
      #define Vector3ToFloat(vec) (Vector3ToFloatV(vec).v)
      #endif
      //----------------------------------------------------------------------------------
      // Types and Structures Definition
      //----------------------------------------------------------------------------------
      #if defined(RAYMATH_STANDALONE)
      // Vector2 type
      typedef struct Vector2 {
      float x;
      float y;
      } Vector2;
      // Vector3 type
      typedef struct Vector3 {
      float x;
      float y;
      float z;
      } Vector3;
      // Quaternion type
      typedef struct Quaternion {
      float x;
      float y;
      float z;
      float w;
      } Quaternion;
      // Matrix type (OpenGL style 4x4 - right handed, column major)
      typedef struct Matrix {
      float m0, m4, m8, m12;
      float m1, m5, m9, m13;
      float m2, m6, m10, m14;
      float m3, m7, m11, m15;
      } Matrix;
      #endif
      // NOTE: Helper types to be used instead of array return types for *ToFloat functions
      typedef struct float3 { float v[3]; } float3;
      typedef struct float16 { float v[16]; } float16;
      #include <math.h> // Required for: sinf(), cosf(), sqrtf(), tan(), fabs()
      //----------------------------------------------------------------------------------
      // Module Functions Definition - Utils math
      //----------------------------------------------------------------------------------
      // Clamp float value
      RMDEF float Clamp(float value, float min, float max)
      {
      const float res = value < min ? min : value;
      return res > max ? max : res;
      }
      // Calculate linear interpolation between two floats
      RMDEF float Lerp(float start, float end, float amount)
      {
      return start + amount*(end - start);
      }
      //----------------------------------------------------------------------------------
      // Module Functions Definition - Vector2 math
      //----------------------------------------------------------------------------------
      // Vector with components value 0.0f
      RMDEF Vector2 Vector2Zero(void)
      {
      Vector2 result = { 0.0f, 0.0f };
      return result;
      }
      // Vector with components value 1.0f
      RMDEF Vector2 Vector2One(void)
      {
      Vector2 result = { 1.0f, 1.0f };
      return result;
      }
      // Add two vectors (v1 + v2)
      RMDEF Vector2 Vector2Add(Vector2 v1, Vector2 v2)
      {
      Vector2 result = { v1.x + v2.x, v1.y + v2.y };
      return result;
      }
      // Subtract two vectors (v1 - v2)
      RMDEF Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
      {
      Vector2 result = { v1.x - v2.x, v1.y - v2.y };
      return result;
      }
      // Calculate vector length
      RMDEF float Vector2Length(Vector2 v)
      {
      float result = sqrtf((v.x*v.x) + (v.y*v.y));
      return result;
      }
      // Calculate two vectors dot product
      RMDEF float Vector2DotProduct(Vector2 v1, Vector2 v2)
      {
      float result = (v1.x*v2.x + v1.y*v2.y);
      return result;
      }
      // Calculate distance between two vectors
      RMDEF float Vector2Distance(Vector2 v1, Vector2 v2)
      {
      float result = sqrtf((v1.x - v2.x)*(v1.x - v2.x) + (v1.y - v2.y)*(v1.y - v2.y));
      return result;
      }
      // Calculate angle from two vectors in X-axis
      RMDEF float Vector2Angle(Vector2 v1, Vector2 v2)
      {
      float result = atan2f(v2.y - v1.y, v2.x - v1.x)*(180.0f/PI);
      if (result < 0) result += 360.0f;
      return result;
      }
      // Scale vector (multiply by value)
      RMDEF Vector2 Vector2Scale(Vector2 v, float scale)
      {
      Vector2 result = { v.x*scale, v.y*scale };
      return result;
      }
      // Multiply vector by vector
      RMDEF Vector2 Vector2MultiplyV(Vector2 v1, Vector2 v2)
      {
      Vector2 result = { v1.x*v2.x, v1.y*v2.y };
      return result;
      }
      // Negate vector
      RMDEF Vector2 Vector2Negate(Vector2 v)
      {
      Vector2 result = { -v.x, -v.y };
      return result;
      }
      // Divide vector by a float value
      RMDEF Vector2 Vector2Divide(Vector2 v, float div)
      {
      Vector2 result = { v.x/div, v.y/div };
      return result;
      }
      // Divide vector by vector
      RMDEF Vector2 Vector2DivideV(Vector2 v1, Vector2 v2)
      {
      Vector2 result = { v1.x/v2.x, v1.y/v2.y };
      return result;
      }
      // Normalize provided vector
      RMDEF Vector2 Vector2Normalize(Vector2 v)
      {
      Vector2 result = Vector2Divide(v, Vector2Length(v));
      return result;
      }
      // Calculate linear interpolation between two vectors
      RMDEF Vector2 Vector2Lerp(Vector2 v1, Vector2 v2, float amount)
      {
      Vector2 result = { 0 };
      result.x = v1.x + amount*(v2.x - v1.x);
      result.y = v1.y + amount*(v2.y - v1.y);
      return result;
      }
      // Rotate Vector by float in Degrees.
      RMDEF Vector2 Vector2Rotate(Vector2 v, float degs)
      {
      float rads = degs*DEG2RAD;
      Vector2 result = {v.x * cosf(rads) - v.y * sinf(rads) , v.x * sinf(rads) + v.y * cosf(rads) };
      return result;
      }
      //----------------------------------------------------------------------------------
      // Module Functions Definition - Vector3 math
      //----------------------------------------------------------------------------------
      // Vector with components value 0.0f
      RMDEF Vector3 Vector3Zero(void)
      {
      Vector3 result = { 0.0f, 0.0f, 0.0f };
      return result;
      }
      // Vector with components value 1.0f
      RMDEF Vector3 Vector3One(void)
      {
      Vector3 result = { 1.0f, 1.0f, 1.0f };
      return result;
      }
      // Add two vectors
      RMDEF Vector3 Vector3Add(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { v1.x + v2.x, v1.y + v2.y, v1.z + v2.z };
      return result;
      }
      // Subtract two vectors
      RMDEF Vector3 Vector3Subtract(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { v1.x - v2.x, v1.y - v2.y, v1.z - v2.z };
      return result;
      }
      // Multiply vector by scalar
      RMDEF Vector3 Vector3Scale(Vector3 v, float scalar)
      {
      Vector3 result = { v.x*scalar, v.y*scalar, v.z*scalar };
      return result;
      }
      // Multiply vector by vector
      RMDEF Vector3 Vector3Multiply(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { v1.x*v2.x, v1.y*v2.y, v1.z*v2.z };
      return result;
      }
      // Calculate two vectors cross product
      RMDEF Vector3 Vector3CrossProduct(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { v1.y*v2.z - v1.z*v2.y, v1.z*v2.x - v1.x*v2.z, v1.x*v2.y - v1.y*v2.x };
      return result;
      }
      // Calculate one vector perpendicular vector
      RMDEF Vector3 Vector3Perpendicular(Vector3 v)
      {
      Vector3 result = { 0 };
      float min = (float) fabs(v.x);
      Vector3 cardinalAxis = {1.0f, 0.0f, 0.0f};
      if (fabs(v.y) < min)
      {
      min = (float) fabs(v.y);
      Vector3 tmp = {0.0f, 1.0f, 0.0f};
      cardinalAxis = tmp;
      }
      if (fabs(v.z) < min)
      {
      Vector3 tmp = {0.0f, 0.0f, 1.0f};
      cardinalAxis = tmp;
      }
      result = Vector3CrossProduct(v, cardinalAxis);
      return result;
      }
      // Calculate vector length
      RMDEF float Vector3Length(const Vector3 v)
      {
      float result = sqrtf(v.x*v.x + v.y*v.y + v.z*v.z);
      return result;
      }
      // Calculate two vectors dot product
      RMDEF float Vector3DotProduct(Vector3 v1, Vector3 v2)
      {
      float result = (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z);
      return result;
      }
      // Calculate distance between two vectors
      RMDEF float Vector3Distance(Vector3 v1, Vector3 v2)
      {
      float dx = v2.x - v1.x;
      float dy = v2.y - v1.y;
      float dz = v2.z - v1.z;
      float result = sqrtf(dx*dx + dy*dy + dz*dz);
      return result;
      }
      // Negate provided vector (invert direction)
      RMDEF Vector3 Vector3Negate(Vector3 v)
      {
      Vector3 result = { -v.x, -v.y, -v.z };
      return result;
      }
      // Divide vector by a float value
      RMDEF Vector3 Vector3Divide(Vector3 v, float div)
      {
      Vector3 result = { v.x / div, v.y / div, v.z / div };
      return result;
      }
      // Divide vector by vector
      RMDEF Vector3 Vector3DivideV(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { v1.x/v2.x, v1.y/v2.y, v1.z/v2.z };
      return result;
      }
      // Normalize provided vector
      RMDEF Vector3 Vector3Normalize(Vector3 v)
      {
      Vector3 result = v;
      float length, ilength;
      length = Vector3Length(v);
      if (length == 0.0f) length = 1.0f;
      ilength = 1.0f/length;
      result.x *= ilength;
      result.y *= ilength;
      result.z *= ilength;
      return result;
      }
      // Orthonormalize provided vectors
      // Makes vectors normalized and orthogonal to each other
      // Gram-Schmidt function implementation
      RMDEF void Vector3OrthoNormalize(Vector3 *v1, Vector3 *v2)
      {
      *v1 = Vector3Normalize(*v1);
      Vector3 vn = Vector3CrossProduct(*v1, *v2);
      vn = Vector3Normalize(vn);
      *v2 = Vector3CrossProduct(vn, *v1);
      }
      // Transforms a Vector3 by a given Matrix
      RMDEF Vector3 Vector3Transform(Vector3 v, Matrix mat)
      {
      Vector3 result = { 0 };
      float x = v.x;
      float y = v.y;
      float z = v.z;
      result.x = mat.m0*x + mat.m4*y + mat.m8*z + mat.m12;
      result.y = mat.m1*x + mat.m5*y + mat.m9*z + mat.m13;
      result.z = mat.m2*x + mat.m6*y + mat.m10*z + mat.m14;
      return result;
      }
      // Transform a vector by quaternion rotation
      RMDEF Vector3 Vector3RotateByQuaternion(Vector3 v, Quaternion q)
      {
      Vector3 result = { 0 };
      result.x = v.x*(q.x*q.x + q.w*q.w - q.y*q.y - q.z*q.z) + v.y*(2*q.x*q.y - 2*q.w*q.z) + v.z*(2*q.x*q.z + 2*q.w*q.y);
      result.y = v.x*(2*q.w*q.z + 2*q.x*q.y) + v.y*(q.w*q.w - q.x*q.x + q.y*q.y - q.z*q.z) + v.z*(-2*q.w*q.x + 2*q.y*q.z);
      result.z = v.x*(-2*q.w*q.y + 2*q.x*q.z) + v.y*(2*q.w*q.x + 2*q.y*q.z)+ v.z*(q.w*q.w - q.x*q.x - q.y*q.y + q.z*q.z);
      return result;
      }
      // Calculate linear interpolation between two vectors
      RMDEF Vector3 Vector3Lerp(Vector3 v1, Vector3 v2, float amount)
      {
      Vector3 result = { 0 };
      result.x = v1.x + amount*(v2.x - v1.x);
      result.y = v1.y + amount*(v2.y - v1.y);
      result.z = v1.z + amount*(v2.z - v1.z);
      return result;
      }
      // Calculate reflected vector to normal
      RMDEF Vector3 Vector3Reflect(Vector3 v, Vector3 normal)
      {
      // I is the original vector
      // N is the normal of the incident plane
      // R = I - (2*N*( DotProduct[ I,N] ))
      Vector3 result = { 0 };
      float dotProduct = Vector3DotProduct(v, normal);
      result.x = v.x - (2.0f*normal.x)*dotProduct;
      result.y = v.y - (2.0f*normal.y)*dotProduct;
      result.z = v.z - (2.0f*normal.z)*dotProduct;
      return result;
      }
      // Return min value for each pair of components
      RMDEF Vector3 Vector3Min(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { 0 };
      result.x = fminf(v1.x, v2.x);
      result.y = fminf(v1.y, v2.y);
      result.z = fminf(v1.z, v2.z);
      return result;
      }
      // Return max value for each pair of components
      RMDEF Vector3 Vector3Max(Vector3 v1, Vector3 v2)
      {
      Vector3 result = { 0 };
      result.x = fmaxf(v1.x, v2.x);
      result.y = fmaxf(v1.y, v2.y);
      result.z = fmaxf(v1.z, v2.z);
      return result;
      }
      // Compute barycenter coordinates (u, v, w) for point p with respect to triangle (a, b, c)
      // NOTE: Assumes P is on the plane of the triangle
      RMDEF Vector3 Vector3Barycenter(Vector3 p, Vector3 a, Vector3 b, Vector3 c)
      {
      //Vector v0 = b - a, v1 = c - a, v2 = p - a;
      Vector3 v0 = Vector3Subtract(b, a);
      Vector3 v1 = Vector3Subtract(c, a);
      Vector3 v2 = Vector3Subtract(p, a);
      float d00 = Vector3DotProduct(v0, v0);
      float d01 = Vector3DotProduct(v0, v1);
      float d11 = Vector3DotProduct(v1, v1);
      float d20 = Vector3DotProduct(v2, v0);
      float d21 = Vector3DotProduct(v2, v1);
      float denom = d00*d11 - d01*d01;
      Vector3 result = { 0 };
      result.y = (d11*d20 - d01*d21)/denom;
      result.z = (d00*d21 - d01*d20)/denom;
      result.x = 1.0f - (result.z + result.y);
      return result;
      }
      // Returns Vector3 as float array
      RMDEF float3 Vector3ToFloatV(Vector3 v)
      {
      float3 buffer = { 0 };
      buffer.v[0] = v.x;
      buffer.v[1] = v.y;
      buffer.v[2] = v.z;
      return buffer;
      }
      //----------------------------------------------------------------------------------
      // Module Functions Definition - Matrix math
      //----------------------------------------------------------------------------------
      // Compute matrix determinant
      RMDEF float MatrixDeterminant(Matrix mat)
      {
      // Cache the matrix values (speed optimization)
      float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
      float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
      float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
      float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
      float result = a30*a21*a12*a03 - a20*a31*a12*a03 - a30*a11*a22*a03 + a10*a31*a22*a03 +
      a20*a11*a32*a03 - a10*a21*a32*a03 - a30*a21*a02*a13 + a20*a31*a02*a13 +
      a30*a01*a22*a13 - a00*a31*a22*a13 - a20*a01*a32*a13 + a00*a21*a32*a13 +
      a30*a11*a02*a23 - a10*a31*a02*a23 - a30*a01*a12*a23 + a00*a31*a12*a23 +
      a10*a01*a32*a23 - a00*a11*a32*a23 - a20*a11*a02*a33 + a10*a21*a02*a33 +
      a20*a01*a12*a33 - a00*a21*a12*a33 - a10*a01*a22*a33 + a00*a11*a22*a33;
      return result;
      }
      // Returns the trace of the matrix (sum of the values along the diagonal)
      RMDEF float MatrixTrace(Matrix mat)
      {
      float result = (mat.m0 + mat.m5 + mat.m10 + mat.m15);
      return result;
      }
      // Transposes provided matrix
      RMDEF Matrix MatrixTranspose(Matrix mat)
      {
      Matrix result = { 0 };
      result.m0 = mat.m0;
      result.m1 = mat.m4;
      result.m2 = mat.m8;
      result.m3 = mat.m12;
      result.m4 = mat.m1;
      result.m5 = mat.m5;
      result.m6 = mat.m9;
      result.m7 = mat.m13;
      result.m8 = mat.m2;
      result.m9 = mat.m6;
      result.m10 = mat.m10;
      result.m11 = mat.m14;
      result.m12 = mat.m3;
      result.m13 = mat.m7;
      result.m14 = mat.m11;
      result.m15 = mat.m15;
      return result;
      }
      // Invert provided matrix
      RMDEF Matrix MatrixInvert(Matrix mat)
      {
      Matrix result = { 0 };
      // Cache the matrix values (speed optimization)
      float a00 = mat.m0, a01 = mat.m1, a02 = mat.m2, a03 = mat.m3;
      float a10 = mat.m4, a11 = mat.m5, a12 = mat.m6, a13 = mat.m7;
      float a20 = mat.m8, a21 = mat.m9, a22 = mat.m10, a23 = mat.m11;
      float a30 = mat.m12, a31 = mat.m13, a32 = mat.m14, a33 = mat.m15;
      float b00 = a00*a11 - a01*a10;
      float b01 = a00*a12 - a02*a10;
      float b02 = a00*a13 - a03*a10;
      float b03 = a01*a12 - a02*a11;
      float b04 = a01*a13 - a03*a11;
      float b05 = a02*a13 - a03*a12;
      float b06 = a20*a31 - a21*a30;
      float b07 = a20*a32 - a22*a30;
      float b08 = a20*a33 - a23*a30;
      float b09 = a21*a32 - a22*a31;
      float b10 = a21*a33 - a23*a31;
      float b11 = a22*a33 - a23*a32;
      // Calculate the invert determinant (inlined to avoid double-caching)
      float invDet = 1.0f/(b00*b11 - b01*b10 + b02*b09 + b03*b08 - b04*b07 + b05*b06);
      result.m0 = (a11*b11 - a12*b10 + a13*b09)*invDet;
      result.m1 = (-a01*b11 + a02*b10 - a03*b09)*invDet;
      result.m2 = (a31*b05 - a32*b04 + a33*b03)*invDet;
      result.m3 = (-a21*b05 + a22*b04 - a23*b03)*invDet;
      result.m4 = (-a10*b11 + a12*b08 - a13*b07)*invDet;
      result.m5 = (a00*b11 - a02*b08 + a03*b07)*invDet;
      result.m6 = (-a30*b05 + a32*b02 - a33*b01)*invDet;
      result.m7 = (a20*b05 - a22*b02 + a23*b01)*invDet;
      result.m8 = (a10*b10 - a11*b08 + a13*b06)*invDet;
      result.m9 = (-a00*b10 + a01*b08 - a03*b06)*invDet;
      result.m10 = (a30*b04 - a31*b02 + a33*b00)*invDet;
      result.m11 = (-a20*b04 + a21*b02 - a23*b00)*invDet;
      result.m12 = (-a10*b09 + a11*b07 - a12*b06)*invDet;
      result.m13 = (a00*b09 - a01*b07 + a02*b06)*invDet;
      result.m14 = (-a30*b03 + a31*b01 - a32*b00)*invDet;
      result.m15 = (a20*b03 - a21*b01 + a22*b00)*invDet;
      return result;
      }
      // Normalize provided matrix
      RMDEF Matrix MatrixNormalize(Matrix mat)
      {
      Matrix result = { 0 };
      float det = MatrixDeterminant(mat);
      result.m0 = mat.m0/det;
      result.m1 = mat.m1/det;
      result.m2 = mat.m2/det;
      result.m3 = mat.m3/det;
      result.m4 = mat.m4/det;
      result.m5 = mat.m5/det;
      result.m6 = mat.m6/det;
      result.m7 = mat.m7/det;
      result.m8 = mat.m8/det;
      result.m9 = mat.m9/det;
      result.m10 = mat.m10/det;
      result.m11 = mat.m11/det;
      result.m12 = mat.m12/det;
      result.m13 = mat.m13/det;
      result.m14 = mat.m14/det;
      result.m15 = mat.m15/det;
      return result;
      }
      // Returns identity matrix
      RMDEF Matrix MatrixIdentity(void)
      {
      Matrix result = { 1.0f, 0.0f, 0.0f, 0.0f,
      0.0f, 1.0f, 0.0f, 0.0f,
      0.0f, 0.0f, 1.0f, 0.0f,
      0.0f, 0.0f, 0.0f, 1.0f };
      return result;
      }
      // Add two matrices
      RMDEF Matrix MatrixAdd(Matrix left, Matrix right)
      {
      Matrix result = MatrixIdentity();
      result.m0 = left.m0 + right.m0;
      result.m1 = left.m1 + right.m1;
      result.m2 = left.m2 + right.m2;
      result.m3 = left.m3 + right.m3;
      result.m4 = left.m4 + right.m4;
      result.m5 = left.m5 + right.m5;
      result.m6 = left.m6 + right.m6;
      result.m7 = left.m7 + right.m7;
      result.m8 = left.m8 + right.m8;
      result.m9 = left.m9 + right.m9;
      result.m10 = left.m10 + right.m10;
      result.m11 = left.m11 + right.m11;
      result.m12 = left.m12 + right.m12;
      result.m13 = left.m13 + right.m13;
      result.m14 = left.m14 + right.m14;
      result.m15 = left.m15 + right.m15;
      return result;
      }
      // Subtract two matrices (left - right)
      RMDEF Matrix MatrixSubtract(Matrix left, Matrix right)
      {
      Matrix result = MatrixIdentity();
      result.m0 = left.m0 - right.m0;
      result.m1 = left.m1 - right.m1;
      result.m2 = left.m2 - right.m2;
      result.m3 = left.m3 - right.m3;
      result.m4 = left.m4 - right.m4;
      result.m5 = left.m5 - right.m5;
      result.m6 = left.m6 - right.m6;
      result.m7 = left.m7 - right.m7;
      result.m8 = left.m8 - right.m8;
      result.m9 = left.m9 - right.m9;
      result.m10 = left.m10 - right.m10;
      result.m11 = left.m11 - right.m11;
      result.m12 = left.m12 - right.m12;
      result.m13 = left.m13 - right.m13;
      result.m14 = left.m14 - right.m14;
      result.m15 = left.m15 - right.m15;
      return result;
      }
      // Returns translation matrix
      RMDEF Matrix MatrixTranslate(float x, float y, float z)
      {
      Matrix result = { 1.0f, 0.0f, 0.0f, x,
      0.0f, 1.0f, 0.0f, y,
      0.0f, 0.0f, 1.0f, z,
      0.0f, 0.0f, 0.0f, 1.0f };
      return result;
      }
      // Create rotation matrix from axis and angle
      // NOTE: Angle should be provided in radians
      RMDEF Matrix MatrixRotate(Vector3 axis, float angle)
      {
      Matrix result = { 0 };
      float x = axis.x, y = axis.y, z = axis.z;
      float length = sqrtf(x*x + y*y + z*z);
      if ((length != 1.0f) && (length != 0.0f))
      {
      length = 1.0f/length;
      x *= length;
      y *= length;
      z *= length;
      }
      float sinres = sinf(angle);
      float cosres = cosf(angle);
      float t = 1.0f - cosres;
      result.m0 = x*x*t + cosres;
      result.m1 = y*x*t + z*sinres;
      result.m2 = z*x*t - y*sinres;
      result.m3 = 0.0f;
      result.m4 = x*y*t - z*sinres;
      result.m5 = y*y*t + cosres;
      result.m6 = z*y*t + x*sinres;
      result.m7 = 0.0f;
      result.m8 = x*z*t + y*sinres;
      result.m9 = y*z*t - x*sinres;
      result.m10 = z*z*t + cosres;
      result.m11 = 0.0f;
      result.m12 = 0.0f;
      result.m13 = 0.0f;
      result.m14 = 0.0f;
      result.m15 = 1.0f;
      return result;
      }
      // Returns xyz-rotation matrix (angles in radians)
      RMDEF Matrix MatrixRotateXYZ(Vector3 ang)
      {
      Matrix result = MatrixIdentity();
      float cosz = cosf(-ang.z);
      float sinz = sinf(-ang.z);
      float cosy = cosf(-ang.y);
      float siny = sinf(-ang.y);
      float cosx = cosf(-ang.x);
      float sinx = sinf(-ang.x);
      result.m0 = cosz * cosy;
      result.m4 = (cosz * siny * sinx) - (sinz * cosx);
      result.m8 = (cosz * siny * cosx) + (sinz * sinx);
      result.m1 = sinz * cosy;
      result.m5 = (sinz * siny * sinx) + (cosz * cosx);
      result.m9 = (sinz * siny * cosx) - (cosz * sinx);
      result.m2 = -siny;
      result.m6 = cosy * sinx;
      result.m10= cosy * cosx;
      return result;
      }
      // Returns x-rotation matrix (angle in radians)
      RMDEF Matrix MatrixRotateX(float angle)
      {
      Matrix result = MatrixIdentity();
      float cosres = cosf(angle);
      float sinres = sinf(angle);
      result.m5 = cosres;
      result.m6 = -sinres;
      result.m9 = sinres;
      result.m10 = cosres;
      return result;
      }
      // Returns y-rotation matrix (angle in radians)
      RMDEF Matrix MatrixRotateY(float angle)
      {
      Matrix result = MatrixIdentity();
      float cosres = cosf(angle);
      float sinres = sinf(angle);
      result.m0 = cosres;
      result.m2 = sinres;
      result.m8 = -sinres;
      result.m10 = cosres;
      return result;
      }
      // Returns z-rotation matrix (angle in radians)
      RMDEF Matrix MatrixRotateZ(float angle)
      {
      Matrix result = MatrixIdentity();
      float cosres = cosf(angle);
      float sinres = sinf(angle);
      result.m0 = cosres;
      result.m1 = -sinres;
      result.m4 = sinres;
      result.m5 = cosres;
      return result;
      }
      // Returns scaling matrix
      RMDEF Matrix MatrixScale(float x, float y, float z)
      {
      Matrix result = { x, 0.0f, 0.0f, 0.0f,
      0.0f, y, 0.0f, 0.0f,
      0.0f, 0.0f, z, 0.0f,
      0.0f, 0.0f, 0.0f, 1.0f };
      return result;
      }
      // Returns two matrix multiplication
      // NOTE: When multiplying matrices... the order matters!
      RMDEF Matrix MatrixMultiply(Matrix left, Matrix right)
      {
      Matrix result = { 0 };
      result.m0 = left.m0*right.m0 + left.m1*right.m4 + left.m2*right.m8 + left.m3*right.m12;
      result.m1 = left.m0*right.m1 + left.m1*right.m5 + left.m2*right.m9 + left.m3*right.m13;
      result.m2 = left.m0*right.m2 + left.m1*right.m6 + left.m2*right.m10 + left.m3*right.m14;
      result.m3 = left.m0*right.m3 + left.m1*right.m7 + left.m2*right.m11 + left.m3*right.m15;
      result.m4 = left.m4*right.m0 + left.m5*right.m4 + left.m6*right.m8 + left.m7*right.m12;
      result.m5 = left.m4*right.m1 + left.m5*right.m5 + left.m6*right.m9 + left.m7*right.m13;
      result.m6 = left.m4*right.m2 + left.m5*right.m6 + left.m6*right.m10 + left.m7*right.m14;
      result.m7 = left.m4*right.m3 + left.m5*right.m7 + left.m6*right.m11 + left.m7*right.m15;
      result.m8 = left.m8*right.m0 + left.m9*right.m4 + left.m10*right.m8 + left.m11*right.m12;
      result.m9 = left.m8*right.m1 + left.m9*right.m5 + left.m10*right.m9 + left.m11*right.m13;
      result.m10 = left.m8*right.m2 + left.m9*right.m6 + left.m10*right.m10 + left.m11*right.m14;
      result.m11 = left.m8*right.m3 + left.m9*right.m7 + left.m10*right.m11 + left.m11*right.m15;
      result.m12 = left.m12*right.m0 + left.m13*right.m4 + left.m14*right.m8 + left.m15*right.m12;
      result.m13 = left.m12*right.m1 + left.m13*right.m5 + left.m14*right.m9 + left.m15*right.m13;
      result.m14 = left.m12*right.m2 + left.m13*right.m6 + left.m14*right.m10 + left.m15*right.m14;
      result.m15 = left.m12*right.m3 + left.m13*right.m7 + left.m14*right.m11 + left.m15*right.m15;
      return result;
      }
      // Returns perspective projection matrix
      RMDEF Matrix MatrixFrustum(double left, double right, double bottom, double top, double near, double far)
      {
      Matrix result = { 0 };
      float rl = (float)(right - left);
      float tb = (float)(top - bottom);
      float fn = (float)(far - near);
      result.m0 = ((float) near*2.0f)/rl;
      result.m1 = 0.0f;
      result.m2 = 0.0f;
      result.m3 = 0.0f;
      result.m4 = 0.0f;
      result.m5 = ((float) near*2.0f)/tb;
      result.m6 = 0.0f;
      result.m7 = 0.0f;
      result.m8 = ((float)right + (float)left)/rl;
      result.m9 = ((float)top + (float)bottom)/tb;
      result.m10 = -((float)far + (float)near)/fn;
      result.m11 = -1.0f;
      result.m12 = 0.0f;
      result.m13 = 0.0f;
      result.m14 = -((float)far*(float)near*2.0f)/fn;
      result.m15 = 0.0f;
      return result;
      }
      // Returns perspective projection matrix
      // NOTE: Angle should be provided in radians
      RMDEF Matrix MatrixPerspective(double fovy, double aspect, double near, double far)
      {
      double top = near*tan(fovy*0.5);
      double right = top*aspect;
      Matrix result = MatrixFrustum(-right, right, -top, top, near, far);
      return result;
      }
      // Returns orthographic projection matrix
      RMDEF Matrix MatrixOrtho(double left, double right, double bottom, double top, double near, double far)
      {
      Matrix result = { 0 };
      float rl = (float)(right - left);
      float tb = (float)(top - bottom);
      float fn = (float)(far - near);
      result.m0 = 2.0f/rl;
      result.m1 = 0.0f;
      result.m2 = 0.0f;
      result.m3 = 0.0f;
      result.m4 = 0.0f;
      result.m5 = 2.0f/tb;
      result.m6 = 0.0f;
      result.m7 = 0.0f;
      result.m8 = 0.0f;
      result.m9 = 0.0f;
      result.m10 = -2.0f/fn;
      result.m11 = 0.0f;
      result.m12 = -((float)left + (float)right)/rl;
      result.m13 = -((float)top + (float)bottom)/tb;
      result.m14 = -((float)far + (float)near)/fn;
      result.m15 = 1.0f;
      return result;
      }
      // Returns camera look-at matrix (view matrix)
      RMDEF Matrix MatrixLookAt(Vector3 eye, Vector3 target, Vector3 up)
      {
      Matrix result = { 0 };
      Vector3 z = Vector3Subtract(eye, target);
      z = Vector3Normalize(z);
      Vector3 x = Vector3CrossProduct(up, z);
      x = Vector3Normalize(x);
      Vector3 y = Vector3CrossProduct(z, x);
      y = Vector3Normalize(y);
      result.m0 = x.x;
      result.m1 = x.y;
      result.m2 = x.z;
      result.m3 = 0.0f;
      result.m4 = y.x;
      result.m5 = y.y;
      result.m6 = y.z;
      result.m7 = 0.0f;
      result.m8 = z.x;
      result.m9 = z.y;
      result.m10 = z.z;
      result.m11 = 0.0f;
      result.m12 = eye.x;
      result.m13 = eye.y;
      result.m14 = eye.z;
      result.m15 = 1.0f;
      result = MatrixInvert(result);
      return result;
      }
      // Returns float array of matrix data
      RMDEF float16 MatrixToFloatV(Matrix mat)
      {
      float16 buffer = { 0 };
      buffer.v[0] = mat.m0;
      buffer.v[1] = mat.m1;
      buffer.v[2] = mat.m2;
      buffer.v[3] = mat.m3;
      buffer.v[4] = mat.m4;
      buffer.v[5] = mat.m5;
      buffer.v[6] = mat.m6;
      buffer.v[7] = mat.m7;
      buffer.v[8] = mat.m8;
      buffer.v[9] = mat.m9;
      buffer.v[10] = mat.m10;
      buffer.v[11] = mat.m11;
      buffer.v[12] = mat.m12;
      buffer.v[13] = mat.m13;
      buffer.v[14] = mat.m14;
      buffer.v[15] = mat.m15;
      return buffer;
      }
      //----------------------------------------------------------------------------------
      // Module Functions Definition - Quaternion math
      //----------------------------------------------------------------------------------
      // Returns identity quaternion
      RMDEF Quaternion QuaternionIdentity(void)
      {
      Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f };
      return result;
      }
      // Computes the length of a quaternion
      RMDEF float QuaternionLength(Quaternion q)
      {
      float result = (float)sqrt(q.x*q.x + q.y*q.y + q.z*q.z + q.w*q.w);
      return result;
      }
      // Normalize provided quaternion
      RMDEF Quaternion QuaternionNormalize(Quaternion q)
      {
      Quaternion result = { 0 };
      float length, ilength;
      length = QuaternionLength(q);
      if (length == 0.0f) length = 1.0f;
      ilength = 1.0f/length;
      result.x = q.x*ilength;
      result.y = q.y*ilength;
      result.z = q.z*ilength;
      result.w = q.w*ilength;
      return result;
      }
      // Invert provided quaternion
      RMDEF Quaternion QuaternionInvert(Quaternion q)
      {
      Quaternion result = q;
      float length = QuaternionLength(q);
      float lengthSq = length*length;
      if (lengthSq != 0.0)
      {
      float i = 1.0f/lengthSq;
      result.x *= -i;
      result.y *= -i;
      result.z *= -i;
      result.w *= i;
      }
      return result;
      }
      // Calculate two quaternion multiplication
      RMDEF Quaternion QuaternionMultiply(Quaternion q1, Quaternion q2)
      {
      Quaternion result = { 0 };
      float qax = q1.x, qay = q1.y, qaz = q1.z, qaw = q1.w;
      float qbx = q2.x, qby = q2.y, qbz = q2.z, qbw = q2.w;
      result.x = qax*qbw + qaw*qbx + qay*qbz - qaz*qby;
      result.y = qay*qbw + qaw*qby + qaz*qbx - qax*qbz;
      result.z = qaz*qbw + qaw*qbz + qax*qby - qay*qbx;
      result.w = qaw*qbw - qax*qbx - qay*qby - qaz*qbz;
      return result;
      }
      // Calculate linear interpolation between two quaternions
      RMDEF Quaternion QuaternionLerp(Quaternion q1, Quaternion q2, float amount)
      {
      Quaternion result = { 0 };
      result.x = q1.x + amount*(q2.x - q1.x);
      result.y = q1.y + amount*(q2.y - q1.y);
      result.z = q1.z + amount*(q2.z - q1.z);
      result.w = q1.w + amount*(q2.w - q1.w);
      return result;
      }
      // Calculate slerp-optimized interpolation between two quaternions
      RMDEF Quaternion QuaternionNlerp(Quaternion q1, Quaternion q2, float amount)
      {
      Quaternion result = QuaternionLerp(q1, q2, amount);
      result = QuaternionNormalize(result);
      return result;
      }
      // Calculates spherical linear interpolation between two quaternions
      RMDEF Quaternion QuaternionSlerp(Quaternion q1, Quaternion q2, float amount)
      {
      Quaternion result = { 0 };
      float cosHalfTheta = q1.x*q2.x + q1.y*q2.y + q1.z*q2.z + q1.w*q2.w;
      if (fabs(cosHalfTheta) >= 1.0f) result = q1;
      else if (cosHalfTheta > 0.95f) result = QuaternionNlerp(q1, q2, amount);
      else
      {
      float halfTheta = acosf(cosHalfTheta);
      float sinHalfTheta = sqrtf(1.0f - cosHalfTheta*cosHalfTheta);
      if (fabs(sinHalfTheta) < 0.001f)
      {
      result.x = (q1.x*0.5f + q2.x*0.5f);
      result.y = (q1.y*0.5f + q2.y*0.5f);
      result.z = (q1.z*0.5f + q2.z*0.5f);
      result.w = (q1.w*0.5f + q2.w*0.5f);
      }
      else
      {
      float ratioA = sinf((1 - amount)*halfTheta)/sinHalfTheta;
      float ratioB = sinf(amount*halfTheta)/sinHalfTheta;
      result.x = (q1.x*ratioA + q2.x*ratioB);
      result.y = (q1.y*ratioA + q2.y*ratioB);
      result.z = (q1.z*ratioA + q2.z*ratioB);
      result.w = (q1.w*ratioA + q2.w*ratioB);
      }
      }
      return result;
      }
      // Calculate quaternion based on the rotation from one vector to another
      RMDEF Quaternion QuaternionFromVector3ToVector3(Vector3 from, Vector3 to)
      {
      Quaternion result = { 0 };
      float cos2Theta = Vector3DotProduct(from, to);
      Vector3 cross = Vector3CrossProduct(from, to);
      result.x = cross.x;
      result.y = cross.y;
      result.z = cross.y;
      result.w = 1.0f + cos2Theta; // NOTE: Added QuaternioIdentity()
      // Normalize to essentially nlerp the original and identity to 0.5
      result = QuaternionNormalize(result);
      // Above lines are equivalent to:
      //Quaternion result = QuaternionNlerp(q, QuaternionIdentity(), 0.5f);
      return result;
      }
      // Returns a quaternion for a given rotation matrix
      RMDEF Quaternion QuaternionFromMatrix(Matrix mat)
      {
      Quaternion result = { 0 };
      float trace = MatrixTrace(mat);
      if (trace > 0.0f)
      {
      float s = sqrtf(trace + 1)*2.0f;
      float invS = 1.0f/s;
      result.w = s*0.25f;
      result.x = (mat.m6 - mat.m9)*invS;
      result.y = (mat.m8 - mat.m2)*invS;
      result.z = (mat.m1 - mat.m4)*invS;
      }
      else
      {
      float m00 = mat.m0, m11 = mat.m5, m22 = mat.m10;
      if (m00 > m11 && m00 > m22)
      {
      float s = (float)sqrt(1.0f + m00 - m11 - m22)*2.0f;
      float invS = 1.0f/s;
      result.w = (mat.m6 - mat.m9)*invS;
      result.x = s*0.25f;
      result.y = (mat.m4 + mat.m1)*invS;
      result.z = (mat.m8 + mat.m2)*invS;
      }
      else if (m11 > m22)
      {
      float s = sqrtf(1.0f + m11 - m00 - m22)*2.0f;
      float invS = 1.0f/s;
      result.w = (mat.m8 - mat.m2)*invS;
      result.x = (mat.m4 + mat.m1)*invS;
      result.y = s*0.25f;
      result.z = (mat.m9 + mat.m6)*invS;
      }
      else
      {
      float s = sqrtf(1.0f + m22 - m00 - m11)*2.0f;
      float invS = 1.0f/s;
      result.w = (mat.m1 - mat.m4)*invS;
      result.x = (mat.m8 + mat.m2)*invS;
      result.y = (mat.m9 + mat.m6)*invS;
      result.z = s*0.25f;
      }
      }
      return result;
      }
      // Returns a matrix for a given quaternion
      RMDEF Matrix QuaternionToMatrix(Quaternion q)
      {
      Matrix result = { 0 };
      float x = q.x, y = q.y, z = q.z, w = q.w;
      float x2 = x + x;
      float y2 = y + y;
      float z2 = z + z;
      float length = QuaternionLength(q);
      float lengthSquared = length*length;
      float xx = x*x2/lengthSquared;
      float xy = x*y2/lengthSquared;
      float xz = x*z2/lengthSquared;
      float yy = y*y2/lengthSquared;
      float yz = y*z2/lengthSquared;
      float zz = z*z2/lengthSquared;
      float wx = w*x2/lengthSquared;
      float wy = w*y2/lengthSquared;
      float wz = w*z2/lengthSquared;
      result.m0 = 1.0f - (yy + zz);
      result.m1 = xy - wz;
      result.m2 = xz + wy;
      result.m3 = 0.0f;
      result.m4 = xy + wz;
      result.m5 = 1.0f - (xx + zz);
      result.m6 = yz - wx;
      result.m7 = 0.0f;
      result.m8 = xz - wy;
      result.m9 = yz + wx;
      result.m10 = 1.0f - (xx + yy);
      result.m11 = 0.0f;
      result.m12 = 0.0f;
      result.m13 = 0.0f;
      result.m14 = 0.0f;
      result.m15 = 1.0f;
      return result;
      }
      // Returns rotation quaternion for an angle and axis
      // NOTE: angle must be provided in radians
      RMDEF Quaternion QuaternionFromAxisAngle(Vector3 axis, float angle)
      {
      Quaternion result = { 0.0f, 0.0f, 0.0f, 1.0f };
      if (Vector3Length(axis) != 0.0f)
      angle *= 0.5f;
      axis = Vector3Normalize(axis);
      float sinres = sinf(angle);
      float cosres = cosf(angle);
      result.x = axis.x*sinres;
      result.y = axis.y*sinres;
      result.z = axis.z*sinres;
      result.w = cosres;
      result = QuaternionNormalize(result);
      return result;
      }
      // Returns the rotation angle and axis for a given quaternion
      RMDEF void QuaternionToAxisAngle(Quaternion q, Vector3 *outAxis, float *outAngle)
      {
      if (fabs(q.w) > 1.0f) q = QuaternionNormalize(q);
      Vector3 resAxis = { 0.0f, 0.0f, 0.0f };
      float resAngle = 2.0f*acosf(q.w);
      float den = sqrtf(1.0f - q.w*q.w);
      if (den > 0.0001f)
      {
      resAxis.x = q.x/den;
      resAxis.y = q.y/den;
      resAxis.z = q.z/den;
      }
      else
      {
      // This occurs when the angle is zero.
      // Not a problem: just set an arbitrary normalized axis.
      resAxis.x = 1.0f;
      }
      *outAxis = resAxis;
      *outAngle = resAngle;
      }
      // Returns he quaternion equivalent to Euler angles
      RMDEF Quaternion QuaternionFromEuler(float roll, float pitch, float yaw)
      {
      Quaternion q = { 0 };
      float x0 = cosf(roll*0.5f);
      float x1 = sinf(roll*0.5f);
      float y0 = cosf(pitch*0.5f);
      float y1 = sinf(pitch*0.5f);
      float z0 = cosf(yaw*0.5f);
      float z1 = sinf(yaw*0.5f);
      q.x = x1*y0*z0 - x0*y1*z1;
      q.y = x0*y1*z0 + x1*y0*z1;
      q.z = x0*y0*z1 - x1*y1*z0;
      q.w = x0*y0*z0 + x1*y1*z1;
      return q;
      }
      // Return the Euler angles equivalent to quaternion (roll, pitch, yaw)
      // NOTE: Angles are returned in a Vector3 struct in degrees
      RMDEF Vector3 QuaternionToEuler(Quaternion q)
      {
      Vector3 result = { 0 };
      // roll (x-axis rotation)
      float x0 = 2.0f*(q.w*q.x + q.y*q.z);
      float x1 = 1.0f - 2.0f*(q.x*q.x + q.y*q.y);
      result.x = atan2f(x0, x1)*RAD2DEG;
      // pitch (y-axis rotation)
      float y0 = 2.0f*(q.w*q.y - q.z*q.x);
      y0 = y0 > 1.0f ? 1.0f : y0;
      y0 = y0 < -1.0f ? -1.0f : y0;
      result.y = asinf(y0)*RAD2DEG;
      // yaw (z-axis rotation)
      float z0 = 2.0f*(q.w*q.z + q.x*q.y);
      float z1 = 1.0f - 2.0f*(q.y*q.y + q.z*q.z);
      result.z = atan2f(z0, z1)*RAD2DEG;
      return result;
      }
      // Transform a quaternion given a transformation matrix
      RMDEF Quaternion QuaternionTransform(Quaternion q, Matrix mat)
      {
      Quaternion result = { 0 };
      result.x = mat.m0*q.x + mat.m4*q.y + mat.m8*q.z + mat.m12*q.w;
      result.y = mat.m1*q.x + mat.m5*q.y + mat.m9*q.z + mat.m13*q.w;
      result.z = mat.m2*q.x + mat.m6*q.y + mat.m10*q.z + mat.m14*q.w;
      result.w = mat.m3*q.x + mat.m7*q.y + mat.m11*q.z + mat.m15*q.w;
      return result;
      }
      #endif // RAYMATH_H
      Markdown is supported
      0% or
      You are about to add 0 people to the discussion. Proceed with caution.
      Finish editing this message first!
      Please register or to comment