From 305efcf5ad715305ccb33b0e1d2d9baf4a34976a Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Sat, 5 Mar 2016 17:05:02 +0100
Subject: Redesigned physics module (IN PROGRESS)

physac modules is being redesigned. Physics base behaviour is done and
it is composed by three steps: apply physics, resolve collisions and fix
overlapping.

A basic example is currently in progress. The next steps are try to add
torque and unoriented physic collisions and implement physics basic
functions to add forces. Rigidbody grounding state is automatically
calculated and has a perfect result. Rigidbodies interacts well with
each others.

To achieve physics accuracy, UpdatePhysics() is called a number of times
per frame. In a future, it should be changed to another thread and call
it without any target frame restriction.

Basic physics example has been redone (not finished) using the new
module functions. Forces examples will be redone so I removed it from
branch.
---
 examples/physics_basic_rigidbody.c | 131 +++++++++++++++++++------------------
 1 file changed, 67 insertions(+), 64 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 6c354eb7..c604dd14 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -1,8 +1,8 @@
 /*******************************************************************************************
 *
-*   raylib [physac] physics example - Basic rigidbody
+*   raylib [physac] example - Basic rigidbody
 *
-*   This example has been created using raylib 1.4 (www.raylib.com)
+*   This example has been created using raylib 1.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
@@ -11,8 +11,8 @@
 
 #include "raylib.h"
 
-#define OBJECT_SIZE 50
-#define PLAYER_INDEX 0
+#define MOVE_VELOCITY    5
+#define JUMP_VELOCITY    35
 
 int main()
 {
@@ -20,28 +20,45 @@ int main()
     //--------------------------------------------------------------------------------------
     int screenWidth = 800;
     int screenHeight = 450;
-    
-    InitWindow(screenWidth, screenHeight, "raylib [physics] example - basic rigidbody");
 
-    InitPhysics(3);      // Initialize physics system with maximum physic objects
+    InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
+    InitPhysics();      // Initialize physics module
     
-    // Object initialization
-    Transform player = (Transform){(Vector2){(screenWidth - OBJECT_SIZE) / 2, (screenHeight - OBJECT_SIZE) / 2}, 0.0f, (Vector2){OBJECT_SIZE, OBJECT_SIZE}};
-    AddCollider(PLAYER_INDEX, (Collider){true, COLLIDER_RECTANGLE, (Rectangle){player.position.x, player.position.y, player.scale.x, player.scale.y}, 0});
-    AddRigidbody(PLAYER_INDEX, (Rigidbody){true, 1.0f, (Vector2){0, 0}, (Vector2){0, 0}, false, false, true, 0.5f, 1.0f});
+    SetTargetFPS(60);
     
-    // Floor initialization 
-    // NOTE: floor doesn't need a rigidbody because it's a static physic object, just a collider to collide with other dynamic colliders (with rigidbody)
-    Transform floor = (Transform){(Vector2){0, screenHeight * 0.8f}, 0.0f, (Vector2){screenWidth, screenHeight * 0.2f}};
-    AddCollider(PLAYER_INDEX + 1, (Collider){true, COLLIDER_RECTANGLE, (Rectangle){floor.position.x, floor.position.y, floor.scale.x, floor.scale.y}, 0});
+    // Debug variables
+    bool isDebug = false;
     
-    // Object properties initialization
-    float moveSpeed = 6.0f;
-    float jumpForce = 5.0f;
+    // Player physic object
+    PhysicObject *player = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+    player->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
+    player->rigidbody.applyGravity = true;
+    player->rigidbody.friction = 0.3f;
+    player->collider.enabled = true;        // Enable physic object collisions detection
     
-    bool physicsDebug = false;
+    // Player physic object
+    PhysicObject *player2 = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+    player2->rigidbody.enabled = true;
+    player2->rigidbody.applyGravity = true;
+    player2->rigidbody.friction = 0.1f;
+    player2->collider.enabled = true;
+    
+    // Floor physic object
+    PhysicObject *floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+    floor->collider.enabled = true;         // Enable just physic object collisions detection
+    
+    // Left wall physic object
+    PhysicObject *leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    leftWall->collider.enabled = true;
+    
+    // Right wall physic object
+    PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    rightWall->collider.enabled = true;
+    
+    // Platform physic objectdd
+    PhysicObject *platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
+    platform->collider.enabled = true;
     
-    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -49,35 +66,22 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
+        UpdatePhysics();    // Update all created physic objects
         
-        // Update object physics 
-        // NOTE: all physics detections and reactions are calculated in ApplyPhysics() function (You will live happier :D)
-        ApplyPhysics(PLAYER_INDEX, &player.position);
+        // Check debug switch input
+        if (IsKeyPressed('P')) isDebug = !isDebug;
         
-        // Check jump button input
-        if (IsKeyDown(KEY_SPACE) && GetRigidbody(PLAYER_INDEX).isGrounded)
-        {
-            // Reset object Y velocity to avoid double jumping cases but keep the same X velocity that it already has
-            SetRigidbodyVelocity(PLAYER_INDEX, (Vector2){GetRigidbody(PLAYER_INDEX).velocity.x, 0});
-            
-            // Add jumping force in Y axis
-            AddRigidbodyForce(PLAYER_INDEX, (Vector2){0, jumpForce});
-        }
+        // Check player movement inputs
+        if (IsKeyDown('W') && player->rigidbody.isGrounded) player->rigidbody.velocity.y = JUMP_VELOCITY;
+        
+        if (IsKeyDown('A')) player->rigidbody.velocity.x = -MOVE_VELOCITY;
+        else if (IsKeyDown('D')) player->rigidbody.velocity.x = MOVE_VELOCITY;
         
-        // Check movement buttons input
-        if (IsKeyDown(KEY_RIGHT) || IsKeyDown(KEY_D))
-        {
-            // Set rigidbody velocity in X based on moveSpeed value and apply the same Y velocity that it already has
-            SetRigidbodyVelocity(PLAYER_INDEX, (Vector2){moveSpeed, GetRigidbody(PLAYER_INDEX).velocity.y});
-        }
-        else if (IsKeyDown(KEY_LEFT) || IsKeyDown(KEY_A))
-        {
-            // Set rigidbody velocity in X based on moveSpeed negative value and apply the same Y velocity that it already has
-            SetRigidbodyVelocity(PLAYER_INDEX, (Vector2){-moveSpeed, GetRigidbody(PLAYER_INDEX).velocity.y});
-        }
+        // Check player 2 movement inputs
+        if (IsKeyDown(KEY_UP) && player2->rigidbody.isGrounded) player2->rigidbody.velocity.y = JUMP_VELOCITY;
         
-        // Check debug mode toggle button input
-        if (IsKeyPressed(KEY_P)) physicsDebug = !physicsDebug;
+        if (IsKeyDown(KEY_LEFT)) player2->rigidbody.velocity.x = -MOVE_VELOCITY;
+        else if (IsKeyDown(KEY_RIGHT)) player2->rigidbody.velocity.x = MOVE_VELOCITY;
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -86,28 +90,28 @@ int main()
 
             ClearBackground(RAYWHITE);
             
-            // Draw information
-            DrawText("Use LEFT / RIGHT to MOVE and SPACE to JUMP", (screenWidth - MeasureText("Use LEFT / RIGHT to MOVE and SPACE to JUMP", 20)) / 2, screenHeight * 0.20f, 20, LIGHTGRAY);
-            DrawText("Use P to switch DEBUG MODE", (screenWidth - MeasureText("Use P to switch DEBUG MODE", 20)) / 2, screenHeight * 0.3f, 20, LIGHTGRAY);
-            
-            // Check if debug mode is enabled
-            if (physicsDebug)
+            if (isDebug)
             {
-                // Draw every internal physics stored collider if it is active
-                for (int i = 0; i < 2; i++)
-                {
-                    if (GetCollider(i).enabled)
-                    {
-                        DrawRectangleLines(GetCollider(i).bounds.x, GetCollider(i).bounds.y, GetCollider(i).bounds.width, GetCollider(i).bounds.height, GREEN);
-                    }
-                }
+                DrawRectangleLines(floor->collider.bounds.x, floor->collider.bounds.y, floor->collider.bounds.width, floor->collider.bounds.height, GREEN);
+                DrawRectangleLines(leftWall->collider.bounds.x, leftWall->collider.bounds.y, leftWall->collider.bounds.width, leftWall->collider.bounds.height, GREEN);
+                DrawRectangleLines(rightWall->collider.bounds.x, rightWall->collider.bounds.y, rightWall->collider.bounds.width, rightWall->collider.bounds.height, GREEN);
+                DrawRectangleLines(platform->collider.bounds.x, platform->collider.bounds.y, platform->collider.bounds.width, platform->collider.bounds.height, GREEN);
+                DrawRectangleLines(player->collider.bounds.x, player->collider.bounds.y, player->collider.bounds.width, player->collider.bounds.height, GREEN);
+                DrawRectangleLines(player2->collider.bounds.x, player2->collider.bounds.y, player2->collider.bounds.width, player2->collider.bounds.height, GREEN);
             }
             else
             {
-                // Draw player and floor
-                DrawRectangleRec((Rectangle){player.position.x, player.position.y, player.scale.x, player.scale.y}, GRAY);
-                DrawRectangleRec((Rectangle){floor.position.x, floor.position.y, floor.scale.x, floor.scale.y}, BLACK);
+                // Convert transform values to rectangle data type variable
+                DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);
+                DrawRectangleRec(TransformToRectangle(leftWall->transform), DARKGRAY);
+                DrawRectangleRec(TransformToRectangle(rightWall->transform), DARKGRAY);
+                DrawRectangleRec(TransformToRectangle(platform->transform), DARKGRAY);
+                DrawRectangleRec(TransformToRectangle(player->transform), RED);
+                DrawRectangleRec(TransformToRectangle(player2->transform), BLUE);
             }
+            
+            // Draw all physic object information in specific screen position and font size
+            // DrawPhysicObjectInfo(player, (Vector2){ 10.0f, 10.0f }, 10);    
 
         EndDrawing();
         //----------------------------------------------------------------------------------
@@ -115,8 +119,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    UnloadPhysics();      // Unload physic objects
-    
+    ClosePhysics();       // Unitialize physics module
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
-- 
cgit v1.2.3


From dc68205a18168a611b11d3b042a806edcdd96781 Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Wed, 16 Mar 2016 12:46:12 +0100
Subject: Updated and improved physac examples

---
 examples/physics_basic_rigidbody.c |  90 ++++++++++-----------
 examples/physics_forces.c          | 160 +++++++++++++++++++++++++++++++++++++
 2 files changed, 201 insertions(+), 49 deletions(-)
 create mode 100644 examples/physics_forces.c

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index c604dd14..f0edba72 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -12,7 +12,7 @@
 #include "raylib.h"
 
 #define MOVE_VELOCITY    5
-#define JUMP_VELOCITY    35
+#define JUMP_VELOCITY    30
 
 int main()
 {
@@ -22,42 +22,34 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    InitPhysics();      // Initialize physics module
+    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     SetTargetFPS(60);
     
     // Debug variables
     bool isDebug = false;
     
-    // Player physic object
-    PhysicObject *player = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
-    player->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
-    player->rigidbody.applyGravity = true;
-    player->rigidbody.friction = 0.3f;
-    player->collider.enabled = true;        // Enable physic object collisions detection
+    // Create rectangle physic object
+    PhysicObject *rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
+    rectangle->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
+    rectangle->rigidbody.applyGravity = true;
+    rectangle->rigidbody.friction = 0.1f;
+    rectangle->rigidbody.bounciness = 6.0f;
     
-    // Player physic object
-    PhysicObject *player2 = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
-    player2->rigidbody.enabled = true;
-    player2->rigidbody.applyGravity = true;
-    player2->rigidbody.friction = 0.1f;
-    player2->collider.enabled = true;
+    // Create square physic object
+    PhysicObject *square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+    square->rigidbody.enabled = true;      // Enable physic object rigidbody behaviour
+    square->rigidbody.applyGravity = true;
+    square->rigidbody.friction = 0.1f;
     
-    // Floor physic object
+    // Create walls physic objects
     PhysicObject *floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
-    floor->collider.enabled = true;         // Enable just physic object collisions detection
-    
-    // Left wall physic object
     PhysicObject *leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    leftWall->collider.enabled = true;
-    
-    // Right wall physic object
     PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    rightWall->collider.enabled = true;
+    PhysicObject *roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
     
-    // Platform physic objectdd
+    // Create pplatform physic object
     PhysicObject *platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
-    platform->collider.enabled = true;
     
     //--------------------------------------------------------------------------------------
 
@@ -68,20 +60,18 @@ int main()
         //----------------------------------------------------------------------------------
         UpdatePhysics();    // Update all created physic objects
         
-        // Check debug switch input
-        if (IsKeyPressed('P')) isDebug = !isDebug;
-        
-        // Check player movement inputs
-        if (IsKeyDown('W') && player->rigidbody.isGrounded) player->rigidbody.velocity.y = JUMP_VELOCITY;
-        
-        if (IsKeyDown('A')) player->rigidbody.velocity.x = -MOVE_VELOCITY;
-        else if (IsKeyDown('D')) player->rigidbody.velocity.x = MOVE_VELOCITY;
+        // Check rectangle movement inputs
+        if (IsKeyDown('W') && rectangle->rigidbody.isGrounded) rectangle->rigidbody.velocity.y = JUMP_VELOCITY;
+        if (IsKeyDown('A')) rectangle->rigidbody.velocity.x = -MOVE_VELOCITY;
+        else if (IsKeyDown('D')) rectangle->rigidbody.velocity.x = MOVE_VELOCITY;
         
         // Check player 2 movement inputs
-        if (IsKeyDown(KEY_UP) && player2->rigidbody.isGrounded) player2->rigidbody.velocity.y = JUMP_VELOCITY;
+        if (IsKeyDown(KEY_UP) && square->rigidbody.isGrounded) square->rigidbody.velocity.y = JUMP_VELOCITY;
+        if (IsKeyDown(KEY_LEFT)) square->rigidbody.velocity.x = -MOVE_VELOCITY;
+        else if (IsKeyDown(KEY_RIGHT)) square->rigidbody.velocity.x = MOVE_VELOCITY;
         
-        if (IsKeyDown(KEY_LEFT)) player2->rigidbody.velocity.x = -MOVE_VELOCITY;
-        else if (IsKeyDown(KEY_RIGHT)) player2->rigidbody.velocity.x = MOVE_VELOCITY;
+        // Check debug switch input
+        if (IsKeyPressed('P')) isDebug = !isDebug;
         //----------------------------------------------------------------------------------
 
         // Draw
@@ -89,29 +79,31 @@ int main()
         BeginDrawing();
 
             ClearBackground(RAYWHITE);
+
+            // Convert transform values to rectangle data type variable
+            DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);
+            DrawRectangleRec(TransformToRectangle(leftWall->transform), DARKGRAY);
+            DrawRectangleRec(TransformToRectangle(rightWall->transform), DARKGRAY);
+            DrawRectangleRec(TransformToRectangle(roof->transform), DARKGRAY);
+            
+            DrawRectangleRec(TransformToRectangle(platform->transform), DARKGRAY);
+            
+            DrawRectangleRec(TransformToRectangle(rectangle->transform), RED);
+            DrawRectangleRec(TransformToRectangle(square->transform), BLUE);
             
             if (isDebug)
             {
                 DrawRectangleLines(floor->collider.bounds.x, floor->collider.bounds.y, floor->collider.bounds.width, floor->collider.bounds.height, GREEN);
                 DrawRectangleLines(leftWall->collider.bounds.x, leftWall->collider.bounds.y, leftWall->collider.bounds.width, leftWall->collider.bounds.height, GREEN);
                 DrawRectangleLines(rightWall->collider.bounds.x, rightWall->collider.bounds.y, rightWall->collider.bounds.width, rightWall->collider.bounds.height, GREEN);
+                DrawRectangleLines(roof->collider.bounds.x, roof->collider.bounds.y, roof->collider.bounds.width, roof->collider.bounds.height, GREEN);
                 DrawRectangleLines(platform->collider.bounds.x, platform->collider.bounds.y, platform->collider.bounds.width, platform->collider.bounds.height, GREEN);
-                DrawRectangleLines(player->collider.bounds.x, player->collider.bounds.y, player->collider.bounds.width, player->collider.bounds.height, GREEN);
-                DrawRectangleLines(player2->collider.bounds.x, player2->collider.bounds.y, player2->collider.bounds.width, player2->collider.bounds.height, GREEN);
-            }
-            else
-            {
-                // Convert transform values to rectangle data type variable
-                DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);
-                DrawRectangleRec(TransformToRectangle(leftWall->transform), DARKGRAY);
-                DrawRectangleRec(TransformToRectangle(rightWall->transform), DARKGRAY);
-                DrawRectangleRec(TransformToRectangle(platform->transform), DARKGRAY);
-                DrawRectangleRec(TransformToRectangle(player->transform), RED);
-                DrawRectangleRec(TransformToRectangle(player2->transform), BLUE);
+                DrawRectangleLines(rectangle->collider.bounds.x, rectangle->collider.bounds.y, rectangle->collider.bounds.width, rectangle->collider.bounds.height, GREEN);
+                DrawRectangleLines(square->collider.bounds.x, square->collider.bounds.y, square->collider.bounds.width, square->collider.bounds.height, GREEN);
             }
             
-            // Draw all physic object information in specific screen position and font size
-            // DrawPhysicObjectInfo(player, (Vector2){ 10.0f, 10.0f }, 10);    
+            // Draw help message
+            DrawText("Use WASD to move rectangle and ARROWS to move square", screenWidth/2 - MeasureText("Use WASD to move rectangle and ARROWS to move square", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
 
         EndDrawing();
         //----------------------------------------------------------------------------------
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
new file mode 100644
index 00000000..2afd14ee
--- /dev/null
+++ b/examples/physics_forces.c
@@ -0,0 +1,160 @@
+/*******************************************************************************************
+*
+*   raylib [physac] example - Forces
+*
+*   This example has been created using raylib 1.5 (www.raylib.com)
+*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
+*
+********************************************************************************************/
+
+#include "raylib.h"
+#include "math.h"
+
+#define FORCE_AMOUNT    5.0f
+#define FORCE_RADIUS    150
+#define LINE_LENGTH     100
+
+int main()
+{
+    // Initialization
+    //--------------------------------------------------------------------------------------
+    int screenWidth = 800;
+    int screenHeight = 450;
+
+    InitWindow(screenWidth, screenHeight, "raylib [physac] example - forces");
+    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
+    
+    SetTargetFPS(60);
+    
+    // Global variables
+    Vector2 mousePosition;
+    bool isDebug = false;
+    
+    // Create rectangle physic objects
+    PhysicObject *rectangles[3];
+    for (int i = 0; i < 3; i++)
+    {
+        rectangles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
+        rectangles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
+        rectangles[i]->rigidbody.friction = 0.1f;
+    }
+    
+    // Create circles physic objects
+    PhysicObject *circles[3];
+    for (int i = 0; i < 3; i++)
+    {
+        circles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
+        circles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
+        circles[i]->rigidbody.friction = 0.1f;
+        circles[i]->collider.type = COLLIDER_CIRCLE;
+        circles[i]->collider.radius = 25;
+    }
+    
+    // Create walls physic objects
+    PhysicObject *leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicObject *topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    PhysicObject *bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    
+    //--------------------------------------------------------------------------------------
+
+    // Main game loop
+    while (!WindowShouldClose())    // Detect window close button or ESC key
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdatePhysics();    // Update all created physic objects
+        
+        // Update mouse position value
+        mousePosition = GetMousePosition();
+        
+        // Check force input
+        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ApplyForceAtPosition(mousePosition, FORCE_AMOUNT, FORCE_RADIUS);
+        
+        // Check reset input
+        if (IsKeyPressed('R'))
+        {
+            // Reset rectangle physic objects positions
+            for (int i = 0; i < 3; i++)
+            {
+                rectangles[i]->transform.position = (Vector2){ screenWidth/4*(i+1) - rectangles[i]->transform.scale.x/2, (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) - rectangles[i]->transform.scale.y/2 };
+                rectangles[i]->rigidbody.velocity =(Vector2){ 0.0f, 0.0f };
+            }
+            
+            // Reset circles physic objects positions
+            for (int i = 0; i < 3; i++)
+            {
+                circles[i]->transform.position = (Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) };
+                circles[i]->rigidbody.velocity =(Vector2){ 0.0f, 0.0f };
+            }
+        }
+        
+        // Check debug switch input
+        if (IsKeyPressed('P')) isDebug = !isDebug;
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+            ClearBackground(RAYWHITE);
+
+            // Draw rectangles
+            for (int i = 0; i < 3; i++)
+            {
+                // Convert transform values to rectangle data type variable
+                DrawRectangleRec(TransformToRectangle(rectangles[i]->transform), RED);
+                if (isDebug) DrawRectangleLines(rectangles[i]->collider.bounds.x, rectangles[i]->collider.bounds.y, rectangles[i]->collider.bounds.width, rectangles[i]->collider.bounds.height, GREEN);
+
+                // Draw force radius
+                DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
+                
+                // Draw direction line
+                if (CheckCollisionPointCircle((Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 }, mousePosition, FORCE_RADIUS))
+                {
+                    Vector2 direction = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 - mousePosition.x, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 - mousePosition.y };
+                    float angle = atan2l(direction.y, direction.x);
+                    
+                    DrawLineV((Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 },
+                    (Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 + (cos(angle)*LINE_LENGTH), rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 + (sin(angle)*LINE_LENGTH) }, BLACK);
+                }
+            }
+            
+            // Draw circles
+            for (int i = 0; i < 3; i++)
+            {
+                DrawCircleV(circles[i]->transform.position, circles[i]->collider.radius, BLUE);
+                if (isDebug) DrawCircleLines(circles[i]->transform.position.x, circles[i]->transform.position.y, circles[i]->collider.radius, GREEN);
+
+                // Draw force radius
+                DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
+                
+                // Draw direction line
+                if (CheckCollisionPointCircle((Vector2){ circles[i]->transform.position.x, circles[i]->transform.position.y }, mousePosition, FORCE_RADIUS))
+                {
+                    Vector2 direction = { circles[i]->transform.position.x - mousePosition.x, circles[i]->transform.position.y - mousePosition.y };
+                    float angle = atan2l(direction.y, direction.x);
+                    
+                    DrawLineV((Vector2){ circles[i]->transform.position.x, circles[i]->transform.position.y },
+                    (Vector2){ circles[i]->transform.position.x + (cos(angle)*LINE_LENGTH), circles[i]->transform.position.y + (sin(angle)*LINE_LENGTH) }, BLACK);
+                }
+            }
+            
+            // Draw help messages
+            DrawText("Use LEFT MOUSE BUTTON to apply a force", screenWidth/2 - MeasureText("Use LEFT MOUSE BUTTON to apply a force", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
+            DrawText("Use R to reset objects position", screenWidth/2 - MeasureText("Use R to reset objects position", 20)/2, screenHeight*0.875f, 20, GRAY);    
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------
+    ClosePhysics();       // Unitialize physics module
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
\ No newline at end of file
-- 
cgit v1.2.3


From 60223a358b691c2769c362597c49e124b045209c Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Wed, 23 Mar 2016 15:50:41 +0100
Subject: Physac redesign (3/3)

Finally, physics update is handled in main thread using steps to get
accuracy in collisions detection instead of moving it to a new thread.

Examples are finished as simple and clear as I could. Finally, physac
module is MORE simpler than in the first version, calculation everything
by the same way for both types of physic objects.

I tryed to add rotated physics a couple of times but I didn't get
anything good to get a base to improve it. Maybe for the next version...

No bugs or strange behaviours found during testing.
---
 examples/physics_basic_rigidbody.c   |   9 ++++---
 examples/physics_basic_rigidbody.png | Bin 18144 -> 15294 bytes
 examples/physics_forces.c            |  40 +++++++++++++++++++++-------
 examples/physics_forces.png          | Bin 0 -> 17935 bytes
 src/physac.c                         |  49 +++++++++++++++++++----------------
 src/physac.h                         |   6 ++---
 src/raylib.h                         |   4 +--
 7 files changed, 68 insertions(+), 40 deletions(-)
 create mode 100644 examples/physics_forces.png

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index f0edba72..917813ad 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -65,7 +65,7 @@ int main()
         if (IsKeyDown('A')) rectangle->rigidbody.velocity.x = -MOVE_VELOCITY;
         else if (IsKeyDown('D')) rectangle->rigidbody.velocity.x = MOVE_VELOCITY;
         
-        // Check player 2 movement inputs
+        // Check square movement inputs
         if (IsKeyDown(KEY_UP) && square->rigidbody.isGrounded) square->rigidbody.velocity.y = JUMP_VELOCITY;
         if (IsKeyDown(KEY_LEFT)) square->rigidbody.velocity.x = -MOVE_VELOCITY;
         else if (IsKeyDown(KEY_RIGHT)) square->rigidbody.velocity.x = MOVE_VELOCITY;
@@ -80,17 +80,20 @@ int main()
 
             ClearBackground(RAYWHITE);
 
-            // Convert transform values to rectangle data type variable
-            DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);
+            // Draw floor, roof and walls rectangles
+            DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);         // Convert transform values to rectangle data type variable
             DrawRectangleRec(TransformToRectangle(leftWall->transform), DARKGRAY);
             DrawRectangleRec(TransformToRectangle(rightWall->transform), DARKGRAY);
             DrawRectangleRec(TransformToRectangle(roof->transform), DARKGRAY);
             
