Added physac examples to web

Some tweaks on original src files

docs/examples/src/physac/physics_demo.c

@@ -119,7 +119,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
+    ClosePhysics();       // Uninitialize physics
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

docs/examples/src/physac/physics_friction.c

@@ -133,7 +133,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
+    ClosePhysics();       // Uninitialize physics
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

docs/examples/src/physac/physics_movement.c

@@ -119,7 +119,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
+    ClosePhysics();       // Uninitialize physics
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

docs/examples/src/physac/physics_restitution.c

@@ -112,7 +112,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
+    ClosePhysics();       // Uninitialize physics
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

docs/examples/src/physac/physics_shatter.c

@@ -104,7 +104,7 @@ int main()
 
     // De-Initialization
     //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
+    ClosePhysics();       // Uninitialize physics
     
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------

docs/examples/web/makefile

@@ -577,23 +577,23 @@ audio/audio_raw_stream: audio/audio_raw_stream.c
 
 # compile [physac] example - physics demo
 physac/physics_demo: physac/physics_demo.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL) -s USE_PTHREADS=1
 
 # compile [physac] example - physics friction
 physac/physics_friction: physac/physics_friction.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL) -s USE_PTHREADS=1
 
 # compile [physac] example - physics movement
 physac/physics_movement: physac/physics_movement.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL) -s USE_PTHREADS=1
 
 # compile [physac] example - physics restitution
 physac/physics_restitution: physac/physics_restitution.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL) -s USE_PTHREADS=1
 
 # compile [physac] example - physics shatter
 physac/physics_shatter: physac/physics_shatter.c
-	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL)
+	$(CC) -o $@$(EXT) $< $(CFLAGS) $(INCLUDES) $(LFLAGS) $(LIBS) -static -lpthread -D$(PLATFORM) $(WINFLAGS) $(WEB_SHELL) -s USE_PTHREADS=1
 
 # fix dylib install path name for each executable (MAC)
 fix_dylib:

docs/examples/web/physac/physics_demo.c

@@ -2,9 +2,11 @@
 *
 *   Physac - Physics demo
 *
-*   NOTE: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+*
+*   Use the following line to compile:
 *
-*   Use the following code to compile (-static -lpthread):
 *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib_icon -static -lraylib -lpthread 
 *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
 *   
@@ -15,111 +17,148 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
-#include "../src/physac.h"
+#include "physac.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Physac logo drawing position
+int logoX = 0;
+int logoY = 15;
+
+PhysicsBody ground;
+PhysicsBody circle;
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
 
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
 int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics demo");
     SetTargetFPS(60);
-
-    // Physac logo drawing position
-    int logoX = screenWidth - MeasureText("Physac", 30) - 10;
-    int logoY = 15;
+    
+    logoX = screenWidth - MeasureText("Physac", 30) - 10;
 
     // 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)
+    ground = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
+    ground->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 = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
     circle->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
-    //--------------------------------------------------------------------------------------
 
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (IsKeyPressed('R'))    // Reset physics input
-        {
-            ResetPhysics();
+        UpdateDrawFrame();
+    }
+#endif
 
-            floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
-            floor->enabled = false;
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    ClosePhysics();       // Uninitialize physics
 
-            circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
-            circle->enabled = false;
-        }
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
 
-        // 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);
+    return 0;
+}
 
-        // 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);
-        }
-        //----------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed('R'))    // Reset physics input
+    {
+        ResetPhysics();
 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
+        ground = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, 500, 100, 10);
+        ground->enabled = false;
 
-            ClearBackground(BLACK);
+        circle = CreatePhysicsBodyCircle((Vector2){ screenWidth/2, screenHeight/2 }, 45, 10);
+        circle->enabled = false;
+    }
 
-            DrawFPS(screenWidth - 90, screenHeight - 30);
+    // 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);
 
-            // Draw created physics bodies
-            bodiesCount = GetPhysicsBodiesCount();
-            for (int i = 0; i < bodiesCount; i++)
-            {
-                PhysicsBody body = GetPhysicsBody(i);
+    // 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();
 
-                if (body != NULL)
+        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++)
                 {
-                    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
-                    }
+                    // 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("Press 'R' to reset example", 10, 40, 10, WHITE);
-
-            DrawText("Physac", logoX, logoY, 30, WHITE);
-            DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+        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("Press 'R' to reset example", 10, 40, 10, WHITE);
 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
