Repository: victorfisac/Physac
Branch: master
Commit: 587b63926010
Files: 14
Total size: 116.1 KB
Directory structure:
gitextract_h4mokleg/
├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── examples/
│ ├── physics_demo
│ ├── physics_demo.c
│ ├── physics_friction.c
│ ├── physics_movement.c
│ ├── physics_restitution.c
│ └── physics_shatter.c
├── icon/
│ ├── physac.pdn
│ ├── physac.rc
│ └── physac_icon
└── src/
└── physac.h
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitattributes
================================================
# Auto detect text files and perform LF normalization
* text=auto
# Custom for Visual Studio
*.cs diff=csharp
# Standard to msysgit
*.doc diff=astextplain
*.DOC diff=astextplain
*.docx diff=astextplain
*.DOCX diff=astextplain
*.dot diff=astextplain
*.DOT diff=astextplain
*.pdf diff=astextplain
*.PDF diff=astextplain
*.rtf diff=astextplain
*.RTF diff=astextplain
================================================
FILE: .gitignore
================================================
# Object files
*.o
*.ko
*.obj
*.elf
# Precompiled Headers
*.gch
*.pch
# Libraries
*.lib
*.a
*.la
*.lo
# Shared objects (inc. Windows DLLs)
*.so
*.so.*
*.dylib
# Executables
*.out
*.app
*.i*86
*.x86_64
*.hex
# Debug files
*.dSYM/
# =========================
# Operating System Files
# =========================
# Linux
# =========================
# Vim temporary files
*~
*.swp
*.swo
# OSX
# =========================
.DS_Store
.AppleDouble
.LSOverride
# Thumbnails
._*
# Files that might appear in the root of a volume
.DocumentRevisions-V100
.fseventsd
.Spotlight-V100
.TemporaryItems
.Trashes
.VolumeIcon.icns
# Directories potentially created on remote AFP share
.AppleDB
.AppleDesktop
Network Trash Folder
Temporary Items
.apdisk
# Windows
# =========================
# Windows image file caches
Thumbs.db
ehthumbs.db
# Folder config file
Desktop.ini
# Recycle Bin used on file shares
$RECYCLE.BIN/
# Windows Installer files
*.cab
*.msi
*.msm
*.msp
# Windows shortcuts
*.lnk
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2022 Víctor Fisac
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: README.md
================================================
<img src="https://github.com/victorfisac/Physac/blob/master/icon/physac_256x256.png">
# Physac
Physac is a small 2D physics engine written in pure C. The engine uses a fixed time-step thread loop to simluate physics.
A physics step contains the following phases: get collision information, apply dynamics, collision solving and position correction. It uses a very simple struct for physic bodies with a position vector to be used in any 3D rendering API.
The header file includes some tweakable define values to fit the results that the user wants with a minimal bad results. Most of those values are commented with a little explanation about their uses.
_Note: The example code uses raylib programming library to create the program window and rendering framework._
Installation
-----
Physac requires raylib. To get it, follow the next steps:
* Go to [raylib](https://www.github.com/raysan5/raylib) and clone the repository.
* Ensure to pull the last changes of 'master' branch.
* Use code inside examples header comments to compile and execute.
Physac API
-----
The PhysicsBody struct contains all dynamics information and collision shape. The user should use the following structure components:
```c
typedef struct *PhysicsBody {
unsigned int id;
bool enabled; // Enabled dynamics state (collisions are calculated anyway)
Vector2 position; // Physics body shape pivot
Vector2 velocity; // Current linear velocity applied to position
Vector2 force; // Current linear force (reset to 0 every step)
float angularVelocity; // Current angular velocity applied to orient
float torque; // Current angular force (reset to 0 every step)
float orient; // Rotation in radians
float staticFriction; // Friction when the body has not movement (0 to 1)
float dynamicFriction; // Friction when the body has movement (0 to 1)
float restitution; // Restitution coefficient of the body (0 to 1)
bool useGravity; // Apply gravity force to dynamics
bool isGrounded; // Physics grounded on other body state
bool freezeOrient; // Physics rotation constraint
PhysicsShape shape; // Physics body shape information (type, radius, vertices, normals)
} *PhysicsBody;
```
The header contains a few customizable define values. I set the values that gived me the best results.
```c
#define PHYSAC_MAX_BODIES 64
#define PHYSAC_MAX_MANIFOLDS 4096
#define PHYSAC_MAX_VERTICES 24
#define PHYSAC_CIRCLE_VERTICES 24
#define PHYSAC_COLLISION_ITERATIONS 100
#define PHYSAC_PENETRATION_ALLOWANCE 0.05f
#define PHYSAC_PENETRATION_CORRECTION 0.4f
```
Physac contains defines for memory management functions (malloc, free) to bring the user the opportunity to implement its own memory functions:
```c
#define PHYSAC_MALLOC(size) malloc(size)
#define PHYSAC_FREE(ptr) free(ptr)
```
The Physac API functions availables for the user are the following:
```c
// Initializes physics values, pointers and creates physics loop thread
void InitPhysics(void);
// Returns true if physics thread is currently enabled
bool IsPhysicsEnabled(void);
// Sets physics global gravity force
void SetPhysicsGravity(float x, float y);
// Creates a new circle physics body with generic parameters
PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density);
// Creates a new rectangle physics body with generic parameters
PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density);
// Creates a new polygon physics body with generic parameters
PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density);
// Adds a force to a physics body
void PhysicsAddForce(PhysicsBody body, Vector2 force);
// Adds a angular force to a physics body
void PhysicsAddTorque(PhysicsBody body, float amount);
// Shatters a polygon shape physics body to little physics bodies with explosion force
void PhysicsShatter(PhysicsBody body, Vector2 position, float force);
// Returns the current amount of created physics bodies
int GetPhysicsBodiesCount(void);
// Returns a physics body of the bodies pool at a specific index
PhysicsBody GetPhysicsBody(int index);
// Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
int GetPhysicsShapeType(int index);
// Returns the amount of vertices of a physics body shape
int GetPhysicsShapeVerticesCount(int index);
// Returns transformed position of a body shape (body position + vertex transformed position)
Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex);
// Sets physics body shape transform based on radians parameter
void SetPhysicsBodyRotation(PhysicsBody body, float radians);
// Unitializes and destroy a physics body
void DestroyPhysicsBody(PhysicsBody body);
// Unitializes physics pointers and closes physics loop thread
void ClosePhysics(void);
```
_Note: InitPhysics() needs to be called at program start and ClosePhysics() before the program ends. Closing and initializing Physac during the program flow doesn't affect or produces any error (useful as a 'reset' to destroy any created body by user in runtime)._
Dependencies
-----
Physac uses the following C libraries for memory management, math operations and some debug features:
* stdlib.h - Memory allocation [malloc(), free(), srand(), rand()].
* stdio.h - Message logging (only if PHYSAC_DEBUG is defined) [printf()].
* math.h - Math operations functions [cos(), sin(), fabs(), sqrtf()].
**It is independent to any graphics engine** and prepared to use any graphics API and use the vertices information (look at examples Drawing logic) to draw lines or shapes in screen. For example, this vertices information can be use in OpenGL API glVertex2f().
By the way, I use [raylib](http://www.raylib.com) to create the examples. This videogames programming library is used to handle inputs, window management and graphics drawing (using OpenGL API).
================================================
FILE: examples/physics_demo.c
================================================
/*******************************************************************************************
*
* Physac - Physics demo
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread
* is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency
* on MinGW DLL (-static -lpthread)
*
* Compile this program using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s ..\icon\physac_icon -I. -I../src
* -I../src/external/raylib/src -static -lraylib -lopengl32 -lgdi32 -pthread -std=c99
*
* Copyright (c) 2016-2025 Victor Fisac (github: @victorfisac)
*
********************************************************************************************/
#include "raylib.h"
#define PHYSAC_IMPLEMENTATION
#include "../src/physac.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "[physac] Basic demo");
// Physac logo drawing position
int logoX = screenWidth - MeasureText("Physac", 30) - 10;
int logoY = 15;
// Initialize physics and default physics bodies
InitPhysics();
// Create floor rectangle physics body
PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
// Create obstacle circle physics body
PhysicsBody circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
circle->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// Physics body creation inputs
if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
CreatePhysicsBodyPolygon(GetMousePosition(), GetRandomValue(20, 80), GetRandomValue(3, 8), 10);
else if (IsMouseButtonPressed(MOUSE_RIGHT_BUTTON))
CreatePhysicsBodyCircle(GetMousePosition(), GetRandomValue(10, 45), 10);
// Destroy falling physics bodies
int bodiesCount = GetPhysicsBodiesCount();
for (int i = bodiesCount - 1; i >= 0; i--)
{
PhysicsBody body = GetPhysicsBody(i);
if ((body != NULL) && (body->position.y > screenHeight*2))
DestroyPhysicsBody(body);
}
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(BLACK);
DrawFPS(screenWidth - 90, screenHeight - 30);
// Draw created physics bodies
bodiesCount = GetPhysicsBodiesCount();
for (int i = 0; i < bodiesCount; i++)
{
PhysicsBody body = GetPhysicsBody(i);
if (body != NULL)
{
int vertexCount = GetPhysicsShapeVerticesCount(i);
for (int j = 0; j < vertexCount; j++)
{
// Get physics bodies shape vertices to draw lines
// Note: GetPhysicsShapeVertex() already calculates rotation transformations
Vector2 vertexA = GetPhysicsShapeVertex(body, j);
int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
}
}
}
DrawText("Left mouse button to create a polygon", 10, 10, 10, WHITE);
DrawText("Right mouse button to create a circle", 10, 25, 10, WHITE);
DrawText("Physac", logoX, logoY, 30, WHITE);
DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
ClosePhysics(); // Unitialize physics
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
================================================
FILE: examples/physics_friction.c
================================================
/*******************************************************************************************
*
* Physac - Physics friction
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread
* is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency
* on MinGW DLL (-static -lpthread)
*
* Compile this program using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s ..\icon\physac_icon -I. -I../src
* -I../src/external/raylib/src -static -lraylib -lopengl32 -lgdi32 -pthread -std=c99
*
* Copyright (c) 2016-2025 Victor Fisac (github: @victorfisac)
*
********************************************************************************************/
#include "raylib.h"
#define PHYSAC_IMPLEMENTATION
#include "../src/physac.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "[physac] Friction demo");
// Physac logo drawing position
int logoX = screenWidth - MeasureText("Physac", 30) - 10;
int logoY = 15;
// Initialize physics and default physics bodies
InitPhysics();
// Create floor rectangle physics body
PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
PhysicsBody wall = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight*0.8f }, 10, 80, 10);
wall->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
// Create left ramp physics body
PhysicsBody rectLeft = CreatePhysicsBodyRectangle((Vector2){ 25, screenHeight - 5 }, 250, 250, 10);
rectLeft->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
SetPhysicsBodyRotation(rectLeft, 30*DEG2RAD);
// Create right ramp physics body
PhysicsBody rectRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth - 25, screenHeight - 5 }, 250, 250, 10);
rectRight->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
SetPhysicsBodyRotation(rectRight, 330*DEG2RAD);
// Create dynamic physics bodies
PhysicsBody bodyA = CreatePhysicsBodyRectangle((Vector2){ 35, screenHeight*0.6f }, 40, 40, 10);
bodyA->staticFriction = 0.1f;
bodyA->dynamicFriction = 0.1f;
SetPhysicsBodyRotation(bodyA, 30*DEG2RAD);
PhysicsBody bodyB = CreatePhysicsBodyRectangle((Vector2){ screenWidth - 35, screenHeight*0.6f }, 40, 40, 10);
bodyB->staticFriction = 1;
bodyB->dynamicFriction = 1;
SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// ...
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(BLACK);
DrawFPS(screenWidth - 90, screenHeight - 30);
// Draw created physics bodies
int bodiesCount = GetPhysicsBodiesCount();
for (int i = 0; i < bodiesCount; i++)
{
PhysicsBody body = GetPhysicsBody(i);
if (body != NULL)
{
int vertexCount = GetPhysicsShapeVerticesCount(i);
for (int j = 0; j < vertexCount; j++)
{
// Get physics bodies shape vertices to draw lines
// Note: GetPhysicsShapeVertex() already calculates rotation transformations
Vector2 vertexA = GetPhysicsShapeVertex(body, j);
int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
}
}
}
DrawRectangle(0, screenHeight - 49, screenWidth, 49, BLACK);
DrawText("Friction amount", (screenWidth - MeasureText("Friction amount", 30))/2, 75, 30, WHITE);
DrawText("0.1", bodyA->position.x - MeasureText("0.1", 20)/2, bodyA->position.y - 7, 20, WHITE);
DrawText("1", bodyB->position.x - MeasureText("1", 20)/2, bodyB->position.y - 7, 20, WHITE);
DrawText("Physac", logoX, logoY, 30, WHITE);
DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
ClosePhysics(); // Unitialize physics
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
================================================
FILE: examples/physics_movement.c
================================================
/*******************************************************************************************
*
* Physac - Physics movement
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread
* is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency
* on MinGW DLL (-static -lpthread)
*
* Compile this program using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s ..\icon\physac_icon -I. -I../src
* -I../src/external/raylib/src -static -lraylib -lopengl32 -lgdi32 -pthread -std=c99
*
* Copyright (c) 2016-2025 Victor Fisac (github: @victorfisac)
*
********************************************************************************************/
#include "raylib.h"
#define PHYSAC_IMPLEMENTATION
#include "../src/physac.h"
#define VELOCITY 0.5f
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "[physac] - Body controller demo");
// Physac logo drawing position
int logoX = screenWidth - MeasureText("Physac", 30) - 10;
int logoY = 15;
// Initialize physics and default physics bodies
InitPhysics();
// Create floor and walls rectangle physics body
PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
PhysicsBody platformLeft = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.25f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
PhysicsBody platformRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth*0.75f, screenHeight*0.6f }, screenWidth*0.25f, 10, 10);
PhysicsBody wallLeft = CreatePhysicsBodyRectangle((Vector2){ -5, screenHeight/2 }, 10, screenHeight, 10);
PhysicsBody wallRight = CreatePhysicsBodyRectangle((Vector2){ screenWidth + 5, screenHeight/2 }, 10, screenHeight, 10);
// Disable dynamics to floor and walls physics bodies
floor->enabled = false;
platformLeft->enabled = false;
platformRight->enabled = false;
wallLeft->enabled = false;
wallRight->enabled = false;
// Create movement physics body
PhysicsBody body = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight/2 }, 50, 50, 1);
body->freezeOrient = true; // Constrain body rotation to avoid little collision torque amounts
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// Horizontal movement input
if (IsKeyDown(KEY_RIGHT))
body->velocity.x = VELOCITY;
else if (IsKeyDown(KEY_LEFT))
body->velocity.x = -VELOCITY;
// Vertical movement input checking if player physics body is grounded
if (IsKeyDown(KEY_UP) && body->isGrounded)
body->velocity.y = -VELOCITY*4;
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(BLACK);
DrawFPS(screenWidth - 90, screenHeight - 30);
// Draw created physics bodies
int bodiesCount = GetPhysicsBodiesCount();
for (int i = 0; i < bodiesCount; i++)
{
PhysicsBody body = GetPhysicsBody(i);
int vertexCount = GetPhysicsShapeVerticesCount(i);
for (int j = 0; j < vertexCount; j++)
{
// Get physics bodies shape vertices to draw lines
// Note: GetPhysicsShapeVertex() already calculates rotation transformations
Vector2 vertexA = GetPhysicsShapeVertex(body, j);
int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
}
}
DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
DrawText("Physac", logoX, logoY, 30, WHITE);
DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
ClosePhysics(); // Unitialize physics
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
================================================
FILE: examples/physics_restitution.c
================================================
/*******************************************************************************************
*
* Physac - Physics restitution
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread
* is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency
* on MinGW DLL (-static -lpthread)
*
* Compile this program using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s ..\icon\physac_icon -I. -I../src
* -I../src/external/raylib/src -static -lraylib -lopengl32 -lgdi32 -pthread -std=c99
*
* Copyright (c) 2016-2025 Victor Fisac (github: @victorfisac)
*
********************************************************************************************/
#include "raylib.h"
#define PHYSAC_IMPLEMENTATION
#include "../src/physac.h"
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "[physac] - Restitution demo");
// Physac logo drawing position
int logoX = screenWidth - MeasureText("Physac", 30) - 10;
int logoY = 15;
// Initialize physics and default physics bodies
InitPhysics();
// Create floor rectangle physics body
PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
floor->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
floor->restitution = 0.9f;
// Create circles physics body
PhysicsBody circleA = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.25f, screenHeight/2 }, 30, 10);
circleA->restitution = 0.0f;
PhysicsBody circleB = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.5f, screenHeight/2 }, 30, 10);
circleB->restitution = 0.5f;
PhysicsBody circleC = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.75f, screenHeight/2 }, 30, 10);
circleC->restitution = 0.9f;
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
// ...
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(BLACK);
DrawFPS(screenWidth - 90, screenHeight - 30);
// Draw created physics bodies
int bodiesCount = GetPhysicsBodiesCount();
for (int i = 0; i < bodiesCount; i++)
{
PhysicsBody body = GetPhysicsBody(i);
int vertexCount = GetPhysicsShapeVerticesCount(i);
for (int j = 0; j < vertexCount; j++)
{
// Get physics bodies shape vertices to draw lines
// Note: GetPhysicsShapeVertex() already calculates rotation transformations
Vector2 vertexA = GetPhysicsShapeVertex(body, j);
int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
}
}
DrawText("Restitution amount", (screenWidth - MeasureText("Restitution amount", 30))/2, 75, 30, WHITE);
DrawText("0%", circleA->position.x - MeasureText("0%", 20)/2, circleA->position.y - 7, 20, WHITE);
DrawText("50%", circleB->position.x - MeasureText("50%", 20)/2, circleB->position.y - 7, 20, WHITE);
DrawText("90%", circleC->position.x - MeasureText("90%", 20)/2, circleC->position.y - 7, 20, WHITE);
DrawText("Physac", logoX, logoY, 30, WHITE);
DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
ClosePhysics(); // Unitialize physics
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
================================================
FILE: examples/physics_shatter.c
================================================
/*******************************************************************************************
*
* Physac - Body shatter
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread
* is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency
* on MinGW DLL (-static -lpthread)
*
* Compile this program using:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s ..\icon\physac_icon -I. -I../src
* -I../src/external/raylib/src -static -lraylib -lopengl32 -lgdi32 -pthread -std=c99
*
* Copyright (c) 2016-2020 Victor Fisac (github: @victorfisac)
*
********************************************************************************************/
#include "raylib.h"
#define PHYSAC_IMPLEMENTATION
#include "../src/physac.h"
#define SHATTER_FORCE 200.0f
int main()
{
// Initialization
//--------------------------------------------------------------------------------------
int screenWidth = 800;
int screenHeight = 450;
SetConfigFlags(FLAG_MSAA_4X_HINT);
InitWindow(screenWidth, screenHeight, "[physac] - Shatter demo");
// Physac logo drawing position
int logoX = screenWidth - MeasureText("Physac", 30) - 10;
int logoY = 15;
bool shatter = false;
// Initialize physics and default physics bodies
InitPhysics();
SetPhysicsGravity(0, 0);
// Create random polygon physics body to shatter
PhysicsBody shatterBody = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
SetTargetFPS(60);
//--------------------------------------------------------------------------------------
// Main game loop
while (!WindowShouldClose()) // Detect window close button or ESC key
{
// Update
//----------------------------------------------------------------------------------
if (IsKeyPressed(KEY_R))
{
ClosePhysics();
InitPhysics();
SetPhysicsGravity(0, 0);
CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
}
else if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))
{
// Note: some values need to be stored in variables due to asynchronous changes during main thread
int count = GetPhysicsBodiesCount();
for (int i = count - 1; i >= 0; i--)
{
PhysicsBody currentBody = GetPhysicsBody(i);
if (currentBody != NULL)
{
PhysicsShatter(currentBody, GetMousePosition(), SHATTER_FORCE);
}
}
}
//----------------------------------------------------------------------------------
// Draw
//----------------------------------------------------------------------------------
BeginDrawing();
ClearBackground(BLACK);
// Draw created physics bodies
int bodiesCount = GetPhysicsBodiesCount();
for (int i = 0; i < bodiesCount; i++)
{
PhysicsBody currentBody = GetPhysicsBody(i);
// Check if the body is valid
if (currentBody != NULL)
{
int vertexCount = GetPhysicsShapeVerticesCount(i);
for (int j = 0; j < vertexCount; j++)
{
// Get physics bodies shape vertices to draw lines
Vector2 vertexA = GetPhysicsShapeVertex(currentBody, j);
int jj = (((j + 1) < vertexCount) ? (j + 1) : 0); // Get next vertex or first to close the shape
Vector2 vertexB = GetPhysicsShapeVertex(currentBody, jj);
DrawLineV(vertexA, vertexB, GREEN); // Draw a line between two vertex positions
}
}
}
DrawText("Left mouse button in polygon area to shatter body", 10, 10, 10, WHITE);
DrawText("Physac", logoX, logoY, 30, WHITE);
DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
EndDrawing();
//----------------------------------------------------------------------------------
}
// De-Initialization
//--------------------------------------------------------------------------------------
ClosePhysics(); // Uninitialize physics
CloseWindow(); // Close window and OpenGL context
//--------------------------------------------------------------------------------------
return 0;
}
================================================
FILE: icon/physac.rc
================================================
GLFW_ICON ICON "physac.ico"
1 VERSIONINFO
FILEVERSION 1,0,0,0
PRODUCTVERSION 1,0,0,0
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904E4"
BEGIN
VALUE "CompanyName", "Victor Fisac Fuentes"
VALUE "FileDescription", "Physac - 2D physics header-only library for videogames"
VALUE "FileVersion", "1.0"
VALUE "InternalName", "physac"
VALUE "LegalCopyright", "(c) 2017 Victor Fisac. All rights reserved."
VALUE "OriginalFilename", "physac.exe"
VALUE "ProductName", "Physac app"
VALUE "ProductVersion", "1.0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1252 // English US
END
END
================================================
FILE: src/physac.h
================================================
/**********************************************************************************************
*
* Physac v1.1 - 2D Physics library for videogames
*
* DESCRIPTION:
*
* Physac is a small 2D physics library written in pure C. The engine uses a fixed time-step thread loop
* to simluate physics. A physics step contains the following phases: get collision information,
* apply dynamics, collision solving and position correction. It uses a very simple struct for physic
* bodies with a position vector to be used in any 3D rendering API.
*
* CONFIGURATION:
*
* #define PHYSAC_IMPLEMENTATION
* Generates the implementation of the library into the included file.
* If not defined, the library is in header only mode and can be included in other headers
* or source files without problems. But only ONE file should hold the implementation.
*
* #define PHYSAC_STATIC (defined by default)
* The generated implementation will stay private inside implementation file and all
* internal symbols and functions will only be visible inside that file.
*
* #define PHYSAC_NO_THREADS
* The generated implementation won't include pthread library and user must create a secondary thread to call PhysicsThread().
* It is so important that the thread where PhysicsThread() is called must not have v-sync or any other CPU limitation.
*
* #define PHYSAC_STANDALONE
* Avoid raylib.h header inclusion in this file. Data types defined on raylib are defined
* internally in the library and input management and drawing functions must be provided by
* the user (check library implementation for further details).
*
* #define PHYSAC_DEBUG
* Traces log messages when creating and destroying physics bodies and detects errors in physics
* calculations and reference exceptions; it is useful for debug purposes
*
* #define PHYSAC_MALLOC()
* #define PHYSAC_FREE()
* You can define your own malloc/free implementation replacing stdlib.h malloc()/free() functions.
* Otherwise it will include stdlib.h and use the C standard library malloc()/free() function.
*
*
* NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
* NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
*
* Use the following code to compile:
* gcc -o $(NAME_PART).exe $(FILE_NAME) -s -static -lraylib -lpthread -lopengl32 -lgdi32 -lwinmm -std=c99
*
* VERY THANKS TO:
* - raysan5: helped with library design
* - ficoos: added support for Linux
* - R8D8: added support for Linux
* - jubalh: fixed implementation of time calculations
* - a3f: fixed implementation of time calculations
* - define-private-public: added support for OSX
* - pamarcos: fixed implementation of physics steps
* - noshbar: fixed some memory leaks
*
*
* LICENSE: zlib/libpng
*
* Copyright (c) 2016-2025 Victor Fisac (github: @victorfisac)
*
* This software is provided "as-is", without any express or implied warranty. In no event
* will the authors be held liable for any damages arising from the use of this software.
*
* Permission is granted to anyone to use this software for any purpose, including commercial
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
*
* 1. The origin of this software must not be misrepresented; you must not claim that you
* wrote the original software. If you use this software in a product, an acknowledgment
* in the product documentation would be appreciated but is not required.
*
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
* as being the original software.
*
* 3. This notice may not be removed or altered from any source distribution.
*
**********************************************************************************************/
#if !defined(PHYSAC_H)
#define PHYSAC_H
// #define PHYSAC_STATIC
// #define PHYSAC_NO_THREADS
// #define PHYSAC_STANDALONE
// #define PHYSAC_DEBUG
#if defined(PHYSAC_STATIC)
#define PHYSACDEF static // Functions just visible to module including this file
#else
#if defined(__cplusplus)
#define PHYSACDEF extern "C" // Functions visible from other files (no name mangling of functions in C++)
#else
#define PHYSACDEF extern // Functions visible from other files
#endif
#endif
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
#define PHYSAC_MAX_BODIES 64
#define PHYSAC_MAX_MANIFOLDS 4096
#define PHYSAC_MAX_VERTICES 24
#define PHYSAC_CIRCLE_VERTICES 24
#define PHYSAC_FIXED_TIME 1.0f/60.0f
#define PHYSAC_COLLISION_ITERATIONS 20
#define PHYSAC_PENETRATION_ALLOWANCE 0.05f
#define PHYSAC_PENETRATION_CORRECTION 0.4f
#define PHYSAC_PI 3.14159265358979323846
#define PHYSAC_DEG2RAD (PHYSAC_PI/180.0f)
#define PHYSAC_MALLOC(size) malloc(size)
#define PHYSAC_FREE(ptr) free(ptr)
//----------------------------------------------------------------------------------
// Types and Structures Definition
// NOTE: Below types are required for PHYSAC_STANDALONE usage
//----------------------------------------------------------------------------------
#if defined(PHYSAC_STANDALONE)
// Vector2 type
typedef struct Vector2 {
float x;
float y;
} Vector2;
// Boolean type
#if !defined(_STDBOOL_H)
typedef enum { false, true } bool;
#define _STDBOOL_H
#endif
#endif
typedef enum PhysicsShapeType { PHYSICS_CIRCLE, PHYSICS_POLYGON } PhysicsShapeType;
// Previously defined to be used in PhysicsShape struct as circular dependencies
typedef struct PhysicsBodyData *PhysicsBody;
// Mat2 type (used for polygon shape rotation matrix)
typedef struct Mat2 {
float m00;
float m01;
float m10;
float m11;
} Mat2;
typedef struct PolygonData {
unsigned int vertexCount; // Current used vertex and normals count
Vector2 positions[PHYSAC_MAX_VERTICES]; // Polygon vertex positions vectors
Vector2 normals[PHYSAC_MAX_VERTICES]; // Polygon vertex normals vectors
} PolygonData;
typedef struct PhysicsShape {
PhysicsShapeType type; // Physics shape type (circle or polygon)
PhysicsBody body; // Shape physics body reference
float radius; // Circle shape radius (used for circle shapes)
Mat2 transform; // Vertices transform matrix 2x2
PolygonData vertexData; // Polygon shape vertices position and normals data (just used for polygon shapes)
} PhysicsShape;
typedef struct PhysicsBodyData {
unsigned int id; // Reference unique identifier
bool enabled; // Enabled dynamics state (collisions are calculated anyway)
Vector2 position; // Physics body shape pivot
Vector2 velocity; // Current linear velocity applied to position
Vector2 force; // Current linear force (reset to 0 every step)
float angularVelocity; // Current angular velocity applied to orient
float torque; // Current angular force (reset to 0 every step)
float orient; // Rotation in radians
float inertia; // Moment of inertia
float inverseInertia; // Inverse value of inertia
float mass; // Physics body mass
float inverseMass; // Inverse value of mass
float staticFriction; // Friction when the body has not movement (0 to 1)
float dynamicFriction; // Friction when the body has movement (0 to 1)
float restitution; // Restitution coefficient of the body (0 to 1)
bool useGravity; // Apply gravity force to dynamics
bool isGrounded; // Physics grounded on other body state
bool freezeOrient; // Physics rotation constraint
PhysicsShape shape; // Physics body shape information (type, radius, vertices, normals)
} PhysicsBodyData;
typedef struct PhysicsManifoldData {
unsigned int id; // Reference unique identifier
PhysicsBody bodyA; // Manifold first physics body reference
PhysicsBody bodyB; // Manifold second physics body reference
float penetration; // Depth of penetration from collision
Vector2 normal; // Normal direction vector from 'a' to 'b'
Vector2 contacts[2]; // Points of contact during collision
unsigned int contactsCount; // Current collision number of contacts
float restitution; // Mixed restitution during collision
float dynamicFriction; // Mixed dynamic friction during collision
float staticFriction; // Mixed static friction during collision
} PhysicsManifoldData, *PhysicsManifold;
#if defined(__cplusplus)
extern "C" { // Prevents name mangling of functions
#endif
//----------------------------------------------------------------------------------
// Module Functions Declaration
//----------------------------------------------------------------------------------
PHYSACDEF void InitPhysics(void); // Initializes physics values, pointers and creates physics loop thread
PHYSACDEF void RunPhysicsStep(void); // Run physics step, to be used if PHYSICS_NO_THREADS is set in your main loop
PHYSACDEF void SetPhysicsTimeStep(double delta); // Sets physics fixed time step in milliseconds. 1.666666 by default
PHYSACDEF bool IsPhysicsEnabled(void); // Returns true if physics thread is currently enabled
PHYSACDEF void SetPhysicsGravity(float x, float y); // Sets physics global gravity force
PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density); // Creates a new circle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density); // Creates a new rectangle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density); // Creates a new polygon physics body with generic parameters
PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force); // Adds a force to a physics body
PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount); // Adds an angular force to a physics body
PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force); // Shatters a polygon shape physics body to little physics bodies with explosion force
PHYSACDEF int GetPhysicsBodiesCount(void); // Returns the current amount of created physics bodies
PHYSACDEF PhysicsBody GetPhysicsBody(int index); // Returns a physics body of the bodies pool at a specific index
PHYSACDEF int GetPhysicsShapeType(int index); // Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
PHYSACDEF int GetPhysicsShapeVerticesCount(int index); // Returns the amount of vertices of a physics body shape
PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex); // Returns transformed position of a body shape (body position + vertex transformed position)
PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians); // Sets physics body shape transform based on radians parameter
PHYSACDEF void DestroyPhysicsBody(PhysicsBody body); // Unitializes and destroy a physics body
PHYSACDEF void ClosePhysics(void); // Unitializes physics pointers and closes physics loop thread
#if defined(__cplusplus)
}
#endif
#endif // PHYSAC_H
/***********************************************************************************
*
* PHYSAC IMPLEMENTATION
*
************************************************************************************/
#if defined(PHYSAC_IMPLEMENTATION)
#if !defined(PHYSAC_NO_THREADS)
#include <pthread.h> // Required for: pthread_t, pthread_create()
#endif
#if defined(PHYSAC_DEBUG)
#include <stdio.h> // Required for: printf()
#endif
#include <stdlib.h> // Required for: malloc(), free(), srand(), rand()
#include <math.h> // Required for: cosf(), sinf(), fabs(), sqrtf()
#include <stdint.h> // Required for: uint64_t
#if !defined(PHYSAC_STANDALONE)
#include "raymath.h" // Required for: Vector2Add(), Vector2Subtract()
#endif
// Time management functionality
#include <time.h> // Required for: time(), clock_gettime()
#if defined(__linux__)
#if _POSIX_C_SOURCE < 199309L
#undef _POSIX_C_SOURCE
#define _POSIX_C_SOURCE 199309L // Required for CLOCK_MONOTONIC if compiled with c99 without gnu ext.
#endif
#include <sys/time.h> // Required for: timespec
#elif defined(__APPLE__) // macOS also defines __MACH__
#include <mach/mach_time.h> // Required for: mach_absolute_time()
#elif defined(EMSCRIPTEN) // Emscripten uses the browser's time functions
#include <emscripten.h> // Required for: emscripten_get_now()
#endif
//----------------------------------------------------------------------------------
// Defines and Macros
//----------------------------------------------------------------------------------
#define min(a,b) (((a)<(b))?(a):(b))
#define max(a,b) (((a)>(b))?(a):(b))
#define PHYSAC_FLT_MAX 3.402823466e+38f
#define PHYSAC_EPSILON 0.000001f
#define PHYSAC_K 1.0f/3.0f
#define PHYSAC_VECTOR_ZERO (Vector2){ 0.0f, 0.0f }
//----------------------------------------------------------------------------------
// Global Variables Definition
//----------------------------------------------------------------------------------
#if !defined(PHYSAC_NO_THREADS)
static pthread_t physicsThreadId; // Physics thread id
#endif
static unsigned int usedMemory = 0; // Total allocated dynamic memory
static volatile bool physicsThreadEnabled = false; // Physics thread enabled state
static double baseTime = 0.0; // Offset time for MONOTONIC clock
static double startTime = 0.0; // Start time in milliseconds
static double deltaTime = 1.0/60.0/10.0 * 1000; // Delta time used for physics steps, in milliseconds
static double currentTime = 0.0; // Current time in milliseconds
static uint64_t frequency = 0; // Hi-res clock frequency
static double accumulator = 0.0; // Physics time step delta time accumulator
static unsigned int stepsCount = 0; // Total physics steps processed
static Vector2 gravityForce = { 0.0f, 9.81f }; // Physics world gravity force
static PhysicsBody bodies[PHYSAC_MAX_BODIES]; // Physics bodies pointers array
static unsigned int physicsBodiesCount = 0; // Physics world current bodies counter
static PhysicsManifold contacts[PHYSAC_MAX_MANIFOLDS]; // Physics bodies pointers array
static unsigned int physicsManifoldsCount = 0; // Physics world current manifolds counter
//----------------------------------------------------------------------------------
// Module Internal Functions Declaration
//----------------------------------------------------------------------------------
static int FindAvailableBodyIndex(); // Finds a valid index for a new physics body initialization
static PolygonData CreateRandomPolygon(float radius, int sides); // Creates a random polygon shape with max vertex distance from polygon pivot
static PolygonData CreateRectanglePolygon(Vector2 pos, Vector2 size); // Creates a rectangle polygon shape based on a min and max positions
static void *PhysicsLoop(void *arg); // Physics loop thread function
static void PhysicsStep(void); // Physics steps calculations (dynamics, collisions and position corrections)
static int FindAvailableManifoldIndex(); // Finds a valid index for a new manifold initialization
static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b); // Creates a new physics manifold to solve collision
static void DestroyPhysicsManifold(PhysicsManifold manifold); // Unitializes and destroys a physics manifold
static void SolvePhysicsManifold(PhysicsManifold manifold); // Solves a created physics manifold between two physics bodies
static void SolveCircleToCircle(PhysicsManifold manifold); // Solves collision between two circle shape physics bodies
static void SolveCircleToPolygon(PhysicsManifold manifold); // Solves collision between a circle to a polygon shape physics bodies
static void SolvePolygonToCircle(PhysicsManifold manifold); // Solves collision between a polygon to a circle shape physics bodies
static void SolveDifferentShapes(PhysicsManifold manifold, PhysicsBody bodyA, PhysicsBody bodyB); // Solve collision between two different types of shapes
static void SolvePolygonToPolygon(PhysicsManifold manifold); // Solves collision between two polygons shape physics bodies
static void IntegratePhysicsForces(PhysicsBody body); // Integrates physics forces into velocity
static void InitializePhysicsManifolds(PhysicsManifold manifold); // Initializes physics manifolds to solve collisions
static void IntegratePhysicsImpulses(PhysicsManifold manifold); // Integrates physics collisions impulses to solve collisions
static void IntegratePhysicsVelocity(PhysicsBody body); // Integrates physics velocity into position and forces
static void CorrectPhysicsPositions(PhysicsManifold manifold); // Corrects physics bodies positions based on manifolds collision information
static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB); // Finds polygon shapes axis least penetration
static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index); // Finds two polygon shapes incident face
static int Clip(Vector2 normal, float clip, Vector2 *faceA, Vector2 *faceB); // Calculates clipping based on a normal and two faces
static bool BiasGreaterThan(float valueA, float valueB); // Check if values are between bias range
static Vector2 TriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3); // Returns the barycenter of a triangle given by 3 points
static void InitTimer(void); // Initializes hi-resolution MONOTONIC timer
static uint64_t GetTimeCount(void); // Get hi-res MONOTONIC time measure in mseconds
static double GetCurrTime(void); // Get current time measure in milliseconds
// Math functions
static Vector2 MathCross(float value, Vector2 vector); // Returns the cross product of a vector and a value
static float MathCrossVector2(Vector2 v1, Vector2 v2); // Returns the cross product of two vectors
static float MathLenSqr(Vector2 vector); // Returns the len square root of a vector
static float MathDot(Vector2 v1, Vector2 v2); // Returns the dot product of two vectors
static inline float DistSqr(Vector2 v1, Vector2 v2); // Returns the square root of distance between two vectors
static void MathNormalize(Vector2 *vector); // Returns the normalized values of a vector
#if defined(PHYSAC_STANDALONE)
static Vector2 Vector2Add(Vector2 v1, Vector2 v2); // Returns the sum of two given vectors
static Vector2 Vector2Subtract(Vector2 v1, Vector2 v2); // Returns the subtract of two given vectors
#endif
static Mat2 Mat2Radians(float radians); // Creates a matrix 2x2 from a given radians value
static void Mat2Set(Mat2 *matrix, float radians); // Set values from radians to a created matrix 2x2
static inline Mat2 Mat2Transpose(Mat2 matrix); // Returns the transpose of a given matrix 2x2
static inline Vector2 Mat2MultiplyVector2(Mat2 matrix, Vector2 vector); // Multiplies a vector by a matrix 2x2
//----------------------------------------------------------------------------------
// Module Functions Definition
//----------------------------------------------------------------------------------
// Initializes physics values, pointers and creates physics loop thread
PHYSACDEF void InitPhysics(void)
{
#if !defined(PHYSAC_NO_THREADS)
// NOTE: if defined, user will need to create a thread for PhysicsThread function manually
// Create physics thread using POSIXS thread libraries
pthread_create(&physicsThreadId, NULL, &PhysicsLoop, NULL);
#endif
// Initialize high resolution timer
InitTimer();
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] physics module initialized successfully\n");
#endif
accumulator = 0.0;
}
// Returns true if physics thread is currently enabled
PHYSACDEF bool IsPhysicsEnabled(void)
{
return physicsThreadEnabled;
}
// Sets physics global gravity force
PHYSACDEF void SetPhysicsGravity(float x, float y)
{
gravityForce.x = x;
gravityForce.y = y;
}
// Creates a new circle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius, float density)
{
PhysicsBody newBody = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
usedMemory += sizeof(PhysicsBodyData);
int newId = FindAvailableBodyIndex();
if (newId != -1)
{
// Initialize new body with generic values
newBody->id = newId;
newBody->enabled = true;
newBody->position = pos;
newBody->velocity = PHYSAC_VECTOR_ZERO;
newBody->force = PHYSAC_VECTOR_ZERO;
newBody->angularVelocity = 0.0f;
newBody->torque = 0.0f;
newBody->orient = 0.0f;
newBody->shape.type = PHYSICS_CIRCLE;
newBody->shape.body = newBody;
newBody->shape.radius = radius;
newBody->shape.transform = Mat2Radians(0.0f);
newBody->shape.vertexData = (PolygonData) { 0 };
newBody->mass = PHYSAC_PI*radius*radius*density;
newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
newBody->inertia = newBody->mass*radius*radius;
newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
newBody->staticFriction = 0.4f;
newBody->dynamicFriction = 0.2f;
newBody->restitution = 0.0f;
newBody->useGravity = true;
newBody->isGrounded = false;
newBody->freezeOrient = false;
// Add new body to bodies pointers array and update bodies count
bodies[physicsBodiesCount] = newBody;
physicsBodiesCount++;
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] created polygon physics body id %i\n", newBody->id);
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] new physics body creation failed because there is any available id to use\n");
#endif
return newBody;
}
// Creates a new rectangle physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float width, float height, float density)
{
PhysicsBody newBody = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
usedMemory += sizeof(PhysicsBodyData);
int newId = FindAvailableBodyIndex();
if (newId != -1)
{
// Initialize new body with generic values
newBody->id = newId;
newBody->enabled = true;
newBody->position = pos;
newBody->velocity = (Vector2){ 0.0f };
newBody->force = (Vector2){ 0.0f };
newBody->angularVelocity = 0.0f;
newBody->torque = 0.0f;
newBody->orient = 0.0f;
newBody->shape.type = PHYSICS_POLYGON;
newBody->shape.body = newBody;
newBody->shape.radius = 0.0f;
newBody->shape.transform = Mat2Radians(0.0f);
newBody->shape.vertexData = CreateRectanglePolygon(pos, (Vector2){ width, height });
// Calculate centroid and moment of inertia
Vector2 center = { 0.0f, 0.0f };
float area = 0.0f;
float inertia = 0.0f;
for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
{
// Triangle vertices, third vertex implied as (0, 0)
Vector2 p1 = newBody->shape.vertexData.positions[i];
int nextIndex = (((i + 1) < newBody->shape.vertexData.vertexCount) ? (i + 1) : 0);
Vector2 p2 = newBody->shape.vertexData.positions[nextIndex];
float D = MathCrossVector2(p1, p2);
float triangleArea = D/2;
area += triangleArea;
// Use area to weight the centroid average, not just vertex position
center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
}
center.x *= 1.0f/area;
center.y *= 1.0f/area;
// Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
// Note: this is not really necessary
for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
{
newBody->shape.vertexData.positions[i].x -= center.x;
newBody->shape.vertexData.positions[i].y -= center.y;
}
newBody->mass = density*area;
newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
newBody->inertia = density*inertia;
newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
newBody->staticFriction = 0.4f;
newBody->dynamicFriction = 0.2f;
newBody->restitution = 0.0f;
newBody->useGravity = true;
newBody->isGrounded = false;
newBody->freezeOrient = false;
// Add new body to bodies pointers array and update bodies count
bodies[physicsBodiesCount] = newBody;
physicsBodiesCount++;
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] created polygon physics body id %i\n", newBody->id);
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] new physics body creation failed because there is any available id to use\n");
#endif
return newBody;
}
// Creates a new polygon physics body with generic parameters
PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius, int sides, float density)
{
PhysicsBody newBody = (PhysicsBody)PHYSAC_MALLOC(sizeof(PhysicsBodyData));
usedMemory += sizeof(PhysicsBodyData);
int newId = FindAvailableBodyIndex();
if (newId != -1)
{
// Initialize new body with generic values
newBody->id = newId;
newBody->enabled = true;
newBody->position = pos;
newBody->velocity = PHYSAC_VECTOR_ZERO;
newBody->force = PHYSAC_VECTOR_ZERO;
newBody->angularVelocity = 0.0f;
newBody->torque = 0.0f;
newBody->orient = 0.0f;
newBody->shape.type = PHYSICS_POLYGON;
newBody->shape.body = newBody;
newBody->shape.transform = Mat2Radians(0.0f);
newBody->shape.vertexData = CreateRandomPolygon(radius, sides);
// Calculate centroid and moment of inertia
Vector2 center = { 0.0f, 0.0f };
float area = 0.0f;
float inertia = 0.0f;
for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
{
// Triangle vertices, third vertex implied as (0, 0)
Vector2 position1 = newBody->shape.vertexData.positions[i];
int nextIndex = (((i + 1) < newBody->shape.vertexData.vertexCount) ? (i + 1) : 0);
Vector2 position2 = newBody->shape.vertexData.positions[nextIndex];
float cross = MathCrossVector2(position1, position2);
float triangleArea = cross/2;
area += triangleArea;
// Use area to weight the centroid average, not just vertex position
center.x += triangleArea*PHYSAC_K*(position1.x + position2.x);
center.y += triangleArea*PHYSAC_K*(position1.y + position2.y);
float intx2 = position1.x*position1.x + position2.x*position1.x + position2.x*position2.x;
float inty2 = position1.y*position1.y + position2.y*position1.y + position2.y*position2.y;
inertia += (0.25f*PHYSAC_K*cross)*(intx2 + inty2);
}
center.x *= 1.0f/area;
center.y *= 1.0f/area;
// Translate vertices to centroid (make the centroid (0, 0) for the polygon in model space)
// Note: this is not really necessary
for (int i = 0; i < newBody->shape.vertexData.vertexCount; i++)
{
newBody->shape.vertexData.positions[i].x -= center.x;
newBody->shape.vertexData.positions[i].y -= center.y;
}
newBody->mass = density*area;
newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
newBody->inertia = density*inertia;
newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
newBody->staticFriction = 0.4f;
newBody->dynamicFriction = 0.2f;
newBody->restitution = 0.0f;
newBody->useGravity = true;
newBody->isGrounded = false;
newBody->freezeOrient = false;
// Add new body to bodies pointers array and update bodies count
bodies[physicsBodiesCount] = newBody;
physicsBodiesCount++;
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] created polygon physics body id %i\n", newBody->id);
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] new physics body creation failed because there is any available id to use\n");
#endif
return newBody;
}
// Adds a force to a physics body
PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force)
{
if (body != NULL)
body->force = Vector2Add(body->force, force);
}
// Adds an angular force to a physics body
PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount)
{
if (body != NULL)
body->torque += amount;
}
// Shatters a polygon shape physics body to little physics bodies with explosion force
PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float force)
{
if (body != NULL)
{
if (body->shape.type == PHYSICS_POLYGON)
{
PolygonData vertexData = body->shape.vertexData;
bool collision = false;
for (int i = 0; i < vertexData.vertexCount; i++)
{
Vector2 positionA = body->position;
Vector2 positionB = Mat2MultiplyVector2(body->shape.transform, Vector2Add(body->position, vertexData.positions[i]));
int nextIndex = (((i + 1) < vertexData.vertexCount) ? (i + 1) : 0);
Vector2 positionC = Mat2MultiplyVector2(body->shape.transform, Vector2Add(body->position, vertexData.positions[nextIndex]));
// Check collision between each triangle
float alpha = ((positionB.y - positionC.y)*(position.x - positionC.x) + (positionC.x - positionB.x)*(position.y - positionC.y))/
((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
float beta = ((positionC.y - positionA.y)*(position.x - positionC.x) + (positionA.x - positionC.x)*(position.y - positionC.y))/
((positionB.y - positionC.y)*(positionA.x - positionC.x) + (positionC.x - positionB.x)*(positionA.y - positionC.y));
float gamma = 1.0f - alpha - beta;
if ((alpha > 0.0f) && (beta > 0.0f) && (gamma > 0.0f))
{
collision = true;
break;
}
}
if (collision)
{
int count = vertexData.vertexCount;
Vector2 bodyPos = body->position;
Vector2 *vertices = (Vector2*)PHYSAC_MALLOC(sizeof(Vector2) * count);
Mat2 trans = body->shape.transform;
for (int i = 0; i < count; i++)
vertices[i] = vertexData.positions[i];
// Destroy shattered physics body
DestroyPhysicsBody(body);
for (int i = 0; i < count; i++)
{
int nextIndex = (((i + 1) < count) ? (i + 1) : 0);
Vector2 center = TriangleBarycenter(vertices[i], vertices[nextIndex], PHYSAC_VECTOR_ZERO);
center = Vector2Add(bodyPos, center);
Vector2 offset = Vector2Subtract(center, bodyPos);
PhysicsBody newBody = CreatePhysicsBodyPolygon(center, 10, 3, 10); // Create polygon physics body with relevant values
PolygonData newData = { 0 };
newData.vertexCount = 3;
newData.positions[0] = Vector2Subtract(vertices[i], offset);
newData.positions[1] = Vector2Subtract(vertices[nextIndex], offset);
newData.positions[2] = Vector2Subtract(position, center);
// Separate vertices to avoid unnecessary physics collisions
newData.positions[0].x *= 0.95f;
newData.positions[0].y *= 0.95f;
newData.positions[1].x *= 0.95f;
newData.positions[1].y *= 0.95f;
newData.positions[2].x *= 0.95f;
newData.positions[2].y *= 0.95f;
// Calculate polygon faces normals
for (int j = 0; j < newData.vertexCount; j++)
{
int nextVertex = (((j + 1) < newData.vertexCount) ? (j + 1) : 0);
Vector2 face = Vector2Subtract(newData.positions[nextVertex], newData.positions[j]);
newData.normals[j] = (Vector2){ face.y, -face.x };
MathNormalize(&newData.normals[j]);
}
// Apply computed vertex data to new physics body shape
newBody->shape.vertexData = newData;
newBody->shape.transform = trans;
// Calculate centroid and moment of inertia
center = PHYSAC_VECTOR_ZERO;
float area = 0.0f;
float inertia = 0.0f;
for (int j = 0; j < newBody->shape.vertexData.vertexCount; j++)
{
// Triangle vertices, third vertex implied as (0, 0)
Vector2 p1 = newBody->shape.vertexData.positions[j];
int nextVertex = (((j + 1) < newBody->shape.vertexData.vertexCount) ? (j + 1) : 0);
Vector2 p2 = newBody->shape.vertexData.positions[nextVertex];
float D = MathCrossVector2(p1, p2);
float triangleArea = D/2;
area += triangleArea;
// Use area to weight the centroid average, not just vertex position
center.x += triangleArea*PHYSAC_K*(p1.x + p2.x);
center.y += triangleArea*PHYSAC_K*(p1.y + p2.y);
float intx2 = p1.x*p1.x + p2.x*p1.x + p2.x*p2.x;
float inty2 = p1.y*p1.y + p2.y*p1.y + p2.y*p2.y;
inertia += (0.25f*PHYSAC_K*D)*(intx2 + inty2);
}
center.x *= 1.0f/area;
center.y *= 1.0f/area;
newBody->mass = area;
newBody->inverseMass = ((newBody->mass != 0.0f) ? 1.0f/newBody->mass : 0.0f);
newBody->inertia = inertia;
newBody->inverseInertia = ((newBody->inertia != 0.0f) ? 1.0f/newBody->inertia : 0.0f);
// Calculate explosion force direction
Vector2 pointA = newBody->position;
Vector2 pointB = Vector2Subtract(newData.positions[1], newData.positions[0]);
pointB.x /= 2.0f;
pointB.y /= 2.0f;
Vector2 forceDirection = Vector2Subtract(Vector2Add(pointA, Vector2Add(newData.positions[0], pointB)), newBody->position);
MathNormalize(&forceDirection);
forceDirection.x *= force;
forceDirection.y *= force;
// Apply force to new physics body
PhysicsAddForce(newBody, forceDirection);
}
PHYSAC_FREE(vertices);
}
}
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error when trying to shatter a null reference physics body");
#endif
}
// Returns the current amount of created physics bodies
PHYSACDEF int GetPhysicsBodiesCount(void)
{
return physicsBodiesCount;
}
// Returns a physics body of the bodies pool at a specific index
PHYSACDEF PhysicsBody GetPhysicsBody(int index)
{
if (index < physicsBodiesCount)
{
if (bodies[index] == NULL)
{
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] error when trying to get a null reference physics body");
#endif
}
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] physics body index is out of bounds");
#endif
return bodies[index];
}
// Returns the physics body shape type (PHYSICS_CIRCLE or PHYSICS_POLYGON)
PHYSACDEF int GetPhysicsShapeType(int index)
{
int result = -1;
if (index < physicsBodiesCount)
{
if (bodies[index] != NULL)
result = bodies[index]->shape.type;
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error when trying to get a null reference physics body");
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] physics body index is out of bounds");
#endif
return result;
}
// Returns the amount of vertices of a physics body shape
PHYSACDEF int GetPhysicsShapeVerticesCount(int index)
{
int result = 0;
if (index < physicsBodiesCount)
{
if (bodies[index] != NULL)
{
switch (bodies[index]->shape.type)
{
case PHYSICS_CIRCLE: result = PHYSAC_CIRCLE_VERTICES; break;
case PHYSICS_POLYGON: result = bodies[index]->shape.vertexData.vertexCount; break;
default: break;
}
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error when trying to get a null reference physics body");
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] physics body index is out of bounds");
#endif
return result;
}
// Returns transformed position of a body shape (body position + vertex transformed position)
PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex)
{
Vector2 position = { 0.0f, 0.0f };
if (body != NULL)
{
switch (body->shape.type)
{
case PHYSICS_CIRCLE:
{
position.x = body->position.x + cosf(360.0f/PHYSAC_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
position.y = body->position.y + sinf(360.0f/PHYSAC_CIRCLE_VERTICES*vertex*PHYSAC_DEG2RAD)*body->shape.radius;
} break;
case PHYSICS_POLYGON:
{
PolygonData vertexData = body->shape.vertexData;
position = Vector2Add(body->position, Mat2MultiplyVector2(body->shape.transform, vertexData.positions[vertex]));
} break;
default: break;
}
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error when trying to get a null reference physics body");
#endif
return position;
}
// Sets physics body shape transform based on radians parameter
PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians)
{
if (body != NULL)
{
body->orient = radians;
if (body->shape.type == PHYSICS_POLYGON)
body->shape.transform = Mat2Radians(radians);
}
}
// Unitializes and destroys a physics body
PHYSACDEF void DestroyPhysicsBody(PhysicsBody body)
{
if (body != NULL)
{
int id = body->id;
int index = -1;
for (int i = 0; i < physicsBodiesCount; i++)
{
if (bodies[i]->id == id)
{
index = i;
break;
}
}
if (index == -1)
{
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] Not possible to find body id %i in pointers array\n", id);
#endif
return;
}
// Free body allocated memory
PHYSAC_FREE(body);
usedMemory -= sizeof(PhysicsBodyData);
bodies[index] = NULL;
// Reorder physics bodies pointers array and its catched index
for (int i = index; i < physicsBodiesCount; i++)
{
if ((i + 1) < physicsBodiesCount)
bodies[i] = bodies[i + 1];
}
// Update physics bodies count
physicsBodiesCount--;
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] destroyed physics body id %i\n", id);
#endif
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error trying to destroy a null referenced body\n");
#endif
}
// Unitializes physics pointers and exits physics loop thread
PHYSACDEF void ClosePhysics(void)
{
// Exit physics loop thread
physicsThreadEnabled = false;
#if !defined(PHYSAC_NO_THREADS)
pthread_join(physicsThreadId, NULL);
#endif
// Unitialize physics manifolds dynamic memory allocations
for (int i = physicsManifoldsCount - 1; i >= 0; i--)
DestroyPhysicsManifold(contacts[i]);
// Unitialize physics bodies dynamic memory allocations
for (int i = physicsBodiesCount - 1; i >= 0; i--)
DestroyPhysicsBody(bodies[i]);
#if defined(PHYSAC_DEBUG)
if (physicsBodiesCount > 0 || usedMemory != 0)
printf("[PHYSAC] physics module closed with %i still allocated bodies [MEMORY: %i bytes]\n", physicsBodiesCount, usedMemory);
else if (physicsManifoldsCount > 0 || usedMemory != 0)
printf("[PHYSAC] physics module closed with %i still allocated manifolds [MEMORY: %i bytes]\n", physicsManifoldsCount, usedMemory);
else
printf("[PHYSAC] physics module closed successfully\n");
#endif
}
//----------------------------------------------------------------------------------
// Module Internal Functions Definition
//----------------------------------------------------------------------------------
// Finds a valid index for a new physics body initialization
static int FindAvailableBodyIndex()
{
int index = -1;
for (int i = 0; i < PHYSAC_MAX_BODIES; i++)
{
int currentId = i;
// Check if current id already exist in other physics body
for (int k = 0; k < physicsBodiesCount; k++)
{
if (bodies[k]->id == currentId)
{
currentId++;
break;
}
}
// If it is not used, use it as new physics body id
if (currentId == i)
{
index = i;
break;
}
}
return index;
}
// Creates a random polygon shape with max vertex distance from polygon pivot
static PolygonData CreateRandomPolygon(float radius, int sides)
{
PolygonData data = { 0 };
data.vertexCount = sides;
// Calculate polygon vertices positions
for (int i = 0; i < data.vertexCount; i++)
{
data.positions[i].x = cosf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
data.positions[i].y = sinf(360.0f/sides*i*PHYSAC_DEG2RAD)*radius;
}
// Calculate polygon faces normals
for (int i = 0; i < data.vertexCount; i++)
{
int nextIndex = (((i + 1) < sides) ? (i + 1) : 0);
Vector2 face = Vector2Subtract(data.positions[nextIndex], data.positions[i]);
data.normals[i] = (Vector2){ face.y, -face.x };
MathNormalize(&data.normals[i]);
}
return data;
}
// Creates a rectangle polygon shape based on a min and max positions
static PolygonData CreateRectanglePolygon(Vector2 pos, Vector2 size)
{
PolygonData data = { 0 };
data.vertexCount = 4;
// Calculate polygon vertices positions
data.positions[0] = (Vector2){ pos.x + size.x/2, pos.y - size.y/2 };
data.positions[1] = (Vector2){ pos.x + size.x/2, pos.y + size.y/2 };
data.positions[2] = (Vector2){ pos.x - size.x/2, pos.y + size.y/2 };
data.positions[3] = (Vector2){ pos.x - size.x/2, pos.y - size.y/2 };
// Calculate polygon faces normals
for (int i = 0; i < data.vertexCount; i++)
{
int nextIndex = (((i + 1) < data.vertexCount) ? (i + 1) : 0);
Vector2 face = Vector2Subtract(data.positions[nextIndex], data.positions[i]);
data.normals[i] = (Vector2){ face.y, -face.x };
MathNormalize(&data.normals[i]);
}
return data;
}
// Physics loop thread function
static void *PhysicsLoop(void *arg)
{
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] physics thread created successfully\n");
#endif
// Initialize physics loop thread values
physicsThreadEnabled = true;
// Physics update loop
while (physicsThreadEnabled)
{
RunPhysicsStep();
struct timespec req = { 0 };
req.tv_sec = 0;
req.tv_nsec = PHYSAC_FIXED_TIME*1000*1000;
nanosleep(&req, NULL);
}
return 0;
}
// Physics steps calculations (dynamics, collisions and position corrections)
static void PhysicsStep(void)
{
// Update current steps count
stepsCount++;
// Clear previous generated collisions information
for (int i = physicsManifoldsCount - 1; i >= 0; i--)
{
PhysicsManifold manifold = contacts[i];
if (manifold != NULL)
DestroyPhysicsManifold(manifold);
}
// Reset physics bodies grounded state
for (int i = 0; i < physicsBodiesCount; i++)
{
PhysicsBody body = bodies[i];
body->isGrounded = false;
}
// Generate new collision information
for (int i = 0; i < physicsBodiesCount; i++)
{
PhysicsBody bodyA = bodies[i];
if (bodyA != NULL)
{
for (int j = i + 1; j < physicsBodiesCount; j++)
{
PhysicsBody bodyB = bodies[j];
if (bodyB != NULL)
{
if ((bodyA->inverseMass == 0) && (bodyB->inverseMass == 0))
continue;
PhysicsManifold manifold = CreatePhysicsManifold(bodyA, bodyB);
SolvePhysicsManifold(manifold);
if (manifold->contactsCount > 0)
{
// Create a new manifold with same information as previously solved manifold and add it to the manifolds pool last slot
PhysicsManifold newManifold = CreatePhysicsManifold(bodyA, bodyB);
newManifold->penetration = manifold->penetration;
newManifold->normal = manifold->normal;
newManifold->contacts[0] = manifold->contacts[0];
newManifold->contacts[1] = manifold->contacts[1];
newManifold->contactsCount = manifold->contactsCount;
newManifold->restitution = manifold->restitution;
newManifold->dynamicFriction = manifold->dynamicFriction;
newManifold->staticFriction = manifold->staticFriction;
}
}
}
}
}
// Integrate forces to physics bodies
for (int i = 0; i < physicsBodiesCount; i++)
{
PhysicsBody body = bodies[i];
if (body != NULL)
IntegratePhysicsForces(body);
}
// Initialize physics manifolds to solve collisions
for (int i = 0; i < physicsManifoldsCount; i++)
{
PhysicsManifold manifold = contacts[i];
if (manifold != NULL)
InitializePhysicsManifolds(manifold);
}
// Integrate physics collisions impulses to solve collisions
for (int i = 0; i < PHYSAC_COLLISION_ITERATIONS; i++)
{
for (int j = 0; j < physicsManifoldsCount; j++)
{
PhysicsManifold manifold = contacts[j];
if (manifold != NULL)
IntegratePhysicsImpulses(manifold);
}
}
// Integrate velocity to physics bodies
for (int i = 0; i < physicsBodiesCount; i++)
{
PhysicsBody body = bodies[i];
if (body != NULL)
IntegratePhysicsVelocity(body);
}
// Correct physics bodies positions based on manifolds collision information
for (int i = 0; i < physicsManifoldsCount; i++)
{
PhysicsManifold manifold = contacts[i];
if (manifold != NULL)
CorrectPhysicsPositions(manifold);
}
// Clear physics bodies forces
for (int i = 0; i < physicsBodiesCount; i++)
{
PhysicsBody body = bodies[i];
if (body != NULL)
{
body->force = PHYSAC_VECTOR_ZERO;
body->torque = 0.0f;
}
}
}
// Wrapper to ensure PhysicsStep is run with at a fixed time step
PHYSACDEF void RunPhysicsStep(void)
{
// Calculate current time
currentTime = GetCurrTime();
// Calculate current delta time
double delta = currentTime - startTime;
// Store the time elapsed since the last frame began
accumulator += delta;
// Fixed time stepping loop
while (accumulator >= deltaTime)
{
PhysicsStep();
accumulator -= deltaTime;
}
// Record the starting of this frame
startTime = currentTime;
}
PHYSACDEF void SetPhysicsTimeStep(double delta)
{
deltaTime = delta;
}
// Finds a valid index for a new manifold initialization
static int FindAvailableManifoldIndex()
{
int id = physicsManifoldsCount + 1;
if (id >= PHYSAC_MAX_MANIFOLDS)
{
return -1;
}
return id;
}
// Creates a new physics manifold to solve collision
static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b)
{
PhysicsManifold newManifold = (PhysicsManifold)PHYSAC_MALLOC(sizeof(PhysicsManifoldData));
usedMemory += sizeof(PhysicsManifoldData);
int newId = FindAvailableManifoldIndex();
if (newId != -1)
{
// Initialize new manifold with generic values
newManifold->id = newId;
newManifold->bodyA = a;
newManifold->bodyB = b;
newManifold->penetration = 0;
newManifold->normal = PHYSAC_VECTOR_ZERO;
newManifold->contacts[0] = PHYSAC_VECTOR_ZERO;
newManifold->contacts[1] = PHYSAC_VECTOR_ZERO;
newManifold->contactsCount = 0;
newManifold->restitution = 0.0f;
newManifold->dynamicFriction = 0.0f;
newManifold->staticFriction = 0.0f;
// Add new body to bodies pointers array and update bodies count
contacts[physicsManifoldsCount] = newManifold;
physicsManifoldsCount++;
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] new physics manifold creation failed because there is any available id to use\n");
#endif
return newManifold;
}
// Unitializes and destroys a physics manifold
static void DestroyPhysicsManifold(PhysicsManifold manifold)
{
if (manifold != NULL)
{
int id = manifold->id;
int index = -1;
for (int i = 0; i < physicsManifoldsCount; i++)
{
if (contacts[i]->id == id)
{
index = i;
break;
}
}
if (index == -1)
{
#if defined(PHYSAC_DEBUG)
printf("[PHYSAC] Not possible to manifold id %i in pointers array\n", id);
#endif
return;
}
// Free manifold allocated memory
PHYSAC_FREE(manifold);
usedMemory -= sizeof(PhysicsManifoldData);
contacts[index] = NULL;
// Reorder physics manifolds pointers array and its catched index
for (int i = index; i < physicsManifoldsCount; i++)
{
if ((i + 1) < physicsManifoldsCount)
contacts[i] = contacts[i + 1];
}
// Update physics manifolds count
physicsManifoldsCount--;
}
#if defined(PHYSAC_DEBUG)
else
printf("[PHYSAC] error trying to destroy a null referenced manifold\n");
#endif
}
// Solves a created physics manifold between two physics bodies
static void SolvePhysicsManifold(PhysicsManifold manifold)
{
switch (manifold->bodyA->shape.type)
{
case PHYSICS_CIRCLE:
{
switch (manifold->bodyB->shape.type)
{
case PHYSICS_CIRCLE: SolveCircleToCircle(manifold); break;
case PHYSICS_POLYGON: SolveCircleToPolygon(manifold); break;
default: break;
}
} break;
case PHYSICS_POLYGON:
{
switch (manifold->bodyB->shape.type)
{
case PHYSICS_CIRCLE: SolvePolygonToCircle(manifold); break;
case PHYSICS_POLYGON: SolvePolygonToPolygon(manifold); break;
default: break;
}
} break;
default: break;
}
// Update physics body grounded state if normal direction is down and grounded state is not set yet in previous manifolds
if (!manifold->bodyB->isGrounded)
manifold->bodyB->isGrounded = (manifold->normal.y < 0);
}
// Solves collision between two circle shape physics bodies
static void SolveCircleToCircle(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
// Calculate translational vector, which is normal
Vector2 normal = Vector2Subtract(bodyB->position, bodyA->position);
float distSqr = MathLenSqr(normal);
float radius = bodyA->shape.radius + bodyB->shape.radius;
// Check if circles are not in contact
if (distSqr >= radius*radius)
{
manifold->contactsCount = 0;
return;
}
float distance = sqrtf(distSqr);
manifold->contactsCount = 1;
if (distance == 0.0f)
{
manifold->penetration = bodyA->shape.radius;
manifold->normal = (Vector2){ 1.0f, 0.0f };
manifold->contacts[0] = bodyA->position;
}
else
{
manifold->penetration = radius - distance;
manifold->normal = (Vector2){ normal.x/distance, normal.y/distance }; // Faster than using MathNormalize() due to sqrt is already performed
manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
}
// Update physics body grounded state if normal direction is down
if (!bodyA->isGrounded)
bodyA->isGrounded = (manifold->normal.y < 0);
}
// Solves collision between a circle to a polygon shape physics bodies
static void SolveCircleToPolygon(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
SolveDifferentShapes(manifold, bodyA, bodyB);
}
// Solves collision between a circle to a polygon shape physics bodies
static void SolvePolygonToCircle(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
SolveDifferentShapes(manifold, bodyB, bodyA);
manifold->normal.x *= -1.0f;
manifold->normal.y *= -1.0f;
}
// Solve collision between two different types of shapes
static void SolveDifferentShapes(PhysicsManifold manifold, PhysicsBody bodyA, PhysicsBody bodyB)
{
manifold->contactsCount = 0;
// Transform circle center to polygon transform space
Vector2 center = bodyA->position;
center = Mat2MultiplyVector2(Mat2Transpose(bodyB->shape.transform), Vector2Subtract(center, bodyB->position));
// Find edge with minimum penetration
// It is the same concept as using support points in SolvePolygonToPolygon
float separation = -PHYSAC_FLT_MAX;
int faceNormal = 0;
PolygonData vertexData = bodyB->shape.vertexData;
for (int i = 0; i < vertexData.vertexCount; i++)
{
float currentSeparation = MathDot(vertexData.normals[i], Vector2Subtract(center, vertexData.positions[i]));
if (currentSeparation > bodyA->shape.radius)
return;
if (currentSeparation > separation)
{
separation = currentSeparation;
faceNormal = i;
}
}
// Grab face's vertices
Vector2 v1 = vertexData.positions[faceNormal];
int nextIndex = (((faceNormal + 1) < vertexData.vertexCount) ? (faceNormal + 1) : 0);
Vector2 v2 = vertexData.positions[nextIndex];
// Check to see if center is within polygon
if (separation < PHYSAC_EPSILON)
{
manifold->contactsCount = 1;
Vector2 normal = Mat2MultiplyVector2(bodyB->shape.transform, vertexData.normals[faceNormal]);
manifold->normal = (Vector2){ -normal.x, -normal.y };
manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
manifold->penetration = bodyA->shape.radius;
return;
}
// Determine which voronoi region of the edge center of circle lies within
float dot1 = MathDot(Vector2Subtract(center, v1), Vector2Subtract(v2, v1));
float dot2 = MathDot(Vector2Subtract(center, v2), Vector2Subtract(v1, v2));
manifold->penetration = bodyA->shape.radius - separation;
if (dot1 <= 0.0f) // Closest to v1
{
if (DistSqr(center, v1) > bodyA->shape.radius*bodyA->shape.radius)
return;
manifold->contactsCount = 1;
Vector2 normal = Vector2Subtract(v1, center);
normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
MathNormalize(&normal);
manifold->normal = normal;
v1 = Mat2MultiplyVector2(bodyB->shape.transform, v1);
v1 = Vector2Add(v1, bodyB->position);
manifold->contacts[0] = v1;
}
else if (dot2 <= 0.0f) // Closest to v2
{
if (DistSqr(center, v2) > bodyA->shape.radius*bodyA->shape.radius)
return;
manifold->contactsCount = 1;
Vector2 normal = Vector2Subtract(v2, center);
v2 = Mat2MultiplyVector2(bodyB->shape.transform, v2);
v2 = Vector2Add(v2, bodyB->position);
manifold->contacts[0] = v2;
normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
MathNormalize(&normal);
manifold->normal = normal;
}
else // Closest to face
{
Vector2 normal = vertexData.normals[faceNormal];
if (MathDot(Vector2Subtract(center, v1), normal) > bodyA->shape.radius)
return;
normal = Mat2MultiplyVector2(bodyB->shape.transform, normal);
manifold->normal = (Vector2){ -normal.x, -normal.y };
manifold->contacts[0] = (Vector2){ manifold->normal.x*bodyA->shape.radius + bodyA->position.x, manifold->normal.y*bodyA->shape.radius + bodyA->position.y };
manifold->contactsCount = 1;
}
}
// Solves collision between two polygons shape physics bodies
static void SolvePolygonToPolygon(PhysicsManifold manifold)
{
if ((manifold->bodyA == NULL) || (manifold->bodyB == NULL))
return;
PhysicsShape bodyA = manifold->bodyA->shape;
PhysicsShape bodyB = manifold->bodyB->shape;
manifold->contactsCount = 0;
// Check for separating axis with A shape's face planes
int faceA = 0;
float penetrationA = FindAxisLeastPenetration(&faceA, bodyA, bodyB);
if (penetrationA >= 0.0f)
return;
// Check for separating axis with B shape's face planes
int faceB = 0;
float penetrationB = FindAxisLeastPenetration(&faceB, bodyB, bodyA);
if (penetrationB >= 0.0f)
return;
int referenceIndex = 0;
bool flip = false; // Always point from A shape to B shape
PhysicsShape refPoly; // Reference
PhysicsShape incPoly; // Incident
// Determine which shape contains reference face
if (BiasGreaterThan(penetrationA, penetrationB))
{
refPoly = bodyA;
incPoly = bodyB;
referenceIndex = faceA;
}
else
{
refPoly = bodyB;
incPoly = bodyA;
referenceIndex = faceB;
flip = true;
}
// World space incident face
Vector2 incidentFace[2];
FindIncidentFace(&incidentFace[0], &incidentFace[1], refPoly, incPoly, referenceIndex);
// Setup reference face vertices
PolygonData refData = refPoly.vertexData;
Vector2 v1 = refData.positions[referenceIndex];
referenceIndex = (((referenceIndex + 1) < refData.vertexCount) ? (referenceIndex + 1) : 0);
Vector2 v2 = refData.positions[referenceIndex];
// Transform vertices to world space
v1 = Mat2MultiplyVector2(refPoly.transform, v1);
v1 = Vector2Add(v1, refPoly.body->position);
v2 = Mat2MultiplyVector2(refPoly.transform, v2);
v2 = Vector2Add(v2, refPoly.body->position);
// Calculate reference face side normal in world space
Vector2 sidePlaneNormal = Vector2Subtract(v2, v1);
MathNormalize(&sidePlaneNormal);
// Orthogonalize
Vector2 refFaceNormal = { sidePlaneNormal.y, -sidePlaneNormal.x };
float refC = MathDot(refFaceNormal, v1);
float negSide = MathDot(sidePlaneNormal, v1)*-1;
float posSide = MathDot(sidePlaneNormal, v2);
// Clip incident face to reference face side planes (due to floating point error, possible to not have required points
if (Clip((Vector2){ -sidePlaneNormal.x, -sidePlaneNormal.y }, negSide, &incidentFace[0], &incidentFace[1]) < 2)
return;
if (Clip(sidePlaneNormal, posSide, &incidentFace[0], &incidentFace[1]) < 2)
return;
// Flip normal if required
manifold->normal = (flip ? (Vector2){ -refFaceNormal.x, -refFaceNormal.y } : refFaceNormal);
// Keep points behind reference face
int currentPoint = 0; // Clipped points behind reference face
float separation = MathDot(refFaceNormal, incidentFace[0]) - refC;
if (separation <= 0.0f)
{
manifold->contacts[currentPoint] = incidentFace[0];
manifold->penetration = -separation;
currentPoint++;
}
else
manifold->penetration = 0.0f;
separation = MathDot(refFaceNormal, incidentFace[1]) - refC;
if (separation <= 0.0f)
{
manifold->contacts[currentPoint] = incidentFace[1];
manifold->penetration += -separation;
currentPoint++;
// Calculate total penetration average
manifold->penetration /= currentPoint;
}
manifold->contactsCount = currentPoint;
}
// Integrates physics forces into velocity
static void IntegratePhysicsForces(PhysicsBody body)
{
if ((body == NULL) || (body->inverseMass == 0.0f) || !body->enabled)
return;
body->velocity.x += (body->force.x*body->inverseMass)*(deltaTime/2.0);
body->velocity.y += (body->force.y*body->inverseMass)*(deltaTime/2.0);
if (body->useGravity)
{
body->velocity.x += gravityForce.x*(deltaTime/1000/2.0);
body->velocity.y += gravityForce.y*(deltaTime/1000/2.0);
}
if (!body->freezeOrient)
body->angularVelocity += body->torque*body->inverseInertia*(deltaTime/2.0);
}
// Initializes physics manifolds to solve collisions
static void InitializePhysicsManifolds(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
// Calculate average restitution, static and dynamic friction
manifold->restitution = sqrtf(bodyA->restitution*bodyB->restitution);
manifold->staticFriction = sqrtf(bodyA->staticFriction*bodyB->staticFriction);
manifold->dynamicFriction = sqrtf(bodyA->dynamicFriction*bodyB->dynamicFriction);
for (int i = 0; i < manifold->contactsCount; i++)
{
// Caculate radius from center of mass to contact
Vector2 radiusA = Vector2Subtract(manifold->contacts[i], bodyA->position);
Vector2 radiusB = Vector2Subtract(manifold->contacts[i], bodyB->position);
Vector2 crossA = MathCross(bodyA->angularVelocity, radiusA);
Vector2 crossB = MathCross(bodyB->angularVelocity, radiusB);
Vector2 radiusV = { 0.0f, 0.0f };
radiusV.x = bodyB->velocity.x + crossB.x - bodyA->velocity.x - crossA.x;
radiusV.y = bodyB->velocity.y + crossB.y - bodyA->velocity.y - crossA.y;
// Determine if we should perform a resting collision or not;
// The idea is if the only thing moving this object is gravity, then the collision should be performed without any restitution
if (MathLenSqr(radiusV) < (MathLenSqr((Vector2){ gravityForce.x*deltaTime/1000, gravityForce.y*deltaTime/1000 }) + PHYSAC_EPSILON))
manifold->restitution = 0;
}
}
// Integrates physics collisions impulses to solve collisions
static void IntegratePhysicsImpulses(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
// Early out and positional correct if both objects have infinite mass
if (fabs(bodyA->inverseMass + bodyB->inverseMass) <= PHYSAC_EPSILON)
{
bodyA->velocity = PHYSAC_VECTOR_ZERO;
bodyB->velocity = PHYSAC_VECTOR_ZERO;
return;
}
for (int i = 0; i < manifold->contactsCount; i++)
{
// Calculate radius from center of mass to contact
Vector2 radiusA = Vector2Subtract(manifold->contacts[i], bodyA->position);
Vector2 radiusB = Vector2Subtract(manifold->contacts[i], bodyB->position);
// Calculate relative velocity
Vector2 radiusV = { 0.0f, 0.0f };
radiusV.x = bodyB->velocity.x + MathCross(bodyB->angularVelocity, radiusB).x - bodyA->velocity.x - MathCross(bodyA->angularVelocity, radiusA).x;
radiusV.y = bodyB->velocity.y + MathCross(bodyB->angularVelocity, radiusB).y - bodyA->velocity.y - MathCross(bodyA->angularVelocity, radiusA).y;
// Relative velocity along the normal
float contactVelocity = MathDot(radiusV, manifold->normal);
// Do not resolve if velocities are separating
if (contactVelocity > 0.0f)
return;
float raCrossN = MathCrossVector2(radiusA, manifold->normal);
float rbCrossN = MathCrossVector2(radiusB, manifold->normal);
float inverseMassSum = bodyA->inverseMass + bodyB->inverseMass + (raCrossN*raCrossN)*bodyA->inverseInertia + (rbCrossN*rbCrossN)*bodyB->inverseInertia;
// Calculate impulse scalar value
float impulse = -(1.0f + manifold->restitution)*contactVelocity;
impulse /= inverseMassSum;
impulse /= (float)manifold->contactsCount;
// Apply impulse to each physics body
Vector2 impulseV = { manifold->normal.x*impulse, manifold->normal.y*impulse };
if (bodyA->enabled)
{
bodyA->velocity.x += bodyA->inverseMass*(-impulseV.x);
bodyA->velocity.y += bodyA->inverseMass*(-impulseV.y);
if (!bodyA->freezeOrient)
bodyA->angularVelocity += bodyA->inverseInertia*MathCrossVector2(radiusA, (Vector2){ -impulseV.x, -impulseV.y });
}
if (bodyB->enabled)
{
bodyB->velocity.x += bodyB->inverseMass*(impulseV.x);
bodyB->velocity.y += bodyB->inverseMass*(impulseV.y);
if (!bodyB->freezeOrient)
bodyB->angularVelocity += bodyB->inverseInertia*MathCrossVector2(radiusB, impulseV);
}
// Apply friction impulse to each physics body
radiusV.x = bodyB->velocity.x + MathCross(bodyB->angularVelocity, radiusB).x - bodyA->velocity.x - MathCross(bodyA->angularVelocity, radiusA).x;
radiusV.y = bodyB->velocity.y + MathCross(bodyB->angularVelocity, radiusB).y - bodyA->velocity.y - MathCross(bodyA->angularVelocity, radiusA).y;
Vector2 tangent = { radiusV.x - (manifold->normal.x*MathDot(radiusV, manifold->normal)), radiusV.y - (manifold->normal.y*MathDot(radiusV, manifold->normal)) };
MathNormalize(&tangent);
// Calculate impulse tangent magnitude
float impulseTangent = -MathDot(radiusV, tangent);
impulseTangent /= inverseMassSum;
impulseTangent /= (float)manifold->contactsCount;
float absImpulseTangent = fabs(impulseTangent);
// Don't apply tiny friction impulses
if (absImpulseTangent <= PHYSAC_EPSILON)
return;
// Apply coulumb's law
Vector2 tangentImpulse = { 0.0f, 0.0f };
if (absImpulseTangent < impulse*manifold->staticFriction)
tangentImpulse = (Vector2){ tangent.x*impulseTangent, tangent.y*impulseTangent };
else
tangentImpulse = (Vector2){ tangent.x*-impulse*manifold->dynamicFriction, tangent.y*-impulse*manifold->dynamicFriction };
// Apply friction impulse
if (bodyA->enabled)
{
bodyA->velocity.x += bodyA->inverseMass*(-tangentImpulse.x);
bodyA->velocity.y += bodyA->inverseMass*(-tangentImpulse.y);
if (!bodyA->freezeOrient)
bodyA->angularVelocity += bodyA->inverseInertia*MathCrossVector2(radiusA, (Vector2){ -tangentImpulse.x, -tangentImpulse.y });
}
if (bodyB->enabled)
{
bodyB->velocity.x += bodyB->inverseMass*(tangentImpulse.x);
bodyB->velocity.y += bodyB->inverseMass*(tangentImpulse.y);
if (!bodyB->freezeOrient)
bodyB->angularVelocity += bodyB->inverseInertia*MathCrossVector2(radiusB, tangentImpulse);
}
}
}
// Integrates physics velocity into position and forces
static void IntegratePhysicsVelocity(PhysicsBody body)
{
if ((body == NULL) ||!body->enabled)
return;
body->position.x += body->velocity.x*deltaTime;
body->position.y += body->velocity.y*deltaTime;
if (!body->freezeOrient)
body->orient += body->angularVelocity*deltaTime;
Mat2Set(&body->shape.transform, body->orient);
IntegratePhysicsForces(body);
}
// Corrects physics bodies positions based on manifolds collision information
static void CorrectPhysicsPositions(PhysicsManifold manifold)
{
PhysicsBody bodyA = manifold->bodyA;
PhysicsBody bodyB = manifold->bodyB;
if ((bodyA == NULL) || (bodyB == NULL))
return;
Vector2 correction = { 0.0f, 0.0f };
correction.x = (max(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.x*PHYSAC_PENETRATION_CORRECTION;
correction.y = (max(manifold->penetration - PHYSAC_PENETRATION_ALLOWANCE, 0.0f)/(bodyA->inverseMass + bodyB->inverseMass))*manifold->normal.y*PHYSAC_PENETRATION_CORRECTION;
if (bodyA->enabled)
{
bodyA->position.x -= correction.x*bodyA->inverseMass;
bodyA->position.y -= correction.y*bodyA->inverseMass;
}
if (bodyB->enabled)
{
bodyB->position.x += correction.x*bodyB->inverseMass;
bodyB->position.y += correction.y*bodyB->inverseMass;
}
}
// Returns the extreme point along a direction within a polygon
static Vector2 GetSupport(PhysicsShape shape, Vector2 dir)
{
float bestProjection = -PHYSAC_FLT_MAX;
Vector2 bestVertex = { 0.0f, 0.0f };
PolygonData data = shape.vertexData;
for (int i = 0; i < data.vertexCount; i++)
{
Vector2 vertex = data.positions[i];
float projection = MathDot(vertex, dir);
if (projection > bestProjection)
{
bestVertex = vertex;
bestProjection = projection;
}
}
return bestVertex;
}
// Finds polygon shapes axis least penetration
static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shapeA, PhysicsShape shapeB)
{
float bestDistance = -PHYSAC_FLT_MAX;
int bestIndex = 0;
PolygonData dataA = shapeA.vertexData;
for (int i = 0; i < dataA.vertexCount; i++)
{
// Retrieve a face normal from A shape
Vector2 normal = dataA.normals[i];
Vector2 transNormal = Mat2MultiplyVector2(shapeA.transform, normal);
// Transform face normal into B shape's model space
Mat2 buT = Mat2Transpose(shapeB.transform);
normal = Mat2MultiplyVector2(buT, transNormal);
// Retrieve support point from B shape along -n
Vector2 support = GetSupport(shapeB, (Vector2){ -normal.x, -normal.y });
// Retrieve vertex on face from A shape, transform into B shape's model space
Vector2 vertex = dataA.positions[i];
vertex = Mat2MultiplyVector2(shapeA.transform, vertex);
vertex = Vector2Add(vertex, shapeA.body->position);
vertex = Vector2Subtract(vertex, shapeB.body->position);
vertex = Mat2MultiplyVector2(buT, vertex);
// Compute penetration distance in B shape's model space
float distance = MathDot(normal, Vector2Subtract(support, vertex));
// Store greatest distance
if (distance > bestDistance)
{
bestDistance = distance;
bestIndex = i;
}
}
*faceIndex = bestIndex;
return bestDistance;
}
// Finds two polygon shapes incident face
static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref, PhysicsShape inc, int index)
{
PolygonData refData = ref.vertexData;
PolygonData incData = inc.vertexData;
Vector2 referenceNormal = refData.normals[index];
// Calculate normal in incident's frame of reference
referenceNormal = Mat2MultiplyVector2(ref.transform, referenceNormal); // To world space
referenceNormal = Mat2MultiplyVector2(Mat2Transpose(inc.transform), referenceNormal); // To incident's model space
// Find most anti-normal face on polygon
int incidentFace = 0;
float minDot = PHYSAC_FLT_MAX;
for (int i = 0; i < incData.vertexCount; i++)
{
float dot = MathDot(referenceNormal, incData.normals[i]);
if (dot < minDot)
{
minDot = dot;
incidentFace = i;
}
}
// Assign face vertices for incident face
*v0 = Mat2MultiplyVector2(inc.transform, incData.positions[incidentFace]);
*v0 = Vector2Add(*v0, inc.body->position);
incidentFace = (((incidentFace + 1) < incData.vertexCount) ? (incidentFace + 1) : 0);
*v1 = Mat2MultiplyVector2(inc.transform, incData.positions[incidentFace]);
*v1 = Vector2Add(*v1, inc.body->position);
}
// Calculates clipping based on a normal and two faces
static int Clip(Vector2 normal, float clip, Vector2 *faceA, Vector2 *faceB)
{
int sp = 0;
Vector2 out[2] = { *faceA, *faceB };
// Retrieve distances from each endpoint to the line
float distanceA = MathDot(normal, *faceA) - clip;
float distanceB = MathDot(normal, *faceB) - clip;
// If negative (behind plane)
if (distanceA <= 0.0f)
out[sp++] = *faceA;
if (distanceB <= 0.0f)
out[sp++] = *faceB;
// If the points are on different sides of the plane
if ((distanceA*distanceB) < 0.0f)
{
// Push intersection point
float alpha = distanceA/(distanceA - distanceB);
out[sp] = *faceA;
Vector2 delta = Vector2Subtract(*faceB, *faceA);
delta.x *= alpha;
delta.y *= alpha;
out[sp] = Vector2Add(out[sp], delta);
sp++;
}
// Assign the new converted values
*faceA = out[0];
*faceB = out[1];
return sp;
}
// Check if values are between bias range
static bool BiasGreaterThan(float valueA, float valueB)
{
return (valueA >= (valueB*0.95f + valueA*0.01f));
}
// Returns the barycenter of a triangle given by 3 points
static Vector2 TriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3)
{
Vector2 result = { 0.0f, 0.0f };
result.x = (v1.x + v2.x + v3.x)/3;
result.y = (v1.y + v2.y + v3.y)/3;
return result;
}
// Initializes hi-resolution MONOTONIC timer
static void InitTimer(void)
{
srand(time(NULL)); // Initialize random seed
#if defined(_WIN32)
QueryPerformanceFrequency((unsigned long long int *) &frequency);
#endif
#if defined(__linux__)
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now) == 0)
frequency = 1000000000;
#endif
#if defined(__APPLE__)
mach_timebase_info_data_t timebase;
mach_timebase_info(&timebase);
frequency = (timebase.denom*1e9)/timebase.numer;
#endif
#if defined(EMSCRIPTEN)
frequency = 1000;
#endif
baseTime = GetTimeCount(); // Get MONOTONIC clock time offset
startTime = GetCurrTime(); // Get current time
}
// Get hi-res MONOTONIC time measure in seconds
static uint64_t GetTimeCount(void)
{
uint64_t value = 0;
#if defined(_WIN32)
QueryPerformanceCounter((unsigned long long int *) &value);
#endif
#if defined(__linux__)
struct timespec now;
clock_gettime(CLOCK_MONOTONIC, &now);
value = (uint64_t)now.tv_sec*(uint64_t)1000000000 + (uint64_t)now.tv_nsec;
#endif
#if defined(__APPLE__)
value = mach_absolute_time();
#endif
#if defined(EMSCRIPTEN)
value = emscripten_get_now();
#endif
return value;
}
// Get current time in milliseconds
static double GetCurrTime(void)
{
return (double)(GetTimeCount() - baseTime)/frequency*1000;
}
// Returns the cross product of a vector and a value
static inline Vector2 MathCross(float value, Vector2 vector)
{
return (Vector2){ -value*vector.y, value*vector.x };
}
// Returns the cross product of two vectors
static inline float MathCrossVector2(Vector2 v1, Vector2 v2)
{
return (v1.x*v2.y - v1.y*v2.x);
}
// Returns the len square root of a vector
static inline float MathLenSqr(Vector2 vector)
{
return (vector.x*vector.x + vector.y*vector.y);
}
// Returns the dot product of two vectors
static inline float MathDot(Vector2 v1, Vector2 v2)
{
return (v1.x*v2.x + v1.y*v2.y);
}
// Returns the square root of distance between two vectors
static inline float DistSqr(Vector2 v1, Vector2 v2)
{
Vector2 dir = Vector2Subtract(v1, v2);
return MathDot(dir, dir);
}
// Returns the normalized values of a vector
static void MathNormalize(Vector2 *vector)
{
float length, ilength;
Vector2 aux = *vector;
length = sqrtf(aux.x*aux.x + aux.y*aux.y);
if (length == 0)
length = 1.0f;
ilength = 1.0f/length;
vector->x *= ilength;
vector->y *= ilength;
}
#if defined(PHYSAC_STANDALONE)
// Returns the sum of two given vectors
static inline Vector2 Vector2Add(Vector2 v1, Vector2 v2)
{
return (Vector2){ v1.x + v2.x, v1.y + v2.y };
}
// Returns the subtract of two given vectors
static inline Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
{
return (Vector2){ v1.x - v2.x, v1.y - v2.y };
}
#endif
// Creates a matrix 2x2 from a given radians value
static Mat2 Mat2Radians(float radians)
{
float c = cosf(radians);
float s = sinf(radians);
return (Mat2){ c, -s, s, c };
}
// Set values from radians to a created matrix 2x2
static void Mat2Set(Mat2 *matrix, float radians)
{
float cos = cosf(radians);
float sin = sinf(radians);
matrix->m00 = cos;
matrix->m01 = -sin;
matrix->m10 = sin;
matrix->m11 = cos;
}
// Returns the transpose of a given matrix 2x2
static inline Mat2 Mat2Transpose(Mat2 matrix)
{
return (Mat2){ matrix.m00, matrix.m10, matrix.m01, matrix.m11 };
}
// Multiplies a vector by a matrix 2x2
static inline Vector2 Mat2MultiplyVector2(Mat2 matrix, Vector2 vector)
{
return (Vector2){ matrix.m00*vector.x + matrix.m01*vector.y, matrix.m10*vector.x + matrix.m11*vector.y };
}
#endif // PHYSAC_IMPLEMENTATION
gitextract_h4mokleg/
├── .gitattributes
├── .gitignore
├── LICENSE
├── README.md
├── examples/
│ ├── physics_demo
│ ├── physics_demo.c
│ ├── physics_friction.c
│ ├── physics_movement.c
│ ├── physics_restitution.c
│ └── physics_shatter.c
├── icon/
│ ├── physac.pdn
│ ├── physac.rc
│ └── physac_icon
└── src/
└── physac.h
SYMBOL INDEX (72 symbols across 6 files)
FILE: examples/physics_demo.c
function main (line 23) | int main()
FILE: examples/physics_friction.c
function main (line 23) | int main()
FILE: examples/physics_movement.c
function main (line 25) | int main()
FILE: examples/physics_restitution.c
function main (line 23) | int main()
FILE: examples/physics_shatter.c
function main (line 25) | int main()
FILE: src/physac.h
type Vector2 (line 123) | typedef struct Vector2 {
type PhysicsShapeType (line 135) | typedef enum PhysicsShapeType { PHYSICS_CIRCLE, PHYSICS_POLYGON } Physic...
type PhysicsBodyData (line 138) | struct PhysicsBodyData
type Mat2 (line 141) | typedef struct Mat2 {
type PolygonData (line 148) | typedef struct PolygonData {
type PhysicsShape (line 154) | typedef struct PhysicsShape {
type PhysicsBodyData (line 162) | typedef struct PhysicsBodyData {
type PhysicsManifoldData (line 184) | typedef struct PhysicsManifoldData {
function PHYSACDEF (line 354) | PHYSACDEF void InitPhysics(void)
function PHYSACDEF (line 373) | PHYSACDEF bool IsPhysicsEnabled(void)
function PHYSACDEF (line 379) | PHYSACDEF void SetPhysicsGravity(float x, float y)
function PHYSACDEF (line 386) | PHYSACDEF PhysicsBody CreatePhysicsBodyCircle(Vector2 pos, float radius,...
function PHYSACDEF (line 437) | PHYSACDEF PhysicsBody CreatePhysicsBodyRectangle(Vector2 pos, float widt...
function PHYSACDEF (line 525) | PHYSACDEF PhysicsBody CreatePhysicsBodyPolygon(Vector2 pos, float radius...
function PHYSACDEF (line 612) | PHYSACDEF void PhysicsAddForce(PhysicsBody body, Vector2 force)
function PHYSACDEF (line 619) | PHYSACDEF void PhysicsAddTorque(PhysicsBody body, float amount)
function PHYSACDEF (line 626) | PHYSACDEF void PhysicsShatter(PhysicsBody body, Vector2 position, float ...
function PHYSACDEF (line 768) | PHYSACDEF int GetPhysicsBodiesCount(void)
function PHYSACDEF (line 774) | PHYSACDEF PhysicsBody GetPhysicsBody(int index)
function PHYSACDEF (line 794) | PHYSACDEF int GetPhysicsShapeType(int index)
function PHYSACDEF (line 817) | PHYSACDEF int GetPhysicsShapeVerticesCount(int index)
function PHYSACDEF (line 846) | PHYSACDEF Vector2 GetPhysicsShapeVertex(PhysicsBody body, int vertex)
function PHYSACDEF (line 876) | PHYSACDEF void SetPhysicsBodyRotation(PhysicsBody body, float radians)
function PHYSACDEF (line 888) | PHYSACDEF void DestroyPhysicsBody(PhysicsBody body)
function PHYSACDEF (line 938) | PHYSACDEF void ClosePhysics(void)
function FindAvailableBodyIndex (line 969) | static int FindAvailableBodyIndex()
function PolygonData (line 998) | static PolygonData CreateRandomPolygon(float radius, int sides)
function PolygonData (line 1024) | static PolygonData CreateRectanglePolygon(Vector2 pos, Vector2 size)
type timespec (line 1063) | struct timespec
function PhysicsStep (line 1074) | static void PhysicsStep(void)
function PHYSACDEF (line 1194) | PHYSACDEF void RunPhysicsStep(void)
function PHYSACDEF (line 1216) | PHYSACDEF void SetPhysicsTimeStep(double delta)
function FindAvailableManifoldIndex (line 1222) | static int FindAvailableManifoldIndex()
function PhysicsManifold (line 1235) | static PhysicsManifold CreatePhysicsManifold(PhysicsBody a, PhysicsBody b)
function DestroyPhysicsManifold (line 1269) | static void DestroyPhysicsManifold(PhysicsManifold manifold)
function SolvePhysicsManifold (line 1315) | static void SolvePhysicsManifold(PhysicsManifold manifold)
function SolveCircleToCircle (line 1346) | static void SolveCircleToCircle(PhysicsManifold manifold)
function SolveCircleToPolygon (line 1389) | static void SolveCircleToPolygon(PhysicsManifold manifold)
function SolvePolygonToCircle (line 1401) | static void SolvePolygonToCircle(PhysicsManifold manifold)
function SolveDifferentShapes (line 1416) | static void SolveDifferentShapes(PhysicsManifold manifold, PhysicsBody b...
function SolvePolygonToPolygon (line 1508) | static void SolvePolygonToPolygon(PhysicsManifold manifold)
function IntegratePhysicsForces (line 1617) | static void IntegratePhysicsForces(PhysicsBody body)
function InitializePhysicsManifolds (line 1636) | static void InitializePhysicsManifolds(PhysicsManifold manifold)
function IntegratePhysicsImpulses (line 1670) | static void IntegratePhysicsImpulses(PhysicsManifold manifold)
function IntegratePhysicsVelocity (line 1782) | static void IntegratePhysicsVelocity(PhysicsBody body)
function CorrectPhysicsPositions (line 1799) | static void CorrectPhysicsPositions(PhysicsManifold manifold)
function Vector2 (line 1825) | static Vector2 GetSupport(PhysicsShape shape, Vector2 dir)
function FindAxisLeastPenetration (line 1847) | static float FindAxisLeastPenetration(int *faceIndex, PhysicsShape shape...
function FindIncidentFace (line 1890) | static void FindIncidentFace(Vector2 *v0, Vector2 *v1, PhysicsShape ref,...
function Clip (line 1925) | static int Clip(Vector2 normal, float clip, Vector2 *faceA, Vector2 *faceB)
function BiasGreaterThan (line 1962) | static bool BiasGreaterThan(float valueA, float valueB)
function Vector2 (line 1968) | static Vector2 TriangleBarycenter(Vector2 v1, Vector2 v2, Vector2 v3)
function InitTimer (line 1979) | static void InitTimer(void)
function GetTimeCount (line 2008) | static uint64_t GetTimeCount(void)
function GetCurrTime (line 2034) | static double GetCurrTime(void)
function Vector2 (line 2040) | static inline Vector2 MathCross(float value, Vector2 vector)
function MathCrossVector2 (line 2046) | static inline float MathCrossVector2(Vector2 v1, Vector2 v2)
function MathLenSqr (line 2052) | static inline float MathLenSqr(Vector2 vector)
function MathDot (line 2058) | static inline float MathDot(Vector2 v1, Vector2 v2)
function DistSqr (line 2064) | static inline float DistSqr(Vector2 v1, Vector2 v2)
function MathNormalize (line 2071) | static void MathNormalize(Vector2 *vector)
function Vector2 (line 2089) | static inline Vector2 Vector2Add(Vector2 v1, Vector2 v2)
function Vector2 (line 2095) | static inline Vector2 Vector2Subtract(Vector2 v1, Vector2 v2)
function Mat2 (line 2102) | static Mat2 Mat2Radians(float radians)
function Mat2Set (line 2111) | static void Mat2Set(Mat2 *matrix, float radians)
function Mat2 (line 2123) | static inline Mat2 Mat2Transpose(Mat2 matrix)
function Vector2 (line 2129) | static inline Vector2 Mat2MultiplyVector2(Mat2 matrix, Vector2 vector)
Condensed preview — 14 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (123K chars).
[
{
"path": ".gitattributes",
"chars": 378,
"preview": "# Auto detect text files and perform LF normalization\n* text=auto\n\n# Custom for Visual Studio\n*.cs diff=csharp\n\n# St"
},
{
"path": ".gitignore",
"chars": 998,
"preview": "# Object files\n*.o\n*.ko\n*.obj\n*.elf\n\n# Precompiled Headers\n*.gch\n*.pch\n\n# Libraries\n*.lib\n*.a\n*.la\n*.lo\n\n# Shared object"
},
{
"path": "LICENSE",
"chars": 1069,
"preview": "MIT License\n\nCopyright (c) 2022 Víctor Fisac\n\nPermission is hereby granted, free of charge, to any person obtaining a co"
},
{
"path": "README.md",
"chars": 6223,
"preview": "<img src=\"https://github.com/victorfisac/Physac/blob/master/icon/physac_256x256.png\">\n\n# Physac\n\nPhysac is a small 2D ph"
},
{
"path": "examples/physics_demo.c",
"chars": 4957,
"preview": "/*******************************************************************************************\n*\n* Physac - Physics demo"
},
{
"path": "examples/physics_friction.c",
"chars": 5595,
"preview": "/*******************************************************************************************\n*\n* Physac - Physics fric"
},
{
"path": "examples/physics_movement.c",
"chars": 5118,
"preview": "/*******************************************************************************************\n*\n* Physac - Physics move"
},
{
"path": "examples/physics_restitution.c",
"chars": 4727,
"preview": "/*******************************************************************************************\n*\n* Physac - Physics rest"
},
{
"path": "examples/physics_shatter.c",
"chars": 4756,
"preview": "/*******************************************************************************************\n*\n* Physac - Body shatter"
},
{
"path": "icon/physac.rc",
"chars": 670,
"preview": "GLFW_ICON ICON \"physac.ico\"\n\n1 VERSIONINFO\nFILEVERSION 1,0,0,0\nPRODUCTVERSION 1,0,0,0\nBEGIN\n BLOCK \"StringFileInfo"
},
{
"path": "src/physac.h",
"chars": 84389,
"preview": "/**********************************************************************************************\n*\n* Physac v1.1 - 2D P"
}
]
// ... and 3 more files (download for full content)
About this extraction
This page contains the full source code of the victorfisac/Physac GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 14 files (116.1 KB), approximately 27.6k tokens, and a symbol index with 72 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.