+            // Draw middle platform rectangle
             DrawRectangleRec(TransformToRectangle(platform->transform), DARKGRAY);
             
+            // Draw physic objects
             DrawRectangleRec(TransformToRectangle(rectangle->transform), RED);
             DrawRectangleRec(TransformToRectangle(square->transform), BLUE);
             
+            // Draw collider lines if debug is enabled
             if (isDebug)
             {
                 DrawRectangleLines(floor->collider.bounds.x, floor->collider.bounds.y, floor->collider.bounds.width, floor->collider.bounds.height, GREEN);
diff --git a/examples/physics_basic_rigidbody.png b/examples/physics_basic_rigidbody.png
index 3d691637..52f265ac 100644
Binary files a/examples/physics_basic_rigidbody.png and b/examples/physics_basic_rigidbody.png differ
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 2afd14ee..74b40d57 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -12,9 +12,12 @@
 #include "raylib.h"
 #include "math.h"
 
-#define FORCE_AMOUNT    5.0f
-#define FORCE_RADIUS    150
-#define LINE_LENGTH     100
+#define FORCE_AMOUNT        5.0f
+#define FORCE_RADIUS        150
+#define LINE_LENGTH         75
+#define TRIANGLE_LENGTH     12
+
+void DrawRigidbodyCircle(PhysicObject *obj, Color color);
 
 int main()
 {
@@ -42,6 +45,7 @@ int main()
     }
     
     // Create circles physic objects
+    // NOTE: when creating circle physic objects, transform.scale must be { 0, 0 } and object radius must be defined in collider.radius and use this value to draw the circle.
     PhysicObject *circles[3];
     for (int i = 0; i < 3; i++)
     {
@@ -111,14 +115,23 @@ int main()
                 // Draw force radius
                 DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
                 
-                // Draw direction line
+                // Draw direction lines
                 if (CheckCollisionPointCircle((Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 }, mousePosition, FORCE_RADIUS))
                 {
                     Vector2 direction = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 - mousePosition.x, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 - mousePosition.y };
                     float angle = atan2l(direction.y, direction.x);
                     
-                    DrawLineV((Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 },
-                    (Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 + (cos(angle)*LINE_LENGTH), rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 + (sin(angle)*LINE_LENGTH) }, BLACK);
+                    // Calculate arrow start and end positions
+                    Vector2 startPosition = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 };
+                    Vector2 endPosition = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 + (cos(angle)*LINE_LENGTH), rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 + (sin(angle)*LINE_LENGTH) };
+                    
+                    // Draw arrow line
+                    DrawLineV(startPosition, endPosition, BLACK);
+                    
+                    // Draw arrow triangle
+                    DrawTriangleLines((Vector2){ endPosition.x - cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y - sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
+                                      (Vector2){ endPosition.x + cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y + sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
+                                      (Vector2){ endPosition.x + cos(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2, endPosition.y + sin(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2 }, BLACK);
                 }
             }
             
@@ -131,14 +144,23 @@ int main()
                 // Draw force radius
                 DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
                 
-                // Draw direction line
+                // Draw direction lines
                 if (CheckCollisionPointCircle((Vector2){ circles[i]->transform.position.x, circles[i]->transform.position.y }, mousePosition, FORCE_RADIUS))
                 {
                     Vector2 direction = { circles[i]->transform.position.x - mousePosition.x, circles[i]->transform.position.y - mousePosition.y };
                     float angle = atan2l(direction.y, direction.x);
                     
-                    DrawLineV((Vector2){ circles[i]->transform.position.x, circles[i]->transform.position.y },
-                    (Vector2){ circles[i]->transform.position.x + (cos(angle)*LINE_LENGTH), circles[i]->transform.position.y + (sin(angle)*LINE_LENGTH) }, BLACK);
+                    // Calculate arrow start and end positions
+                    Vector2 startPosition = { circles[i]->transform.position.x, circles[i]->transform.position.y };
+                    Vector2 endPosition = { circles[i]->transform.position.x + (cos(angle)*LINE_LENGTH), circles[i]->transform.position.y + (sin(angle)*LINE_LENGTH) };
+                    
+                    // Draw arrow line
+                    DrawLineV(startPosition, endPosition, BLACK);
+                    
+                    // Draw arrow triangle
+                    DrawTriangleLines((Vector2){ endPosition.x - cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y - sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
+                                      (Vector2){ endPosition.x + cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y + sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
+                                      (Vector2){ endPosition.x + cos(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2, endPosition.y + sin(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2 }, BLACK);
                 }
             }
             
diff --git a/examples/physics_forces.png b/examples/physics_forces.png
new file mode 100644
index 00000000..832bdbd9
Binary files /dev/null and b/examples/physics_forces.png differ
diff --git a/src/physac.c b/src/physac.c
index 718a06bb..e3f956ba 100644
--- a/src/physac.c
+++ b/src/physac.c
@@ -2,7 +2,7 @@
 *
 *   [physac] raylib physics module - Basic functions to apply physics to 2D objects
 *
-*   Copyright (c) 2015 Victor Fisac and Ramon Santamaria
+*   Copyright (c) 2016 Victor Fisac and Ramon Santamaria
 *
 *   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.
@@ -75,10 +75,7 @@ void InitPhysics(Vector2 gravity)
 void UpdatePhysics()
 {
     // Reset all physic objects is grounded state
-    for (int i = 0; i < physicObjectsCount; i++)
-    {
-        if (physicObjects[i]->rigidbody.enabled) physicObjects[i]->rigidbody.isGrounded = false;
-    }
+    for (int i = 0; i < physicObjectsCount; i++) physicObjects[i]->rigidbody.isGrounded = false;
     
     for (int steps = 0; steps < PHYSICS_STEPS; steps++)
     {
@@ -537,26 +534,32 @@ void ApplyForceAtPosition(Vector2 position, float force, float radius)
 {
     for(int i = 0; i < physicObjectsCount; i++)
     {
-        // Calculate direction and distance between force and physic object pposition
-        Vector2 distance = (Vector2){ physicObjects[i]->transform.position.x - position.x, physicObjects[i]->transform.position.y - position.y };
-
-        if(physicObjects[i]->collider.type == COLLIDER_RECTANGLE)
+        if(physicObjects[i]->rigidbody.enabled)
         {
-            distance.x += physicObjects[i]->transform.scale.x/2;
-            distance.y += physicObjects[i]->transform.scale.y/2;
-        }
-        
-        float distanceLength = Vector2Length(distance);
-        
-        // Check if physic object is in force range
-        if(distanceLength <= radius)
-        {
-            // Normalize force direction
-            distance.x /= distanceLength;
-            distance.y /= -distanceLength;
+            // Calculate direction and distance between force and physic object pposition
+            Vector2 distance = (Vector2){ physicObjects[i]->transform.position.x - position.x, physicObjects[i]->transform.position.y - position.y };
+
+            if(physicObjects[i]->collider.type == COLLIDER_RECTANGLE)
+            {
+                distance.x += physicObjects[i]->transform.scale.x/2;
+                distance.y += physicObjects[i]->transform.scale.y/2;
+            }
+            
+            float distanceLength = Vector2Length(distance);
             
-            // Apply force to the physic object
-            ApplyForce(physicObjects[i], (Vector2){ distance.x*force, distance.y*force });
+            // Check if physic object is in force range
+            if(distanceLength <= radius)
+            {
+                // Normalize force direction
+                distance.x /= distanceLength;
+                distance.y /= -distanceLength;
+                
+                // Calculate final force
+                Vector2 finalForce = { distance.x*force, distance.y*force };
+                
+                // Apply force to the physic object
+                ApplyForce(physicObjects[i], finalForce);
+            }
         }
     }
 }
diff --git a/src/physac.h b/src/physac.h
index c70dbbe2..37544686 100644
--- a/src/physac.h
+++ b/src/physac.h
@@ -2,7 +2,7 @@
 *
 *   [physac] raylib physics module - Basic functions to apply physics to 2D objects
 *
-*   Copyright (c) 2015 Victor Fisac and Ramon Santamaria
+*   Copyright (c) 2016 Victor Fisac and Ramon Santamaria
 *
 *   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.
@@ -44,8 +44,8 @@ typedef enum { COLLIDER_CIRCLE, COLLIDER_RECTANGLE } ColliderType;
 
 typedef struct Transform {
     Vector2 position;
-    float rotation;
-    Vector2 scale;
+    float rotation;         // Radians (not used)
+    Vector2 scale;          // Just for rectangle physic objects, for circle physic objects use collider radius and keep scale as { 0, 0 }
 } Transform;
 
 typedef struct Rigidbody {
diff --git a/src/raylib.h b/src/raylib.h
index a87b58da..1782fef3 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -498,8 +498,8 @@ typedef enum { COLLIDER_CIRCLE, COLLIDER_RECTANGLE } ColliderType;
 
 typedef struct Transform {
     Vector2 position;
-    float rotation;
-    Vector2 scale;
+    float rotation;         // Radians (not used)
+    Vector2 scale;          // Just for rectangle physic objects, for circle physic objects use collider radius and keep scale as { 0, 0 }
 } Transform;
 
 typedef struct Rigidbody {
-- 
cgit v1.2.3


From c9e30f77540e9693ddecffc353964eb71e854842 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Fri, 20 May 2016 10:53:31 +0200
Subject: Review struct typedef to avoid pointers for users

---
 examples/physics_basic_rigidbody.c | 17 +++++++++--------
 examples/physics_forces.c          | 14 +++++++-------
 src/physac.c                       | 12 ++++++------
 src/raylib.h                       | 12 ++++++------
 4 files changed, 28 insertions(+), 27 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 917813ad..cd09f070 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -30,26 +30,26 @@ int main()
     bool isDebug = false;
     
     // Create rectangle physic object
-    PhysicObject *rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
+    PhysicObject rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
     rectangle->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
     rectangle->rigidbody.applyGravity = true;
     rectangle->rigidbody.friction = 0.1f;
     rectangle->rigidbody.bounciness = 6.0f;
     
     // Create square physic object
-    PhysicObject *square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+    PhysicObject square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
     square->rigidbody.enabled = true;      // Enable physic object rigidbody behaviour
     square->rigidbody.applyGravity = true;
     square->rigidbody.friction = 0.1f;
     
     // Create walls physic objects
-    PhysicObject *floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
-    PhysicObject *leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicObject *roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+    PhysicObject floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+    PhysicObject leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    PhysicObject roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
     
     // Create pplatform physic object
-    PhysicObject *platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
+    PhysicObject platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
     
     //--------------------------------------------------------------------------------------
 
@@ -114,7 +114,8 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
-    ClosePhysics();       // Unitialize physics module
+    ClosePhysics();       // Unitialize physics (including all loaded objects)
+    
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 74b40d57..f4eefa05 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -17,7 +17,7 @@
 #define LINE_LENGTH         75
 #define TRIANGLE_LENGTH     12
 
-void DrawRigidbodyCircle(PhysicObject *obj, Color color);
+void DrawRigidbodyCircle(PhysicObject obj, Color color);
 
 int main()
 {
@@ -36,7 +36,7 @@ int main()
     bool isDebug = false;
     
     // Create rectangle physic objects
-    PhysicObject *rectangles[3];
+    PhysicObject rectangles[3];
     for (int i = 0; i < 3; i++)
     {
         rectangles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
@@ -46,7 +46,7 @@ int main()
     
     // Create circles physic objects
     // NOTE: when creating circle physic objects, transform.scale must be { 0, 0 } and object radius must be defined in collider.radius and use this value to draw the circle.
-    PhysicObject *circles[3];
+    PhysicObject circles[3];
     for (int i = 0; i < 3; i++)
     {
         circles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
@@ -57,10 +57,10 @@ int main()
     }
     
     // Create walls physic objects
-    PhysicObject *leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicObject *rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicObject *topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
-    PhysicObject *bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    PhysicObject leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicObject topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    PhysicObject bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
     
     //--------------------------------------------------------------------------------------
 
diff --git a/src/physac.c b/src/physac.c
index ed707474..181488ac 100644
--- a/src/physac.c
+++ b/src/physac.c
@@ -49,7 +49,7 @@
 //----------------------------------------------------------------------------------
 // Global Variables Definition
 //----------------------------------------------------------------------------------
-static PhysicObject *physicObjects[MAX_PHYSIC_OBJECTS];             // Physic objects pool
+static PhysicObject physicObjects[MAX_PHYSIC_OBJECTS];              // Physic objects pool
 static int physicObjectsCount;                                      // Counts current enabled physic objects
 static Vector2 gravityForce;                                        // Gravity force
 
@@ -463,10 +463,10 @@ void ClosePhysics()
 }
 
 // Create a new physic object dinamically, initialize it and add to pool
-PhysicObject *CreatePhysicObject(Vector2 position, float rotation, Vector2 scale)
+PhysicObject CreatePhysicObject(Vector2 position, float rotation, Vector2 scale)
 {
     // Allocate dynamic memory
-    PhysicObject *obj = (PhysicObject *)malloc(sizeof(PhysicObject));
+    PhysicObject obj = (PhysicObject)malloc(sizeof(PhysicObjectData));
     
     // Initialize physic object values with generic values
     obj->id = physicObjectsCount;
@@ -498,7 +498,7 @@ PhysicObject *CreatePhysicObject(Vector2 position, float rotation, Vector2 scale
 }
 
 // Destroy a specific physic object and take it out of the list
-void DestroyPhysicObject(PhysicObject *pObj)
+void DestroyPhysicObject(PhysicObject pObj)
 {
     // Free dynamic memory allocation
     free(physicObjects[pObj->id]);
@@ -520,7 +520,7 @@ void DestroyPhysicObject(PhysicObject *pObj)
 }
 
 // Apply directional force to a physic object
-void ApplyForce(PhysicObject *pObj, Vector2 force)
+void ApplyForce(PhysicObject pObj, Vector2 force)
 {
     if (pObj->rigidbody.enabled)
     {
@@ -571,7 +571,7 @@ Rectangle TransformToRectangle(Transform transform)
 }
 
 // Draw physic object information at screen position
-void DrawPhysicObjectInfo(PhysicObject *pObj, Vector2 position, int fontSize)
+void DrawPhysicObjectInfo(PhysicObject pObj, Vector2 position, int fontSize)
 {
     // Draw physic object ID
     DrawText(FormatText("PhysicObject ID: %i - Enabled: %i", pObj->id, pObj->enabled), position.x, position.y, fontSize, BLACK);
diff --git a/src/raylib.h b/src/raylib.h
index 32cd54a6..fc1914bb 100644
--- a/src/raylib.h
+++ b/src/raylib.h
@@ -535,13 +535,13 @@ typedef struct Collider {
     int radius;             // Used for COLLIDER_CIRCLE
 } Collider;
 
-typedef struct PhysicObject {
+typedef struct PhysicObjectData {
     unsigned int id;
     Transform transform;
     Rigidbody rigidbody;
     Collider collider;
     bool enabled;
-} PhysicObject;
+} PhysicObjectData, *PhysicObject;
 
 #ifdef __cplusplus
 extern "C" {            // Prevents name mangling of functions
@@ -856,14 +856,14 @@ void InitPhysics(Vector2 gravity);
 void UpdatePhysics();                                                                   // Update physic objects, calculating physic behaviours and collisions detection
 void ClosePhysics();                                                                    // Unitialize all physic objects and empty the objects pool
 
-PhysicObject *CreatePhysicObject(Vector2 position, float rotation, Vector2 scale);      // Create a new physic object dinamically, initialize it and add to pool
-void DestroyPhysicObject(PhysicObject *pObj);                                           // Destroy a specific physic object and take it out of the list
+PhysicObject CreatePhysicObject(Vector2 position, float rotation, Vector2 scale);       // Create a new physic object dinamically, initialize it and add to pool
+void DestroyPhysicObject(PhysicObject pObj);                                            // Destroy a specific physic object and take it out of the list
 
-void ApplyForce(PhysicObject *pObj, Vector2 force);                                     // Apply directional force to a physic object
+void ApplyForce(PhysicObject pObj, Vector2 force);                                      // Apply directional force to a physic object
 void ApplyForceAtPosition(Vector2 position, float force, float radius);                 // Apply radial force to all physic objects in range
 
 Rectangle TransformToRectangle(Transform transform);                                    // Convert Transform data type to Rectangle (position and scale)
-void DrawPhysicObjectInfo(PhysicObject *pObj, Vector2 position, int fontSize);          // Draw physic object information at screen position
+void DrawPhysicObjectInfo(PhysicObject pObj, Vector2 position, int fontSize);           // Draw physic object information at screen position
 
 //------------------------------------------------------------------------------------
 // Audio Loading and Playing Functions (Module: audio)
-- 
cgit v1.2.3


From 3c1be60c6615fdcf8d2e3ddec2c9d7de8174b280 Mon Sep 17 00:00:00 2001
From: raysan5 <raysan5@gmail.com>
Date: Thu, 9 Jun 2016 20:02:42 +0200
Subject: Updated examples for new physac header-only

---
 examples/physics_basic_rigidbody.c | 21 ++++++++++++---------
 examples/physics_forces.c          | 27 ++++++++++++++-------------
 2 files changed, 26 insertions(+), 22 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index cd09f070..8870c55b 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -11,6 +11,9 @@
 
 #include "raylib.h"
 
+#define PHYSAC_IMPLEMENTATION
+#include "physac.h"
+
 #define MOVE_VELOCITY    5
 #define JUMP_VELOCITY    30
 
@@ -22,35 +25,35 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
-    SetTargetFPS(60);
+    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Debug variables
     bool isDebug = false;
     
     // Create rectangle physic object
-    PhysicObject rectangle = CreatePhysicObject((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
+    PhysicBody rectangle = CreatePhysicBody((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
     rectangle->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
     rectangle->rigidbody.applyGravity = true;
     rectangle->rigidbody.friction = 0.1f;
     rectangle->rigidbody.bounciness = 6.0f;
     
     // Create square physic object
-    PhysicObject square = CreatePhysicObject((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
+    PhysicBody square = CreatePhysicBody((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
     square->rigidbody.enabled = true;      // Enable physic object rigidbody behaviour
     square->rigidbody.applyGravity = true;
     square->rigidbody.friction = 0.1f;
     
     // Create walls physic objects
-    PhysicObject floor = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
-    PhysicObject leftWall = CreatePhysicObject((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicObject roof = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+    PhysicBody floor = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
+    PhysicBody leftWall = CreatePhysicBody((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    PhysicBody rightWall = CreatePhysicBody((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
+    PhysicBody roof = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
     
     // Create pplatform physic object
-    PhysicObject platform = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
+    PhysicBody platform = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
     
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index f4eefa05..3e90a21d 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -10,15 +10,15 @@
 ********************************************************************************************/
 
 #include "raylib.h"
-#include "math.h"
+
+#define PHYSAC_IMPLEMENTATION
+#include "physac.h"
 
 #define FORCE_AMOUNT        5.0f
 #define FORCE_RADIUS        150
 #define LINE_LENGTH         75
 #define TRIANGLE_LENGTH     12
 
-void DrawRigidbodyCircle(PhysicObject obj, Color color);
-
 int main()
 {
     // Initialization
@@ -27,29 +27,28 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - forces");
-    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
-    SetTargetFPS(60);
+    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Global variables
     Vector2 mousePosition;
     bool isDebug = false;
     
     // Create rectangle physic objects
-    PhysicObject rectangles[3];
+    PhysicBody rectangles[3];
     for (int i = 0; i < 3; i++)
     {
-        rectangles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
+        rectangles[i] = CreatePhysicBody((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
         rectangles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
         rectangles[i]->rigidbody.friction = 0.1f;
     }
     
     // Create circles physic objects
     // NOTE: when creating circle physic objects, transform.scale must be { 0, 0 } and object radius must be defined in collider.radius and use this value to draw the circle.
-    PhysicObject circles[3];
+    PhysicBody circles[3];
     for (int i = 0; i < 3; i++)
     {
-        circles[i] = CreatePhysicObject((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
+        circles[i] = CreatePhysicBody((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
         circles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
         circles[i]->rigidbody.friction = 0.1f;
         circles[i]->collider.type = COLLIDER_CIRCLE;
@@ -57,11 +56,12 @@ int main()
     }
     
     // Create walls physic objects
-    PhysicObject leftWall = CreatePhysicObject((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicObject rightWall = CreatePhysicObject((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicObject topWall = CreatePhysicObject((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
-    PhysicObject bottomWall = CreatePhysicObject((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    PhysicBody leftWall = CreatePhysicBody((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicBody rightWall = CreatePhysicBody((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
+    PhysicBody topWall = CreatePhysicBody((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
+    PhysicBody bottomWall = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
     
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop
@@ -175,6 +175,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------
     ClosePhysics();       // Unitialize physics module
+    
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
-- 
cgit v1.2.3


From 4c43a407888d516b38191b5df76e373dae6ec58e Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Sat, 11 Jun 2016 19:11:30 +0200
Subject: Update physac examples with fixed timestep method

---
 examples/physics_basic_rigidbody.c | 32 ++++++++++++++++++++++++++++++--
 examples/physics_forces.c          | 30 +++++++++++++++++++++++++++++-
 2 files changed, 59 insertions(+), 3 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 8870c55b..24570426 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -13,10 +13,13 @@
 
 #define PHYSAC_IMPLEMENTATION
 #include "physac.h"
+#include <pthread.h>
 
 #define MOVE_VELOCITY    5
 #define JUMP_VELOCITY    30
 
+void* PhysicsThread(void *arg);
+
 int main()
 {
     // Initialization
@@ -53,6 +56,10 @@ int main()
     // Create pplatform physic object
     PhysicBody platform = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
     
+    // Create physics thread
+    pthread_t tid;
+    pthread_create(&tid, NULL, &PhysicsThread, NULL);
+    
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
@@ -61,10 +68,9 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        UpdatePhysics();    // Update all created physic objects
         
         // Check rectangle movement inputs
-        if (IsKeyDown('W') && rectangle->rigidbody.isGrounded) rectangle->rigidbody.velocity.y = JUMP_VELOCITY;
+        if (IsKeyPressed('W')) rectangle->rigidbody.velocity.y = JUMP_VELOCITY;
         if (IsKeyDown('A')) rectangle->rigidbody.velocity.x = -MOVE_VELOCITY;
         else if (IsKeyDown('D')) rectangle->rigidbody.velocity.x = MOVE_VELOCITY;
         
@@ -117,10 +123,32 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
+    pthread_cancel(tid);    // Destroy physics thread
+    
     ClosePhysics();       // Unitialize physics (including all loaded objects)
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;
+}
+
+void* PhysicsThread(void *arg)
+{
+    // Initialize time variables
+    double currentTime = GetTime();
+    double previousTime = currentTime;
+    
+    // Physics update loop
+    while (!WindowShouldClose()) 
+    {
+        currentTime = GetTime();
+        double deltaTime = (double)(currentTime - previousTime);
+        previousTime = currentTime;
+
+        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
+        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
+    }
+    
+    return NULL;
 }
\ No newline at end of file
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 3e90a21d..397c2331 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -13,12 +13,15 @@
 
 #define PHYSAC_IMPLEMENTATION
 #include "physac.h"
+#include <pthread.h>
 
 #define FORCE_AMOUNT        5.0f
 #define FORCE_RADIUS        150
 #define LINE_LENGTH         75
 #define TRIANGLE_LENGTH     12
 
+void* PhysicsThread(void *arg);
+
 int main()
 {
     // Initialization
@@ -61,6 +64,10 @@ int main()
     PhysicBody topWall = CreatePhysicBody((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
     PhysicBody bottomWall = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
     
+    // Create physics thread
+    pthread_t tid;
+    pthread_create(&tid, NULL, &PhysicsThread, NULL);
+    
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
@@ -69,7 +76,6 @@ int main()
     {
         // Update
         //----------------------------------------------------------------------------------
-        UpdatePhysics();    // Update all created physic objects
         
         // Update mouse position value
         mousePosition = GetMousePosition();
@@ -174,10 +180,32 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------
+    pthread_cancel(tid);    // Destroy physics thread
+    
     ClosePhysics();       // Unitialize physics module
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;
+}
+
+void* PhysicsThread(void *arg)
+{
+    // Initialize time variables
+    double currentTime = GetTime();
+    double previousTime = currentTime;
+    
+    // Physics update loop
+    while (!WindowShouldClose()) 
+    {
+        currentTime = GetTime();
+        double deltaTime = (double)(currentTime - previousTime);
+        previousTime = currentTime;
+
+        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
+        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
+    }
+    
+    return NULL;
 }
\ No newline at end of file
-- 
cgit v1.2.3


From 6a2bbae5216e66e5581d697998efe135ad826c50 Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Sun, 12 Jun 2016 22:07:36 +0200
Subject: Updated physics examples with new module changes

---
 examples/physics_basic_rigidbody.c | 32 +-------------------------------
 examples/physics_forces.c          | 33 +--------------------------------
 2 files changed, 2 insertions(+), 63 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 24570426..811ab982 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -13,12 +13,10 @@
 
 #define PHYSAC_IMPLEMENTATION
 #include "physac.h"
-#include <pthread.h>
 
 #define MOVE_VELOCITY    5
 #define JUMP_VELOCITY    30
 
-void* PhysicsThread(void *arg);
 
 int main()
 {
@@ -28,7 +26,6 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    
     InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Debug variables
@@ -56,10 +53,6 @@ int main()
     // Create pplatform physic object
     PhysicBody platform = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
     
-    // Create physics thread
-    pthread_t tid;
-    pthread_create(&tid, NULL, &PhysicsThread, NULL);
-    
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
@@ -122,33 +115,10 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------
-    pthread_cancel(tid);    // Destroy physics thread
-    
+    //--------------------------------------------------------------------------------------    
     ClosePhysics();       // Unitialize physics (including all loaded objects)
-    
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;
-}
-
-void* PhysicsThread(void *arg)
-{
-    // Initialize time variables
-    double currentTime = GetTime();
-    double previousTime = currentTime;
-    
-    // Physics update loop
-    while (!WindowShouldClose()) 
-    {
-        currentTime = GetTime();
-        double deltaTime = (double)(currentTime - previousTime);
-        previousTime = currentTime;
-
-        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
-        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
-    }
-    
-    return NULL;
 }
\ No newline at end of file
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 397c2331..28566753 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -13,15 +13,12 @@
 
 #define PHYSAC_IMPLEMENTATION
 #include "physac.h"
-#include <pthread.h>
 
 #define FORCE_AMOUNT        5.0f
 #define FORCE_RADIUS        150
 #define LINE_LENGTH         75
 #define TRIANGLE_LENGTH     12
 
-void* PhysicsThread(void *arg);
-
 int main()
 {
     // Initialization
@@ -30,7 +27,6 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - forces");
-    
     InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Global variables
@@ -64,10 +60,6 @@ int main()
     PhysicBody topWall = CreatePhysicBody((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
     PhysicBody bottomWall = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
     
-    // Create physics thread
-    pthread_t tid;
-    pthread_create(&tid, NULL, &PhysicsThread, NULL);
-    
     SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
@@ -179,33 +171,10 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------
-    pthread_cancel(tid);    // Destroy physics thread
-    
+    //--------------------------------------------------------------------------------------    
     ClosePhysics();       // Unitialize physics module
-    
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 
     return 0;
-}
-
-void* PhysicsThread(void *arg)
-{
-    // Initialize time variables
-    double currentTime = GetTime();
-    double previousTime = currentTime;
-    
-    // Physics update loop
-    while (!WindowShouldClose()) 
-    {
-        currentTime = GetTime();
-        double deltaTime = (double)(currentTime - previousTime);
-        previousTime = currentTime;
-
-        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
-        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
-    }
-    
-    return NULL;
 }
\ No newline at end of file
-- 
cgit v1.2.3


From 54537e8f0b57df2f3f15d8e46309672f46e4775a Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Tue, 14 Jun 2016 20:23:46 +0200
Subject: Fixed bug in delta time calculation...

and added PHYSAC_NO_THREADS define. Improved physac example drawing
frames per second in screen.
---
 examples/physics_basic_rigidbody.c |  2 ++
 examples/physics_forces.c          |  4 +++-
 src/physac.h                       | 26 ++++++++++++++++----------
 3 files changed, 21 insertions(+), 11 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 811ab982..5223f46a 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -110,6 +110,8 @@ int main()
             // Draw help message
             DrawText("Use WASD to move rectangle and ARROWS to move square", screenWidth/2 - MeasureText("Use WASD to move rectangle and ARROWS to move square", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
 
+            DrawFPS(10, 10);
+            
         EndDrawing();
         //----------------------------------------------------------------------------------
     }
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 28566753..87510552 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -164,7 +164,9 @@ int main()
             
             // Draw help messages
             DrawText("Use LEFT MOUSE BUTTON to apply a force", screenWidth/2 - MeasureText("Use LEFT MOUSE BUTTON to apply a force", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
-            DrawText("Use R to reset objects position", screenWidth/2 - MeasureText("Use R to reset objects position", 20)/2, screenHeight*0.875f, 20, GRAY);    
+            DrawText("Use R to reset objects position", screenWidth/2 - MeasureText("Use R to reset objects position", 20)/2, screenHeight*0.875f, 20, GRAY);
+            
+            DrawFPS(10, 10);
 
         EndDrawing();
         //----------------------------------------------------------------------------------
diff --git a/src/physac.h b/src/physac.h
index ea8801c3..5ce3970e 100644
--- a/src/physac.h
+++ b/src/physac.h
@@ -178,8 +178,10 @@ PHYSACDEF Rectangle TransformToRectangle(Transform transform);
 
 #include <math.h>           // Required for: cos(), sin(), abs(), fminf()
 #include <stdint.h>         // Required for typedef unsigned long long int uint64_t, used by hi-res timer
-#include <pthread.h>        // Required for: pthread_create()
-#include "utils.h"          // Required for: TraceLog()
+
+#ifndef PHYSAC_NO_THREADS
+    #include <pthread.h>        // Required for: pthread_create()
+#endif
 
 #if defined(PLATFORM_DESKTOP)
     // Functions required to query time on Windows
@@ -234,9 +236,11 @@ PHYSACDEF void InitPhysics(Vector2 gravity)
     physicBodiesCount = 0;
     gravityForce = gravity;
     
-    // Create physics thread
-    pthread_t tid;
-    pthread_create(&tid, NULL, &PhysicsThread, NULL);
+    #ifndef PHYSAC_NO_THREADS       // NOTE: if defined, user will need to create a thread for PhysicsThread function manually
+        // Create physics thread
+        pthread_t tid;
+        pthread_create(&tid, NULL, &PhysicsThread, NULL);
+    #endif
 }
 
 // Update physic objects, calculating physic behaviours and collisions detection
@@ -768,7 +772,6 @@ static void InitTimer(void)
     {
         baseTime = (uint64_t)now.tv_sec*1000000000LLU + (uint64_t)now.tv_nsec;
     }
-    else TraceLog(WARNING, "No hi-resolution timer available");
 #endif
 
     previousTime = GetCurrentTime();       // Get time as double
@@ -777,22 +780,25 @@ static void InitTimer(void)
 // Time measure returned are microseconds
 static double GetCurrentTime(void)
 {
+    double time;
+    
 #if defined(PLATFORM_DESKTOP)
     unsigned long long int clockFrequency, currentTime;
     
     QueryPerformanceFrequency(&clockFrequency);
     QueryPerformanceCounter(&currentTime);
-
-    return (double)(currentTime/clockFrequency);
+    
 #endif
 
 #if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI)
     struct timespec ts;
     clock_gettime(CLOCK_MONOTONIC, &ts);
-    uint64_t time = (uint64_t)ts.tv_sec*1000000000LLU + (uint64_t)ts.tv_nsec;
+    uint64_t temp = (uint64_t)ts.tv_sec*1000000000LLU + (uint64_t)ts.tv_nsec;
 
-    return (double)(time - baseTime)*1e-9;
+    time = (double)(temp - baseTime)*1e-9;
 #endif
+
+    return time;
 }
 
 // Returns the dot product of two Vector2
-- 
cgit v1.2.3


From 1a8fbe5cf0b982cf74434f1ba4654fced71a0450 Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Tue, 14 Jun 2016 20:31:48 +0200
Subject: Add pthread external library to source...

and add instructions in physac examples to run it successful.
---
 .gitignore                          |   3 ++-
 examples/physics_basic_rigidbody.c  |   4 ++++
 examples/physics_forces.c           |   5 +++++
 src/external/pthread/pthreadGC2.dll | Bin 0 -> 119888 bytes
 4 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 src/external/pthread/pthreadGC2.dll

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/.gitignore b/.gitignore
index b221a37b..cf9cdfe1 100644
--- a/.gitignore
+++ b/.gitignore
@@ -72,4 +72,5 @@ src/libraylib.bc
 # external libraries DLLs
 !src/external/glfw3/lib/win32/glfw3.dll
 !src/external/openal_soft/lib/win32/OpenAL32.dll
-!src/external/OculusSDK/LibOVR/LibOVRRT32_1.dll
\ No newline at end of file
+!src/external/OculusSDK/LibOVR/LibOVRRT32_1.dll
+!src/external/pthread/pthreadGC2.dll
\ No newline at end of file
diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 5223f46a..b85f7543 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -5,6 +5,10 @@
 *   This example has been created using raylib 1.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
+*
+*   Compile example using:
+*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 87510552..7de85483 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -5,6 +5,11 @@
 *   This example has been created using raylib 1.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
+*   NOTE: This example requires raylib module [rlgl]
+*
+*   Compile example using:
+*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
diff --git a/src/external/pthread/pthreadGC2.dll b/src/external/pthread/pthreadGC2.dll
new file mode 100644
index 00000000..67b9289d
Binary files /dev/null and b/src/external/pthread/pthreadGC2.dll differ
-- 
cgit v1.2.3


From 4e84ded7ef3b165081e08a83d95bf54387a413ca Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Tue, 14 Jun 2016 20:38:49 +0200
Subject: Fixed spacing and set UpdatePhysics() function as static...

and remove static from PhysicsThread().
---
 examples/physics_basic_rigidbody.c |   8 +-
 examples/physics_forces.c          |   2 +-
 src/physac.h                       | 418 ++++++++++++++++++-------------------
 3 files changed, 213 insertions(+), 215 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index b85f7543..084bfb0e 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -21,7 +21,6 @@
 #define MOVE_VELOCITY    5
 #define JUMP_VELOCITY    30
 
-
 int main()
 {
     // Initialization
@@ -30,7 +29,7 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
+    // InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Debug variables
     bool isDebug = false;
@@ -64,8 +63,7 @@ int main()
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
         // Update
-        //----------------------------------------------------------------------------------
-        
+        //----------------------------------------------------------------------------------        
         // Check rectangle movement inputs
         if (IsKeyPressed('W')) rectangle->rigidbody.velocity.y = JUMP_VELOCITY;
         if (IsKeyDown('A')) rectangle->rigidbody.velocity.x = -MOVE_VELOCITY;
@@ -121,7 +119,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------    
+    //--------------------------------------------------------------------------------------
     ClosePhysics();       // Unitialize physics (including all loaded objects)
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index 7de85483..efe8e240 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -178,7 +178,7 @@ int main()
     }
 
     // De-Initialization
-    //--------------------------------------------------------------------------------------    
+    //--------------------------------------------------------------------------------------
     ClosePhysics();       // Unitialize physics module
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
diff --git a/src/physac.h b/src/physac.h
index 4f9b736f..b8cc8f15 100644
--- a/src/physac.h
+++ b/src/physac.h
@@ -146,7 +146,7 @@ typedef struct PhysicBodyData {
 // Module Functions Declaration
 //----------------------------------------------------------------------------------
 PHYSACDEF void InitPhysics(Vector2 gravity);                                            // Initializes pointers array (just pointers, fixed size)
-PHYSACDEF void UpdatePhysics(double deltaTime);                                         // Update physic objects, calculating physic behaviours and collisions detection
+PHYSACDEF void* PhysicsThread(void *arg);                                               // Physics calculations thread function
 PHYSACDEF void ClosePhysics();                                                          // Unitialize all physic objects and empty the objects pool
 
 PHYSACDEF PhysicBody CreatePhysicBody(Vector2 position, float rotation, Vector2 scale); // Create a new physic body dinamically, initialize it and add to pool
@@ -219,7 +219,7 @@ static Vector2 gravityForce;                                        // Gravity f
 //----------------------------------------------------------------------------------
 // Module specific Functions Declaration
 //----------------------------------------------------------------------------------
-static void* PhysicsThread(void *arg);                              // Physics calculations thread function
+static void UpdatePhysics(double deltaTime);                        // Update physic objects, calculating physic behaviours and collisions detection
 static void InitTimer(void);                                        // Initialize hi-resolution timer
 static double GetCurrentTime(void);                                 // Time measure returned are microseconds
 static float Vector2DotProduct(Vector2 v1, Vector2 v2);             // Returns the dot product of two Vector2
@@ -243,8 +243,214 @@ PHYSACDEF void InitPhysics(Vector2 gravity)
     #endif
 }
 
+// Unitialize all physic objects and empty the objects pool
+PHYSACDEF void ClosePhysics()
+{
+    // Exit physics thread loop
+    physicsThreadEnabled = false;
+    
+    // Free all dynamic memory allocations
+    for (int i = 0; i < physicBodiesCount; i++) PHYSAC_FREE(physicBodies[i]);
+    
+    // Reset enabled physic objects count
+    physicBodiesCount = 0;
+}
+
+// Create a new physic body dinamically, initialize it and add to pool
+PHYSACDEF PhysicBody CreatePhysicBody(Vector2 position, float rotation, Vector2 scale)
+{
+    // Allocate dynamic memory
+    PhysicBody obj = (PhysicBody)PHYSAC_MALLOC(sizeof(PhysicBodyData));
+    
+    // Initialize physic body values with generic values
+    obj->id = physicBodiesCount;
+    obj->enabled = true;
+    
+    obj->transform = (Transform){ (Vector2){ position.x - scale.x/2, position.y - scale.y/2 }, rotation, scale };
+    
+    obj->rigidbody.enabled = false;
+    obj->rigidbody.mass = 1.0f;
+    obj->rigidbody.acceleration = (Vector2){ 0.0f, 0.0f };
+    obj->rigidbody.velocity = (Vector2){ 0.0f, 0.0f };
+    obj->rigidbody.applyGravity = false;
+    obj->rigidbody.isGrounded = false;
+    obj->rigidbody.friction = 0.0f;
+    obj->rigidbody.bounciness = 0.0f;
+    
+    obj->collider.enabled = true;
+    obj->collider.type = COLLIDER_RECTANGLE;
+    obj->collider.bounds = TransformToRectangle(obj->transform);
+    obj->collider.radius = 0.0f;
+    
+    // Add new physic body to the pointers array
+    physicBodies[physicBodiesCount] = obj;
+    
+    // Increase enabled physic bodies count
+    physicBodiesCount++;
+    
+    return obj;
+}
+
+// Destroy a specific physic body and take it out of the list
+PHYSACDEF void DestroyPhysicBody(PhysicBody pbody)
+{
+    // Free dynamic memory allocation
+    PHYSAC_FREE(physicBodies[pbody->id]);
+    
+    // Remove *obj from the pointers array
+    for (int i = pbody->id; i < physicBodiesCount; i++)
+    {
+        // Resort all the following pointers of the array
+        if ((i + 1) < physicBodiesCount)
+        {
+            physicBodies[i] = physicBodies[i + 1];
+            physicBodies[i]->id = physicBodies[i + 1]->id;
+        }
+        else PHYSAC_FREE(physicBodies[i]);
+    }
+    
+    // Decrease enabled physic bodies count
+    physicBodiesCount--;
+}
+
+// Apply directional force to a physic body
+PHYSACDEF void ApplyForce(PhysicBody pbody, Vector2 force)
+{
+    if (pbody->rigidbody.enabled)
+    {
+        pbody->rigidbody.velocity.x += force.x/pbody->rigidbody.mass;
+        pbody->rigidbody.velocity.y += force.y/pbody->rigidbody.mass;
+    }
+}
+
+// Apply radial force to all physic objects in range
+PHYSACDEF void ApplyForceAtPosition(Vector2 position, float force, float radius)
+{
+    for (int i = 0; i < physicBodiesCount; i++)
+    {
+        if (physicBodies[i]->rigidbody.enabled)
+        {
+            // Calculate direction and distance between force and physic body position
+            Vector2 distance = (Vector2){ physicBodies[i]->transform.position.x - position.x, physicBodies[i]->transform.position.y - position.y };
+
+            if (physicBodies[i]->collider.type == COLLIDER_RECTANGLE)
+            {
+                distance.x += physicBodies[i]->transform.scale.x/2;
+                distance.y += physicBodies[i]->transform.scale.y/2;
+            }
+            
+            float distanceLength = Vector2Length(distance);
+            
+            // Check if physic body is in force range
+            if (distanceLength <= radius)
+            {
+                // Normalize force direction
+                distance.x /= distanceLength;
+                distance.y /= -distanceLength;
+                
+                // Calculate final force
+                Vector2 finalForce = { distance.x*force, distance.y*force };
+                
+                // Apply force to the physic body
+                ApplyForce(physicBodies[i], finalForce);
+            }
+        }
+    }
+}
+
+// Convert Transform data type to Rectangle (position and scale)
+PHYSACDEF Rectangle TransformToRectangle(Transform transform)
+{
+    return (Rectangle){transform.position.x, transform.position.y, transform.scale.x, transform.scale.y};
+}
+
+// Physics calculations thread function
+PHYSACDEF void* PhysicsThread(void *arg)
+{
+    // Initialize thread loop state
+    physicsThreadEnabled = true;
+    
+    // Initialize hi-resolution timer
+    InitTimer();
+    
+    // Physics update loop
+    while (physicsThreadEnabled) 
+    {
+        currentTime = GetCurrentTime();
+        double deltaTime = (double)(currentTime - previousTime);
+        previousTime = currentTime;
+
+        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
+        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
+    }
+    
+    return NULL;
+}
+
+//----------------------------------------------------------------------------------
+// Module specific Functions Definition
+//----------------------------------------------------------------------------------
+// Initialize hi-resolution timer
+static void InitTimer(void)
+{
+#if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI)
+    struct timespec now;
+
+    if (clock_gettime(CLOCK_MONOTONIC, &now) == 0)  // Success
+    {
+        baseTime = (uint64_t)now.tv_sec*1000000000LLU + (uint64_t)now.tv_nsec;
+    }
+#endif
+
+    previousTime = GetCurrentTime();       // Get time as double
+}
+
+// Time measure returned are microseconds
+static double GetCurrentTime(void)
+{
+    double time;
+    
+#if defined(PLATFORM_DESKTOP)
+    unsigned long long int clockFrequency, currentTime;
+    
+    QueryPerformanceFrequency(&clockFrequency);
+    QueryPerformanceCounter(&currentTime);
+    
+    time = (double)((double)currentTime/(double)clockFrequency);
+#endif
+
+#if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI)
+    struct timespec ts;
+    clock_gettime(CLOCK_MONOTONIC, &ts);
+    uint64_t temp = (uint64_t)ts.tv_sec*1000000000LLU + (uint64_t)ts.tv_nsec;
+
+    time = (double)(temp - baseTime)*1e-9;
+#endif
+
+    return time;
+}
+
+// Returns the dot product of two Vector2
+static float Vector2DotProduct(Vector2 v1, Vector2 v2)
+{
+    float result;
+
+    result = v1.x*v2.x + v1.y*v2.y;
+
+    return result;
+}
+
+static float Vector2Length(Vector2 v)
+{
+    float result;
+    
+    result = sqrt(v.x*v.x + v.y*v.y);
+    
+    return result;
+}
+
 // Update physic objects, calculating physic behaviours and collisions detection
-PHYSACDEF void UpdatePhysics(double deltaTime)
+static void UpdatePhysics(double deltaTime)
 {
     for (int i = 0; i < physicBodiesCount; i++)
     {
@@ -615,210 +821,4 @@ PHYSACDEF void UpdatePhysics(double deltaTime)
     }
 }
 
-// Unitialize all physic objects and empty the objects pool
-PHYSACDEF void ClosePhysics()
-{
-    // Exit physics thread loop
-    physicsThreadEnabled = false;
-    
-    // Free all dynamic memory allocations
-    for (int i = 0; i < physicBodiesCount; i++) PHYSAC_FREE(physicBodies[i]);
-    
-    // Reset enabled physic objects count
-    physicBodiesCount = 0;
-}
-
-// Create a new physic body dinamically, initialize it and add to pool
-PHYSACDEF PhysicBody CreatePhysicBody(Vector2 position, float rotation, Vector2 scale)
-{
-    // Allocate dynamic memory
-    PhysicBody obj = (PhysicBody)PHYSAC_MALLOC(sizeof(PhysicBodyData));
-    
-    // Initialize physic body values with generic values
-    obj->id = physicBodiesCount;
-    obj->enabled = true;
-    
-    obj->transform = (Transform){ (Vector2){ position.x - scale.x/2, position.y - scale.y/2 }, rotation, scale };
-    
-    obj->rigidbody.enabled = false;
-    obj->rigidbody.mass = 1.0f;
-    obj->rigidbody.acceleration = (Vector2){ 0.0f, 0.0f };
-    obj->rigidbody.velocity = (Vector2){ 0.0f, 0.0f };
-    obj->rigidbody.applyGravity = false;
-    obj->rigidbody.isGrounded = false;
-    obj->rigidbody.friction = 0.0f;
-    obj->rigidbody.bounciness = 0.0f;
-    
-    obj->collider.enabled = true;
-    obj->collider.type = COLLIDER_RECTANGLE;
-    obj->collider.bounds = TransformToRectangle(obj->transform);
-    obj->collider.radius = 0.0f;
-    
-    // Add new physic body to the pointers array
-    physicBodies[physicBodiesCount] = obj;
-    
-    // Increase enabled physic bodies count
-    physicBodiesCount++;
-    
-    return obj;
-}
-
-// Destroy a specific physic body and take it out of the list
-PHYSACDEF void DestroyPhysicBody(PhysicBody pbody)
-{
-    // Free dynamic memory allocation
-    PHYSAC_FREE(physicBodies[pbody->id]);
-    
-    // Remove *obj from the pointers array
-    for (int i = pbody->id; i < physicBodiesCount; i++)
-    {
-        // Resort all the following pointers of the array
-        if ((i + 1) < physicBodiesCount)
-        {
-            physicBodies[i] = physicBodies[i + 1];
-            physicBodies[i]->id = physicBodies[i + 1]->id;
-        }
-        else PHYSAC_FREE(physicBodies[i]);
-    }
-    
-    // Decrease enabled physic bodies count
-    physicBodiesCount--;
-}
-
-// Apply directional force to a physic body
-PHYSACDEF void ApplyForce(PhysicBody pbody, Vector2 force)
-{
-    if (pbody->rigidbody.enabled)
-    {
-        pbody->rigidbody.velocity.x += force.x/pbody->rigidbody.mass;
-        pbody->rigidbody.velocity.y += force.y/pbody->rigidbody.mass;
-    }
-}
-
-// Apply radial force to all physic objects in range
-PHYSACDEF void ApplyForceAtPosition(Vector2 position, float force, float radius)
-{
-    for (int i = 0; i < physicBodiesCount; i++)
-    {
-        if (physicBodies[i]->rigidbody.enabled)
-        {
-            // Calculate direction and distance between force and physic body position
-            Vector2 distance = (Vector2){ physicBodies[i]->transform.position.x - position.x, physicBodies[i]->transform.position.y - position.y };
-
-            if (physicBodies[i]->collider.type == COLLIDER_RECTANGLE)
-            {
-                distance.x += physicBodies[i]->transform.scale.x/2;
-                distance.y += physicBodies[i]->transform.scale.y/2;
-            }
-            
-            float distanceLength = Vector2Length(distance);
-            
-            // Check if physic body is in force range
-            if (distanceLength <= radius)
-            {
-                // Normalize force direction
-                distance.x /= distanceLength;
-                distance.y /= -distanceLength;
-                
-                // Calculate final force
-                Vector2 finalForce = { distance.x*force, distance.y*force };
-                
-                // Apply force to the physic body
-                ApplyForce(physicBodies[i], finalForce);
-            }
-        }
-    }
-}
-
-// Convert Transform data type to Rectangle (position and scale)
-PHYSACDEF Rectangle TransformToRectangle(Transform transform)
-{
-    return (Rectangle){transform.position.x, transform.position.y, transform.scale.x, transform.scale.y};
-}
-
-//----------------------------------------------------------------------------------
-// Module specific Functions Definition
-//----------------------------------------------------------------------------------
-// Physics calculations thread function
-static void* PhysicsThread(void *arg)
-{
-    // Initialize thread loop state
-    physicsThreadEnabled = true;
-    
-    // Initialize hi-resolution timer
-    InitTimer();
-    
-    // Physics update loop
-    while (physicsThreadEnabled) 
-    {
-        currentTime = GetCurrentTime();
-        double deltaTime = (double)(currentTime - previousTime);
-        previousTime = currentTime;
-
-        // Delta time value needs to be inverse multiplied by physics time step value (1/target fps)
-        UpdatePhysics(deltaTime/PHYSICS_TIMESTEP);
-    }
-    
-    return NULL;
-}
-
-// Initialize hi-resolution timer
-static void InitTimer(void)
-{
-#if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI)
-    struct timespec now;
-
-    if (clock_gettime(CLOCK_MONOTONIC, &now) == 0)  // Success
-    {
-        baseTime = (uint64_t)now.tv_sec*1000000000LLU + (uint64_t)now.tv_nsec;
-    }
-#endif
-
-    previousTime = GetCurrentTime();       // Get time as double
-}
-
-// Time measure returned are microseconds
-static double GetCurrentTime(void)
-{
-    double time;
-    
-#if defined(PLATFORM_DESKTOP)
-    unsigned long long int clockFrequency, currentTime;
-    
-    QueryPerformanceFrequency(&clockFrequency);
-    QueryPerformanceCounter(&currentTime);
-    
-    time = (double)((double)currentTime/(double)clockFrequency);
-#endif
-
-#if defined(PLATFORM_ANDROID) || defined(PLATFORM_RPI)
-    struct timespec ts;
-    clock_gettime(CLOCK_MONOTONIC, &ts);
-    uint64_t temp = (uint64_t)ts.tv_sec*1000000000LLU + (uint64_t)ts.tv_nsec;
-
-    time = (double)(temp - baseTime)*1e-9;
-#endif
-
-    return time;
-}
-
-// Returns the dot product of two Vector2
-static float Vector2DotProduct(Vector2 v1, Vector2 v2)
-{
-    float result;
-
-    result = v1.x*v2.x + v1.y*v2.y;
-
-    return result;
-}
-
-static float Vector2Length(Vector2 v)
-{
-    float result;
-    
-    result = sqrt(v.x*v.x + v.y*v.y);
-    
-    return result;
-}
-
 #endif  // PHYSAC_IMPLEMENTATION
\ No newline at end of file
-- 
cgit v1.2.3


From 1879a8129e786e859cc2984e294ef9c22663f923 Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Tue, 14 Jun 2016 20:40:12 +0200
Subject: Fixed little bug in physac example

---
 examples/physics_basic_rigidbody.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 084bfb0e..75720c97 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -29,7 +29,7 @@ int main()
     int screenHeight = 450;
 
     InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    // InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
+    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
     
     // Debug variables
     bool isDebug = false;
-- 
cgit v1.2.3


From bd26b66c27ed06706a7f421214f614eca02bbc0d Mon Sep 17 00:00:00 2001
From: Ray <raysan5@gmail.com>
Date: Mon, 15 Aug 2016 16:18:04 +0200
Subject: Updated compiling notes

---
 examples/physics_basic_rigidbody.c | 11 +++++++++--
 examples/physics_forces.c          | 12 +++++++++---
 2 files changed, 18 insertions(+), 5 deletions(-)

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
index 75720c97..87316a98 100644
--- a/examples/physics_basic_rigidbody.c
+++ b/examples/physics_basic_rigidbody.c
@@ -5,9 +5,16 @@
 *   This example has been created using raylib 1.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
+*   NOTE:
+*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
+*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
+*   found inside raylib/src/external/pthread directory. 
 *
-*   Compile example using:
-*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*   Add pthread library when compiling physac example:
+*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
+*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
+*
+*   Note that pthreadGC2.dll must be also copied to project directory!
 *
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
index efe8e240..e45cb44c 100644
--- a/examples/physics_forces.c
+++ b/examples/physics_forces.c
@@ -5,10 +5,16 @@
 *   This example has been created using raylib 1.5 (www.raylib.com)
 *   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   NOTE: This example requires raylib module [rlgl]
+*   NOTE:
+*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
+*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
+*   found inside raylib/src/external/pthread directory. 
 *
-*   Compile example using:
-*   cmd /c IF NOT EXIST pthreadGC2.dll copy C:\raylib\raylib\src\external\pthread\pthreadGC2.dll $(CURRENT_DIRECTORY) /Y
+*   Add pthread library when compiling physac example:
+*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
+*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
+*
+*   Note that pthreadGC2.dll must be also copied to project directory!
 *
 *   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
 *
-- 
cgit v1.2.3


From d0fca7e02b56a88d26a40d96e8e4842c8c29a2fd Mon Sep 17 00:00:00 2001
From: victorfisac <victorfisac@gmail.com>
Date: Mon, 21 Nov 2016 20:31:07 +0100
Subject: Removed old Physac examples

---
 examples/physics_basic_rigidbody.c   | 135 ------------------------
 examples/physics_basic_rigidbody.png | Bin 15294 -> 0 bytes
 examples/physics_forces.c            | 193 -----------------------------------
 examples/physics_forces.png          | Bin 17935 -> 0 bytes
 4 files changed, 328 deletions(-)
 delete mode 100644 examples/physics_basic_rigidbody.c
 delete mode 100644 examples/physics_basic_rigidbody.png
 delete mode 100644 examples/physics_forces.c
 delete mode 100644 examples/physics_forces.png

(limited to 'examples/physics_basic_rigidbody.c')

diff --git a/examples/physics_basic_rigidbody.c b/examples/physics_basic_rigidbody.c
deleted file mode 100644
index 87316a98..00000000
--- a/examples/physics_basic_rigidbody.c
+++ /dev/null
@@ -1,135 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [physac] example - Basic rigidbody
-*
-*   This example has been created using raylib 1.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   NOTE:
-*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
-*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
-*   found inside raylib/src/external/pthread directory. 
-*
-*   Add pthread library when compiling physac example:
-*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
-*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
-*
-*   Note that pthreadGC2.dll must be also copied to project directory!
-*
-*   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "physac.h"
-
-#define MOVE_VELOCITY    5
-#define JUMP_VELOCITY    30
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
-    InitWindow(screenWidth, screenHeight, "raylib [physac] example - basic rigidbody");
-    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
-    
-    // Debug variables
-    bool isDebug = false;
-    
-    // Create rectangle physic object
-    PhysicBody rectangle = CreatePhysicBody((Vector2){ screenWidth*0.25f, screenHeight/2 }, 0.0f, (Vector2){ 75, 50 });
-    rectangle->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
-    rectangle->rigidbody.applyGravity = true;
-    rectangle->rigidbody.friction = 0.1f;
-    rectangle->rigidbody.bounciness = 6.0f;
-    
-    // Create square physic object
-    PhysicBody square = CreatePhysicBody((Vector2){ screenWidth*0.75f, screenHeight/2 }, 0.0f, (Vector2){ 50, 50 });
-    square->rigidbody.enabled = true;      // Enable physic object rigidbody behaviour
-    square->rigidbody.applyGravity = true;
-    square->rigidbody.friction = 0.1f;
-    
-    // Create walls physic objects
-    PhysicBody floor = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.95f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
-    PhysicBody leftWall = CreatePhysicBody((Vector2){ 0.0f, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicBody rightWall = CreatePhysicBody((Vector2){ screenWidth, screenHeight/2 }, 0.0f, (Vector2){ screenWidth*0.1f, screenHeight });
-    PhysicBody roof = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.05f }, 0.0f, (Vector2){ screenWidth*0.9f, 100 });
-    
-    // Create pplatform physic object
-    PhysicBody platform = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight*0.7f }, 0.0f, (Vector2){ screenWidth*0.25f, 20 });
-    
-    SetTargetFPS(60);
-    //--------------------------------------------------------------------------------------
-
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------        
-        // Check rectangle movement inputs
-        if (IsKeyPressed('W')) rectangle->rigidbody.velocity.y = JUMP_VELOCITY;
-        if (IsKeyDown('A')) rectangle->rigidbody.velocity.x = -MOVE_VELOCITY;
-        else if (IsKeyDown('D')) rectangle->rigidbody.velocity.x = MOVE_VELOCITY;
-        
-        // Check square movement inputs
-        if (IsKeyDown(KEY_UP) && square->rigidbody.isGrounded) square->rigidbody.velocity.y = JUMP_VELOCITY;
-        if (IsKeyDown(KEY_LEFT)) square->rigidbody.velocity.x = -MOVE_VELOCITY;
-        else if (IsKeyDown(KEY_RIGHT)) square->rigidbody.velocity.x = MOVE_VELOCITY;
-        
-        // Check debug switch input
-        if (IsKeyPressed('P')) isDebug = !isDebug;
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-
-            ClearBackground(RAYWHITE);
-
-            // Draw floor, roof and walls rectangles
-            DrawRectangleRec(TransformToRectangle(floor->transform), DARKGRAY);         // Convert transform values to rectangle data type variable
-            DrawRectangleRec(TransformToRectangle(leftWall->transform), DARKGRAY);
-            DrawRectangleRec(TransformToRectangle(rightWall->transform), DARKGRAY);
-            DrawRectangleRec(TransformToRectangle(roof->transform), DARKGRAY);
-            
-            // Draw middle platform rectangle
-            DrawRectangleRec(TransformToRectangle(platform->transform), DARKGRAY);
-            
-            // Draw physic objects
-            DrawRectangleRec(TransformToRectangle(rectangle->transform), RED);
-            DrawRectangleRec(TransformToRectangle(square->transform), BLUE);
-            
-            // Draw collider lines if debug is enabled
-            if (isDebug)
-            {
-                DrawRectangleLines(floor->collider.bounds.x, floor->collider.bounds.y, floor->collider.bounds.width, floor->collider.bounds.height, GREEN);
-                DrawRectangleLines(leftWall->collider.bounds.x, leftWall->collider.bounds.y, leftWall->collider.bounds.width, leftWall->collider.bounds.height, GREEN);
-                DrawRectangleLines(rightWall->collider.bounds.x, rightWall->collider.bounds.y, rightWall->collider.bounds.width, rightWall->collider.bounds.height, GREEN);
-                DrawRectangleLines(roof->collider.bounds.x, roof->collider.bounds.y, roof->collider.bounds.width, roof->collider.bounds.height, GREEN);
-                DrawRectangleLines(platform->collider.bounds.x, platform->collider.bounds.y, platform->collider.bounds.width, platform->collider.bounds.height, GREEN);
-                DrawRectangleLines(rectangle->collider.bounds.x, rectangle->collider.bounds.y, rectangle->collider.bounds.width, rectangle->collider.bounds.height, GREEN);
-                DrawRectangleLines(square->collider.bounds.x, square->collider.bounds.y, square->collider.bounds.width, square->collider.bounds.height, GREEN);
-            }
-            
-            // Draw help message
-            DrawText("Use WASD to move rectangle and ARROWS to move square", screenWidth/2 - MeasureText("Use WASD to move rectangle and ARROWS to move square", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
-
-            DrawFPS(10, 10);
-            
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    ClosePhysics();       // Unitialize physics (including all loaded objects)
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
\ No newline at end of file
diff --git a/examples/physics_basic_rigidbody.png b/examples/physics_basic_rigidbody.png
deleted file mode 100644
index 52f265ac..00000000
Binary files a/examples/physics_basic_rigidbody.png and /dev/null differ
diff --git a/examples/physics_forces.c b/examples/physics_forces.c
deleted file mode 100644
index e45cb44c..00000000
--- a/examples/physics_forces.c
+++ /dev/null
@@ -1,193 +0,0 @@
-/*******************************************************************************************
-*
-*   raylib [physac] example - Forces
-*
-*   This example has been created using raylib 1.5 (www.raylib.com)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   NOTE:
-*   Physac requires multi-threading, when InitPhysics() a second thread is created to manage
-*   physics calculations. To accomplish that, physac uses pthread Win32 library that can be
-*   found inside raylib/src/external/pthread directory. 
-*
-*   Add pthread library when compiling physac example:
-*   gcc -o $(NAME_PART).exe $(FILE_NAME) $(RAYLIB_DIR)\raylib_icon -L../src/external/pthread/lib \
-*   -I../src -I../src/external/pthread/include -lraylib -lglfw3 -lopengl32 -lgdi32 -lpthreadGC2 -std=c99 -Wall
-*
-*   Note that pthreadGC2.dll must be also copied to project directory!
-*
-*   Copyright (c) 2016 Victor Fisac and Ramon Santamaria (@raysan5)
-*
-********************************************************************************************/
-
-#include "raylib.h"
-
-#define PHYSAC_IMPLEMENTATION
-#include "physac.h"
-
-#define FORCE_AMOUNT        5.0f
-#define FORCE_RADIUS        150
-#define LINE_LENGTH         75
-#define TRIANGLE_LENGTH     12
-
-int main()
-{
-    // Initialization
-    //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
-    InitWindow(screenWidth, screenHeight, "raylib [physac] example - forces");
-    InitPhysics((Vector2){ 0.0f, -9.81f/2 });      // Initialize physics module
-    
-    // Global variables
-    Vector2 mousePosition;
-    bool isDebug = false;
-    
-    // Create rectangle physic objects
-    PhysicBody rectangles[3];
-    for (int i = 0; i < 3; i++)
-    {
-        rectangles[i] = CreatePhysicBody((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) }, 0.0f, (Vector2){ 50, 50 });
-        rectangles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
-        rectangles[i]->rigidbody.friction = 0.1f;
-    }
-    
-    // Create circles physic objects
-    // NOTE: when creating circle physic objects, transform.scale must be { 0, 0 } and object radius must be defined in collider.radius and use this value to draw the circle.
-    PhysicBody circles[3];
-    for (int i = 0; i < 3; i++)
-    {
-        circles[i] = CreatePhysicBody((Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) }, 0.0f, (Vector2){ 0, 0 });
-        circles[i]->rigidbody.enabled = true;       // Enable physic object rigidbody behaviour
-        circles[i]->rigidbody.friction = 0.1f;
-        circles[i]->collider.type = COLLIDER_CIRCLE;
-        circles[i]->collider.radius = 25;
-    }
-    
-    // Create walls physic objects
-    PhysicBody leftWall = CreatePhysicBody((Vector2){ -25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicBody rightWall = CreatePhysicBody((Vector2){ screenWidth + 25, screenHeight/2 }, 0.0f, (Vector2){ 50, screenHeight });
-    PhysicBody topWall = CreatePhysicBody((Vector2){ screenWidth/2, -25 }, 0.0f, (Vector2){ screenWidth, 50 });
-    PhysicBody bottomWall = CreatePhysicBody((Vector2){ screenWidth/2, screenHeight + 25 }, 0.0f, (Vector2){ screenWidth, 50 });
-    
-    SetTargetFPS(60);
-    //--------------------------------------------------------------------------------------
-
-    // Main game loop
-    while (!WindowShouldClose())    // Detect window close button or ESC key
-    {
-        // Update
-        //----------------------------------------------------------------------------------
-        
-        // Update mouse position value
-        mousePosition = GetMousePosition();
-        
-        // Check force input
-        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) ApplyForceAtPosition(mousePosition, FORCE_AMOUNT, FORCE_RADIUS);
-        
-        // Check reset input
-        if (IsKeyPressed('R'))
-        {
-            // Reset rectangle physic objects positions
-            for (int i = 0; i < 3; i++)
-            {
-                rectangles[i]->transform.position = (Vector2){ screenWidth/4*(i+1) - rectangles[i]->transform.scale.x/2, (((i % 2) == 0) ? (screenHeight/3) : (screenHeight/1.5f)) - rectangles[i]->transform.scale.y/2 };
-                rectangles[i]->rigidbody.velocity =(Vector2){ 0.0f, 0.0f };
-            }
-            
-            // Reset circles physic objects positions
-            for (int i = 0; i < 3; i++)
-            {
-                circles[i]->transform.position = (Vector2){ screenWidth/4*(i+1), (((i % 2) == 0) ? (screenHeight/1.5f) : (screenHeight/4)) };
-                circles[i]->rigidbody.velocity =(Vector2){ 0.0f, 0.0f };
-            }
-        }
-        
-        // Check debug switch input
-        if (IsKeyPressed('P')) isDebug = !isDebug;
-        //----------------------------------------------------------------------------------
-
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
-
-            ClearBackground(RAYWHITE);
-
-            // Draw rectangles
-            for (int i = 0; i < 3; i++)
-            {
-                // Convert transform values to rectangle data type variable
-                DrawRectangleRec(TransformToRectangle(rectangles[i]->transform), RED);
-                if (isDebug) DrawRectangleLines(rectangles[i]->collider.bounds.x, rectangles[i]->collider.bounds.y, rectangles[i]->collider.bounds.width, rectangles[i]->collider.bounds.height, GREEN);
-
-                // Draw force radius
-                DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
-                
-                // Draw direction lines
-                if (CheckCollisionPointCircle((Vector2){ rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 }, mousePosition, FORCE_RADIUS))
-                {
-                    Vector2 direction = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 - mousePosition.x, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 - mousePosition.y };
-                    float angle = atan2l(direction.y, direction.x);
-                    
-                    // Calculate arrow start and end positions
-                    Vector2 startPosition = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2, rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 };
-                    Vector2 endPosition = { rectangles[i]->transform.position.x + rectangles[i]->transform.scale.x/2 + (cos(angle)*LINE_LENGTH), rectangles[i]->transform.position.y + rectangles[i]->transform.scale.y/2 + (sin(angle)*LINE_LENGTH) };
-                    
-                    // Draw arrow line
-                    DrawLineV(startPosition, endPosition, BLACK);
-                    
-                    // Draw arrow triangle
-                    DrawTriangleLines((Vector2){ endPosition.x - cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y - sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
-                                      (Vector2){ endPosition.x + cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y + sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
-                                      (Vector2){ endPosition.x + cos(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2, endPosition.y + sin(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2 }, BLACK);
-                }
-            }
-            
-            // Draw circles
-            for (int i = 0; i < 3; i++)
-            {
-                DrawCircleV(circles[i]->transform.position, circles[i]->collider.radius, BLUE);
-                if (isDebug) DrawCircleLines(circles[i]->transform.position.x, circles[i]->transform.position.y, circles[i]->collider.radius, GREEN);
-
-                // Draw force radius
-                DrawCircleLines(mousePosition.x, mousePosition.y, FORCE_RADIUS, BLACK);
-                
-                // Draw direction lines
-                if (CheckCollisionPointCircle((Vector2){ circles[i]->transform.position.x, circles[i]->transform.position.y }, mousePosition, FORCE_RADIUS))
-                {
-                    Vector2 direction = { circles[i]->transform.position.x - mousePosition.x, circles[i]->transform.position.y - mousePosition.y };
-                    float angle = atan2l(direction.y, direction.x);
-                    
-                    // Calculate arrow start and end positions
-                    Vector2 startPosition = { circles[i]->transform.position.x, circles[i]->transform.position.y };
-                    Vector2 endPosition = { circles[i]->transform.position.x + (cos(angle)*LINE_LENGTH), circles[i]->transform.position.y + (sin(angle)*LINE_LENGTH) };
-                    
-                    // Draw arrow line
-                    DrawLineV(startPosition, endPosition, BLACK);
-                    
-                    // Draw arrow triangle
-                    DrawTriangleLines((Vector2){ endPosition.x - cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y - sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
-                                      (Vector2){ endPosition.x + cos(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH, endPosition.y + sin(angle + 90*DEG2RAD)*LINE_LENGTH/TRIANGLE_LENGTH },
-                                      (Vector2){ endPosition.x + cos(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2, endPosition.y + sin(angle)*LINE_LENGTH/TRIANGLE_LENGTH*2 }, BLACK);
-                }
-            }
-            
-            // Draw help messages
-            DrawText("Use LEFT MOUSE BUTTON to apply a force", screenWidth/2 - MeasureText("Use LEFT MOUSE BUTTON to apply a force", 20)/2, screenHeight*0.075f, 20, LIGHTGRAY);
-            DrawText("Use R to reset objects position", screenWidth/2 - MeasureText("Use R to reset objects position", 20)/2, screenHeight*0.875f, 20, GRAY);
-            
-            DrawFPS(10, 10);
-
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------
-    ClosePhysics();       // Unitialize physics module
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
-}
\ No newline at end of file
diff --git a/examples/physics_forces.png b/examples/physics_forces.png
deleted file mode 100644
index 832bdbd9..00000000
Binary files a/examples/physics_forces.png and /dev/null differ
-- 
cgit v1.2.3