+        DrawText("Physac", logoX, logoY, 30, WHITE);
+        DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
 
-    // De-Initialization
-    //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
-
-    return 0;
+    EndDrawing();
+    //----------------------------------------------------------------------------------
 }

docs/examples/web/physac/physics_friction.c

@@ -2,9 +2,11 @@
 *
 *   Physac - Physics friction
 *
-*   NOTE: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+*
+*   Use the following line to compile:
 *
-*   Use the following code to compile (-static -lpthread):
 *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib_icon -static -lraylib -lpthread 
 *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
 *   
@@ -15,29 +17,50 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
-#include "../src/physac.h"
+#include "physac.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Physac logo drawing position
+int logoX = 0;
+int logoY = 15;
+
+PhysicsBody bodyA;
+PhysicsBody bodyB;
 
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
 int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics friction");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
-    int logoX = screenWidth - MeasureText("Physac", 30) - 10;
-    int logoY = 15;
+    logoX = screenWidth - MeasureText("Physac", 30) - 10;
 
     // 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 ground = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
+    ground->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)
 
@@ -52,88 +75,104 @@ int main()
     SetPhysicsBodyRotation(rectRight, 330*DEG2RAD);
 
     // Create dynamic physics bodies
-    PhysicsBody bodyA = CreatePhysicsBodyRectangle((Vector2){ 35, screenHeight*0.6f }, 40, 40, 10);
+    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 = CreatePhysicsBodyRectangle((Vector2){ screenWidth - 35, screenHeight*0.6f }, 40, 40, 10);
     bodyB->staticFriction = 1;
     bodyB->dynamicFriction = 1;
     SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
-    //--------------------------------------------------------------------------------------
 
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (IsKeyPressed('R'))    // Reset physics input
-        {
-            // Reset dynamic physics bodies position, velocity and rotation
-            bodyA->position = (Vector2){ 35, screenHeight*0.6f };
-            bodyA->velocity = (Vector2){ 0, 0 };
-            bodyA->angularVelocity = 0;
-            SetPhysicsBodyRotation(bodyA, 30*DEG2RAD);
-            
-            bodyB->position = (Vector2){ screenWidth - 35, screenHeight*0.6f };
-            bodyB->velocity = (Vector2){ 0, 0 };
-            bodyB->angularVelocity = 0;
-            SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
-        }
-        //----------------------------------------------------------------------------------
+        UpdateDrawFrame();
+    }
+#endif
 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    ClosePhysics();       // Uninitialize physics
 
-            ClearBackground(BLACK);
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
 
-            DrawFPS(screenWidth - 90, screenHeight - 30);
+    return 0;
+}
 
-            // Draw created physics bodies
-            int bodiesCount = GetPhysicsBodiesCount();
-            for (int i = 0; i < bodiesCount; i++)
-            {
-                PhysicsBody body = GetPhysicsBody(i);
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed('R'))    // Reset physics input
+    {
+        // Reset dynamic physics bodies position, velocity and rotation
+        bodyA->position = (Vector2){ 35, screenHeight*0.6f };
+        bodyA->velocity = (Vector2){ 0, 0 };
+        bodyA->angularVelocity = 0;
+        SetPhysicsBodyRotation(bodyA, 30*DEG2RAD);
+        
+        bodyB->position = (Vector2){ screenWidth - 35, screenHeight*0.6f };
+        bodyB->velocity = (Vector2){ 0, 0 };
+        bodyB->angularVelocity = 0;
+        SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
+    }
+    //----------------------------------------------------------------------------------
+
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
+
+        ClearBackground(BLACK);
+
+        DrawFPS(screenWidth - 90, screenHeight - 30);
 
-                if (body != NULL)
+        // 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++)
                 {
-                    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
-                    }
-                }
-            }
+                    // Get physics bodies shape vertices to draw lines
+                    // Note: GetPhysicsShapeVertex() already calculates rotation transformations
+                    Vector2 vertexA = GetPhysicsShapeVertex(body, j);
 
-            DrawRectangle(0, screenHeight - 49, screenWidth, 49, BLACK);
+                    int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
+                    Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
 
-            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);
+                    DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
+                }
+            }
+        }
 
-            DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
+        DrawRectangle(0, screenHeight - 49, screenWidth, 49, BLACK);
 
-            DrawText("Physac", logoX, logoY, 30, WHITE);
-            DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+        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);
 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
+        DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
 
-    // De-Initialization
-    //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
+        DrawText("Physac", logoX, logoY, 30, WHITE);
+        DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
 
-    return 0;
+    EndDrawing();
+    //----------------------------------------------------------------------------------
 }
+

docs/examples/web/physac/physics_movement.c

@@ -2,9 +2,11 @@
 *
 *   Physac - Physics movement
 *
-*   NOTE: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+*
+*   Use the following line to compile:
 *
-*   Use the following code to compile (-static -lpthread):
 *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib_icon -static -lraylib -lpthread 
 *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
 *   
@@ -15,111 +17,147 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
-#include "../src/physac.h"
+#include "physac.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+#define VELOCITY    0.5f
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Physac logo drawing position
+int logoX = 0;
+int logoY = 15;
 
-#define     VELOCITY    0.5f
+PhysicsBody body;
 
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
 int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
-    int logoX = screenWidth - MeasureText("Physac", 30) - 10;
-    int logoY = 15;
+    logoX = screenWidth - MeasureText("Physac", 30) - 10;
 
     // Initialize physics and default physics bodies
     InitPhysics();
 
-    // Create floor and walls rectangle physics body
-    PhysicsBody floor = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
+    // Create ground and walls rectangle physics body
+    PhysicsBody ground = 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;
+    // Disable dynamics to ground and walls physics bodies
+    ground->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 = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight/2 }, 50, 50, 1);
     body->freezeOrient = true;  // Constrain body rotation to avoid little collision torque amounts
-    //--------------------------------------------------------------------------------------
 
+    
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (IsKeyPressed('R'))    // Reset physics input
-        {
-            // Reset movement physics body position, velocity and rotation
-            body->position = (Vector2){ screenWidth/2, screenHeight/2 };
-            body->velocity = (Vector2){ 0, 0 };
-            SetPhysicsBodyRotation(body, 0);
-        }
+        UpdateDrawFrame();
+    }
+#endif
+
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    ClosePhysics();       // Uninitialize physics
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
 
-        // Horizontal movement input
-        if (IsKeyDown(KEY_RIGHT)) body->velocity.x = VELOCITY;
-        else if (IsKeyDown(KEY_LEFT)) body->velocity.x = -VELOCITY;
+    return 0;
+}
 
-        // Vertical movement input checking if player physics body is grounded
-        if (IsKeyDown(KEY_UP) && body->isGrounded) body->velocity.y = -VELOCITY*4;
-        //----------------------------------------------------------------------------------
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed('R'))    // Reset physics input
+    {
+        // Reset movement physics body position, velocity and rotation
+        body->position = (Vector2){ screenWidth/2, screenHeight/2 };
+        body->velocity = (Vector2){ 0, 0 };
+        SetPhysicsBodyRotation(body, 0);
+    }
 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
+    // Horizontal movement input
+    if (IsKeyDown(KEY_RIGHT)) body->velocity.x = VELOCITY;
+    else if (IsKeyDown(KEY_LEFT)) body->velocity.x = -VELOCITY;
 
-            ClearBackground(BLACK);
+    // Vertical movement input checking if player physics body is grounded
+    if (IsKeyDown(KEY_UP) && body->isGrounded) body->velocity.y = -VELOCITY*4;
+    //----------------------------------------------------------------------------------
 
-            DrawFPS(screenWidth - 90, screenHeight - 30);
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
 
-            // Draw created physics bodies
-            int bodiesCount = GetPhysicsBodiesCount();
-            for (int i = 0; i < bodiesCount; i++)
-            {
-                PhysicsBody body = GetPhysicsBody(i);
+        ClearBackground(BLACK);
 
-                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);
+        DrawFPS(screenWidth - 90, screenHeight - 30);
 
-                    int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
-                    Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
+        // Draw created physics bodies
+        int bodiesCount = GetPhysicsBodiesCount();
+        for (int i = 0; i < bodiesCount; i++)
+        {
+            PhysicsBody body = GetPhysicsBody(i);
 
-                    DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
-                }
-            }
+            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);
 
-            DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
-            DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
+                int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
+                Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
 
-            DrawText("Physac", logoX, logoY, 30, WHITE);
-            DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+                DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
+            }
+        }
 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
+        DrawText("Use 'ARROWS' to move player", 10, 10, 10, WHITE);
+        DrawText("Press 'R' to reset example", 10, 30, 10, WHITE);
 
-    // De-Initialization
-    //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
+        DrawText("Physac", logoX, logoY, 30, WHITE);
+        DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
 
-    return 0;
+    EndDrawing();
+    //----------------------------------------------------------------------------------
 }
+

docs/examples/web/physac/physics_restitution.c

@@ -2,9 +2,11 @@
 *
 *   Physac - Physics restitution
 *
-*   NOTE: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+*
+*   Use the following line to compile:
 *
-*   Use the following code to compile (-static -lpthread):
 *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib_icon -static -lraylib -lpthread 
 *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
 *   
@@ -15,104 +17,140 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
-#include "../src/physac.h"
-
+#include "physac.h"
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Physac logo drawing position
+int logoX = 0;
+int logoY = 15;
+
+PhysicsBody circleA;
+PhysicsBody circleB;
+PhysicsBody circleC;
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
+
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
 int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics restitution");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
-    int logoX = screenWidth - MeasureText("Physac", 30) - 10;
-    int logoY = 15;
+    logoX = screenWidth - MeasureText("Physac", 30) - 10;
 
     // 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 = 1;
+    // Create ground rectangle physics body
+    PhysicsBody ground = CreatePhysicsBodyRectangle((Vector2){ screenWidth/2, screenHeight }, screenWidth, 100, 10);
+    ground->enabled = false; // Disable body state to convert it to static (no dynamics, but collisions)
+    ground->restitution = 1;
 
     // Create circles physics body
-    PhysicsBody circleA = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.25f, screenHeight/2 }, 30, 10);
+    circleA = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.25f, screenHeight/2 }, 30, 10);
     circleA->restitution = 0;
-    PhysicsBody circleB = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.5f, screenHeight/2 }, 30, 10);
+    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 = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.75f, screenHeight/2 }, 30, 10);
     circleC->restitution = 1;
-    //--------------------------------------------------------------------------------------
 
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (IsKeyPressed('R'))    // Reset physics input
-        {
-            // Reset circles physics bodies position and velocity
-            circleA->position = (Vector2){ screenWidth*0.25f, screenHeight/2 };
-            circleA->velocity = (Vector2){ 0, 0 };
-            circleB->position = (Vector2){ screenWidth*0.5f, screenHeight/2 };
-            circleB->velocity = (Vector2){ 0, 0 };
-            circleC->position = (Vector2){ screenWidth*0.75f, screenHeight/2 };
-            circleC->velocity = (Vector2){ 0, 0 };
-        }
-        //----------------------------------------------------------------------------------
+        UpdateDrawFrame();
+    }
+#endif
 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    ClosePhysics();       // Uninitialize physics
 
-            ClearBackground(BLACK);
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
 
-            DrawFPS(screenWidth - 90, screenHeight - 30);
+    return 0;
+}
 
-            // Draw created physics bodies
-            int bodiesCount = GetPhysicsBodiesCount();
-            for (int i = 0; i < bodiesCount; i++)
-            {
-                PhysicsBody body = GetPhysicsBody(i);
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed('R'))    // Reset physics input
+    {
+        // Reset circles physics bodies position and velocity
+        circleA->position = (Vector2){ screenWidth*0.25f, screenHeight/2 };
+        circleA->velocity = (Vector2){ 0, 0 };
+        circleB->position = (Vector2){ screenWidth*0.5f, screenHeight/2 };
+        circleB->velocity = (Vector2){ 0, 0 };
+        circleC->position = (Vector2){ screenWidth*0.75f, screenHeight/2 };
+        circleC->velocity = (Vector2){ 0, 0 };
+    }
+    //----------------------------------------------------------------------------------
 
-                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);
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
 
-                    int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
-                    Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
+        ClearBackground(BLACK);
 
-                    DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
-                }
-            }
+        DrawFPS(screenWidth - 90, screenHeight - 30);
 
-            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("0.5", circleB->position.x - MeasureText("0.5", 20)/2, circleB->position.y - 7, 20, WHITE);
-            DrawText("1", circleC->position.x - MeasureText("1", 20)/2, circleC->position.y - 7, 20, WHITE);
+        // Draw created physics bodies
+        int bodiesCount = GetPhysicsBodiesCount();
+        for (int i = 0; i < bodiesCount; i++)
+        {
+            PhysicsBody body = GetPhysicsBody(i);
 
-            DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
+            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);
 
-            DrawText("Physac", logoX, logoY, 30, WHITE);
-            DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+                int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
+                Vector2 vertexB = GetPhysicsShapeVertex(body, jj);
 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
+                DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
+            }
+        }
 
-    // De-Initialization
-    //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
+        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("0.5", circleB->position.x - MeasureText("0.5", 20)/2, circleB->position.y - 7, 20, WHITE);
+        DrawText("1", circleC->position.x - MeasureText("1", 20)/2, circleC->position.y - 7, 20, WHITE);
 
-    return 0;
+        DrawText("Press 'R' to reset example", 10, 10, 10, WHITE);
+
+        DrawText("Physac", logoX, logoY, 30, WHITE);
+        DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+
+    EndDrawing();
+    //----------------------------------------------------------------------------------
 }

docs/examples/web/physac/physics_shatter.c

@@ -2,9 +2,11 @@
 *
 *   Physac - Body shatter
 *
-*   NOTE: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 1: Physac requires multi-threading, when InitPhysics() a second thread is created to manage physics calculations.
+*   NOTE 2: Physac requires static C library linkage to avoid dependency on MinGW DLL (-static -lpthread)
+*
+*   Use the following line to compile:
 *
-*   Use the following code to compile (-static -lpthread):
 *   gcc -o $(NAME_PART).exe $(FILE_NAME) -s $(RAYLIB_DIR)\raylib\raylib_icon -static -lraylib -lpthread 
 *   -lglfw3 -lopengl32 -lgdi32 -lopenal32 -lwinmm -std=c99 -Wl,--subsystem,windows -Wl,-allow-multiple-definition
 *   
@@ -15,96 +17,131 @@
 #include "raylib.h"
 
 #define PHYSAC_IMPLEMENTATION
-#include "../src/physac.h" 
+#include "physac.h" 
+
+#if defined(PLATFORM_WEB)
+    #include <emscripten/emscripten.h>
+#endif
+
+//----------------------------------------------------------------------------------
+// Global Variables Definition
+//----------------------------------------------------------------------------------
+int screenWidth = 800;
+int screenHeight = 450;
+
+// Physac logo drawing position
+int logoX = 0;
+int logoY = 15;
+
+PhysicsBody body;
+
+//----------------------------------------------------------------------------------
+// Module Functions Declaration
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void);     // Update and Draw one frame
 
+//----------------------------------------------------------------------------------
+// Main Enry Point
+//----------------------------------------------------------------------------------
 int main()
 {
     // Initialization
     //--------------------------------------------------------------------------------------
-    int screenWidth = 800;
-    int screenHeight = 450;
-
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Body shatter");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
-    int logoX = screenWidth - MeasureText("Physac", 30) - 10;
-    int logoY = 15;
+    logoX = screenWidth - MeasureText("Physac", 30) - 10;
 
     // Initialize physics and default physics bodies
     InitPhysics();
     SetPhysicsGravity(0, 0);
 
     // Create random polygon physics body to shatter
-    PhysicsBody body = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
-    //--------------------------------------------------------------------------------------
+    body = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
 
+#if defined(PLATFORM_WEB)
+    emscripten_set_main_loop(UpdateDrawFrame, 0, 1);
+#else
+    SetTargetFPS(60);   // Set our game to run at 60 frames-per-second
+    //--------------------------------------------------------------------------------------
+    
     // Main game loop
     while (!WindowShouldClose())    // Detect window close button or ESC key
     {
-        // Update
-        //----------------------------------------------------------------------------------
-        if (IsKeyPressed('R'))    // Reset physics input
-        {
-            ResetPhysics();
+        UpdateDrawFrame();
+    }
+#endif
 
-            // Create random polygon physics body to shatter
-            body = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
-        }
+    // De-Initialization
+    //--------------------------------------------------------------------------------------   
+    ClosePhysics();       // Uninitialize physics
+
+    CloseWindow();        // Close window and OpenGL context
+    //--------------------------------------------------------------------------------------
+
+    return 0;
+}
+
+//----------------------------------------------------------------------------------
+// Module Functions Definition
+//----------------------------------------------------------------------------------
+void UpdateDrawFrame(void)
+{
+    // Update
+    //----------------------------------------------------------------------------------
+    if (IsKeyPressed('R'))    // Reset physics input
+    {
+        ResetPhysics();
+
+        // Create random polygon physics body to shatter
+        body = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
+    }
 
-        if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))    // Physics shatter input
+    if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON))    // Physics shatter input
+    {
+        // 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--)
         {
-            // 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(), 10/currentBody->inverseMass);
-            }
+            PhysicsBody currentBody = GetPhysicsBody(i);
+            if (currentBody != NULL) PhysicsShatter(currentBody, GetMousePosition(), 10/currentBody->inverseMass);
         }
-        //----------------------------------------------------------------------------------
+    }
+    //----------------------------------------------------------------------------------
 
-        // Draw
-        //----------------------------------------------------------------------------------
-        BeginDrawing();
+    // Draw
+    //----------------------------------------------------------------------------------
+    BeginDrawing();
 
-            ClearBackground(BLACK);
+        ClearBackground(BLACK);
 
-            // Draw created physics bodies
-            int bodiesCount = GetPhysicsBodiesCount();
-            for (int i = 0; i < bodiesCount; i++)
-            {
-                PhysicsBody currentBody = GetPhysicsBody(i);
+        // Draw created physics bodies
+        int bodiesCount = GetPhysicsBodiesCount();
+        for (int i = 0; i < bodiesCount; i++)
+        {
+            PhysicsBody currentBody = 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(currentBody, j);
+            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(currentBody, j);
 
-                    int jj = (((j + 1) < vertexCount) ? (j + 1) : 0);   // Get next vertex or first to close the shape
-                    Vector2 vertexB = GetPhysicsShapeVertex(currentBody, jj);
+                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
-                }
+                DrawLineV(vertexA, vertexB, GREEN);     // Draw a line between two vertex positions
             }
+        }
 
-            DrawText("Left mouse button in polygon area to shatter body\nPress 'R' to reset example", 10, 10, 10, WHITE);
-
-            DrawText("Physac", logoX, logoY, 30, WHITE);
-            DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
+        DrawText("Left mouse button in polygon area to shatter body\nPress 'R' to reset example", 10, 10, 10, WHITE);
 
-        EndDrawing();
-        //----------------------------------------------------------------------------------
-    }
-
-    // De-Initialization
-    //--------------------------------------------------------------------------------------   
-    ClosePhysics();       // Unitialize physics
-    CloseWindow();        // Close window and OpenGL context
-    //--------------------------------------------------------------------------------------
+        DrawText("Physac", logoX, logoY, 30, WHITE);
+        DrawText("Powered by", logoX + 50, logoY - 7, 10, WHITE);
 
-    return 0;
+    EndDrawing();
+    //----------------------------------------------------------------------------------
 }
+

docs/examples/web/physac/pthread-main.js

@@ -0,0 +1,115 @@
+// Pthread Web Worker startup routine:
+// This is the entry point file that is loaded first by each Web Worker
+// that executes pthreads on the Emscripten application.
+
+// Thread-local:
+var threadInfoStruct = 0; // Info area for this thread in Emscripten HEAP (shared). If zero, this worker is not currently hosting an executing pthread.
+var selfThreadId = 0; // The ID of this thread. 0 if not hosting a pthread.
+var parentThreadId = 0; // The ID of the parent pthread that launched this thread.
+var tempDoublePtr = 0; // A temporary memory area for global float and double marshalling operations.
+
+// Thread-local: Each thread has its own allocated stack space.
+var STACK_BASE = 0;
+var STACKTOP = 0;
+var STACK_MAX = 0;
+
+// These are system-wide memory area parameters that are set at main runtime startup in main thread, and stay constant throughout the application.
+var buffer; // All pthreads share the same Emscripten HEAP as SharedArrayBuffer with the main execution thread.
+var DYNAMICTOP_PTR = 0;
+var TOTAL_MEMORY = 0;
+var STATICTOP = 0;
+var staticSealed = true; // When threads are being initialized, the static memory area has been already sealed a long time ago.
+var DYNAMIC_BASE = 0;
+
+var ENVIRONMENT_IS_PTHREAD = true;
+
+// Cannot use console.log or console.error in a web worker, since that would risk a browser deadlock! https://bugzilla.mozilla.org/show_bug.cgi?id=1049091
+// Therefore implement custom logging facility for threads running in a worker, which queue the messages to main thread to print.
+var Module = {};
+
+function threadPrint() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  console.log(text);
+}
+function threadPrintErr() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  console.error(text);
+}
+function threadAlert() {
+  var text = Array.prototype.slice.call(arguments).join(' ');
+  postMessage({cmd: 'alert', text: text, threadId: selfThreadId});
+}
+Module['print'] = threadPrint;
+Module['printErr'] = threadPrintErr;
+this.alert = threadAlert;
+
+this.onmessage = function(e) {
+  if (e.data.cmd === 'load') { // Preload command that is called once per worker to parse and load the Emscripten code.
+    // Initialize the thread-local field(s):
+    tempDoublePtr = e.data.tempDoublePtr;
+
+    // Initialize the global "process"-wide fields:
+    buffer = e.data.buffer;
+    Module['TOTAL_MEMORY'] = TOTAL_MEMORY = e.data.TOTAL_MEMORY;
+    STATICTOP = e.data.STATICTOP;
+    DYNAMIC_BASE = e.data.DYNAMIC_BASE;
+    DYNAMICTOP_PTR = e.data.DYNAMICTOP_PTR;
+
+    PthreadWorkerInit = e.data.PthreadWorkerInit;
+    importScripts(e.data.url);
+    if (typeof FS !== 'undefined') FS.createStandardStreams();
+    postMessage({ cmd: 'loaded' });
+  } else if (e.data.cmd === 'objectTransfer') {
+    PThread.receiveObjectTransfer(e.data);
+  } else if (e.data.cmd === 'run') { // This worker was idle, and now should start executing its pthread entry point.
+    threadInfoStruct = e.data.threadInfoStruct;
+    __register_pthread_ptr(threadInfoStruct, /*isMainBrowserThread=*/0, /*isMainRuntimeThread=*/0); // Pass the thread address inside the asm.js scope to store it for fast access that avoids the need for a FFI out.
+    assert(threadInfoStruct);
+    selfThreadId = e.data.selfThreadId;
+    parentThreadId = e.data.parentThreadId;
+    assert(selfThreadId);
+    assert(parentThreadId);
+    // TODO: Emscripten runtime has these variables twice(!), once outside the asm.js module, and a second time inside the asm.js module.
+    //       Review why that is? Can those get out of sync?
+    STACK_BASE = STACKTOP = e.data.stackBase;
+    STACK_MAX = STACK_BASE + e.data.stackSize;
+    assert(STACK_BASE != 0);
+    assert(STACK_MAX > STACK_BASE);
+    Runtime.establishStackSpace(e.data.stackBase, e.data.stackBase + e.data.stackSize);
+    var result = 0;
+
+    PThread.receiveObjectTransfer(e.data);
+
+    PThread.setThreadStatus(_pthread_self(), 1/*EM_THREAD_STATUS_RUNNING*/);
+
+    try {
+      // HACK: Some code in the wild has instead signatures of form 'void *ThreadMain()', which seems to be ok in native code.
+      // To emulate supporting both in test suites, use the following form. This is brittle!
+      if (typeof asm['dynCall_ii'] !== 'undefined') {
+        result = asm.dynCall_ii(e.data.start_routine, e.data.arg); // pthread entry points are always of signature 'void *ThreadMain(void *arg)'
+      } else {
+        result = asm.dynCall_i(e.data.start_routine); // as a hack, try signature 'i' as fallback.
+      }
+    } catch(e) {
+      if (e === 'Canceled!') {
+        PThread.threadCancel();
+        return;
+      } else {
+        Atomics.store(HEAPU32, (threadInfoStruct + 4 /*{{{ C_STRUCTS.pthread.threadExitCode }}}*/ ) >> 2, -2 /*A custom entry specific to Emscripten denoting that the thread crashed.*/);
+        Atomics.store(HEAPU32, (threadInfoStruct + 0 /*{{{ C_STRUCTS.pthread.threadStatus }}}*/ ) >> 2, 1); // Mark the thread as no longer running.
+        _emscripten_futex_wake(threadInfoStruct + 0 /*{{{ C_STRUCTS.pthread.threadStatus }}}*/, 0x7FFFFFFF/*INT_MAX*/); // wake all threads
+        throw e;
+      }
+    }
+    // The thread might have finished without calling pthread_exit(). If so, then perform the exit operation ourselves.
+    // (This is a no-op if explicit pthread_exit() had been called prior.)
+    if (!Module['noExitRuntime']) PThread.threadExit(result);
+    else console.log('pthread noExitRuntime: not quitting.');
+  } else if (e.data.cmd === 'cancel') { // Main thread is asking for a pthread_cancel() on this thread.
+    if (threadInfoStruct && PThread.thisThreadCancelState == 0/*PTHREAD_CANCEL_ENABLE*/) {
+      PThread.threadCancel();
+    }
+  } else {
+    Module['printErr']('pthread-main.js received unknown command ' + e.data.cmd);
+  }
+}

examples/physac/physics_demo.c

@@ -28,7 +28,6 @@ int main()
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics demo");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
     int logoX = screenWidth - MeasureText("Physac", 30) - 10;
@@ -44,6 +43,8 @@ int main()
     // 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
@@ -120,6 +121,7 @@ int main()
     // De-Initialization
     //--------------------------------------------------------------------------------------   
     ClosePhysics();       // Unitialize physics
+    
     CloseWindow();        // Close window and OpenGL context
     //--------------------------------------------------------------------------------------
 

examples/physac/physics_friction.c

@@ -28,7 +28,6 @@ int main()
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics friction");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
     int logoX = screenWidth - MeasureText("Physac", 30) - 10;
@@ -63,6 +62,8 @@ int main()
     bodyB->staticFriction = 1;
     bodyB->dynamicFriction = 1;
     SetPhysicsBodyRotation(bodyB, 330*DEG2RAD);
+
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_movement.c

@@ -30,7 +30,6 @@ int main()
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics movement");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
     int logoX = screenWidth - MeasureText("Physac", 30) - 10;
@@ -56,6 +55,8 @@ int main()
     // 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

examples/physac/physics_restitution.c

@@ -28,7 +28,6 @@ int main()
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Physics restitution");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
     int logoX = screenWidth - MeasureText("Physac", 30) - 10;
@@ -49,6 +48,8 @@ int main()
     circleB->restitution = 0.5f;
     PhysicsBody circleC = CreatePhysicsBodyCircle((Vector2){ screenWidth*0.75f, screenHeight/2 }, 30, 10);
     circleC->restitution = 1;
+    
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop

examples/physac/physics_shatter.c

@@ -28,7 +28,6 @@ int main()
 
     SetConfigFlags(FLAG_MSAA_4X_HINT);
     InitWindow(screenWidth, screenHeight, "Physac [raylib] - Body shatter");
-    SetTargetFPS(60);
 
     // Physac logo drawing position
     int logoX = screenWidth - MeasureText("Physac", 30) - 10;
@@ -40,6 +39,8 @@ int main()
 
     // Create random polygon physics body to shatter
     PhysicsBody body = CreatePhysicsBodyPolygon((Vector2){ screenWidth/2, screenHeight/2 }, GetRandomValue(80, 200), GetRandomValue(3, 8), 10);
+    
+    SetTargetFPS(60);
     //--------------------------------------------------------------------------------------
 
     // Main game loop