chore: rebase to main with translation ports

Directory.Build.targets

@@ -7,4 +7,20 @@
   <PropertyGroup Condition="'$(MSBuildProjectName)' == 'Raylib-cs' And '$(RuntimeIdentifier)' == 'browser-wasm'">
     <OutputType>Library</OutputType>
   </PropertyGroup>
+
+  <!-- Raylib-cs 8.1.0 is not on nuget.org yet; pack locally so Examples and tests resolve the package with native runtimes. -->
+  <Target Name="_EnsureLocalRaylibCsPackage"
+          BeforeTargets="Restore"
+          Condition="'$(MSBuildProjectName)' != 'Raylib-cs' And Exists('$(MSBuildThisFileDirectory)Raylib-cs/Raylib-cs.csproj')">
+    <PropertyGroup>
+      <_LocalNuGetDir>$(MSBuildThisFileDirectory)nuget</_LocalNuGetDir>
+      <_LocalRaylibCsNupkg>$(_LocalNuGetDir)/Raylib-cs.$(RaylibCsVersion).nupkg</_LocalRaylibCsNupkg>
+    </PropertyGroup>
+    <MakeDir Directories="$(_LocalNuGetDir)" Condition="!Exists('$(_LocalNuGetDir)')"/>
+    <MSBuild Projects="$(MSBuildThisFileDirectory)Raylib-cs/Raylib-cs.csproj"
+             Targets="Restore;Pack"
+             Properties="Configuration=Release;PackageOutputPath=$(_LocalNuGetDir)"
+             RemoveProperties="RuntimeIdentifier;RuntimeIdentifiers;SelfContained;_IsPublishing"
+             Condition="!Exists('$(_LocalRaylibCsNupkg)') Or '$(ForceRaylibCsPack)' == 'true'"/>
+  </Target>
 </Project>

Examples/Audio/ModulePlaying.cs

@@ -1,13 +1,15 @@
 /*******************************************************************************************
 *
-*   raylib [audio] example - Module playing (streaming)
+*   raylib [audio] example - module playing
 *
-*   NOTE: This example requires OpenAL Soft library installed
+*   Example complexity rating: [★☆☆☆] 1/4
 *
-*   This example has been created using raylib 1.5 (www.raylib.com)
+*   Example originally created with raylib 1.5, last time updated with raylib 3.5
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2016 Ramon Santamaria (@raysan5)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2016-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -16,11 +18,20 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Audio;
 
-public class ModulePlaying
+public partial class ModulePlaying : IExample
 {
-    const int MaxCircles = 64;
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
 
-    struct CircleWave
+    private const int MaxCircles = 64;
+
+    public string Name => "Audio / Module Playing";
+
+    public string Title => "raylib [audio] example - module playing";
+
+    public ConfigFlags ConfigFlags => ConfigFlags.Msaa4xHint;
+
+    private struct CircleWave
     {
         public Vector2 Position;
         public float Radius;
@@ -29,20 +40,18 @@ public class ModulePlaying
         public Color Color;
     }
 
-    public static int Main()
+    private Color[] colors;
+    private CircleWave[] circles;
+    private Music music;
+    private float pitch;
+    private float timePlayed;
+    private bool pause;
+
+    public void Init()
     {
-        // Initialization
+        InitAudioDevice();                  // Initialize audio device
-        //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
 
-        SetConfigFlags(ConfigFlags.Msaa4xHint);      // NOTE: Try to enable MSAA 4X
+        colors = new Color[14] {
-
-        InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing (streaming)");
-
-        InitAudioDevice();
-
-        Color[] colors = new Color[14] {
             Color.Orange,
             Color.Red,
             Color.Gold,
@@ -59,133 +68,163 @@ public class ModulePlaying
             Color.Beige
         };
 
-        // Creates ome circles for visual effect
+        // Creates some circles for visual effect
-        CircleWave[] circles = new CircleWave[MaxCircles];
+        circles = new CircleWave[MaxCircles];
 
-        for (int i = MaxCircles - 1; i >= 0; i--)
+        for (var i = MaxCircles - 1; i >= 0; i--)
         {
             circles[i].Alpha = 0.0f;
             circles[i].Radius = GetRandomValue(10, 40);
             circles[i].Position.X = GetRandomValue((int)circles[i].Radius, screenWidth - (int)circles[i].Radius);
             circles[i].Position.Y = GetRandomValue((int)circles[i].Radius, screenHeight - (int)circles[i].Radius);
-            circles[i].Speed = (float)GetRandomValue(1, 100) / 20000.0f;
+            circles[i].Speed = (float)GetRandomValue(1, 100) / 2000.0f;
             circles[i].Color = colors[GetRandomValue(0, 13)];
         }
 
-        Music music = LoadMusicStream("resources/audio/mini1111.xm");
+        music = LoadMusicStream("resources/audio/mini1111.xm");
         music.Looping = false;
-        float pitch = 1.0f;
+        pitch = 1.0f;
 
         PlayMusicStream(music);
 
-        float timePlayed = 0.0f;
+        timePlayed = 0.0f;
-        bool pause = false;
+        pause = false;
+    }
 
-        SetTargetFPS(60);
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateMusicStream(music);      // Update music buffer with new stream data
+
+        // Restart music playing (stop and play)
+        if (IsKeyPressed(KeyboardKey.Space))
+        {
+            StopMusicStream(music);
+            PlayMusicStream(music);
+        }
+
+        // Pause/Resume music playing
+        if (IsKeyPressed(KeyboardKey.P))
+        {
+            pause = !pause;
+
+            if (pause)
+            {
+                PauseMusicStream(music);
+            }
+            else
+            {
+                ResumeMusicStream(music);
+            }
+        }
+
+        if (IsKeyDown(KeyboardKey.Down))
+        {
+            pitch -= 0.01f;
+        }
+        else if (IsKeyDown(KeyboardKey.Up))
+        {
+            pitch += 0.01f;
+        }
+
+        SetMusicPitch(music, pitch);
+
+        // Get timePlayed scaled to bar dimensions
+        timePlayed = GetMusicTimePlayed(music) / GetMusicTimeLength(music) * (screenWidth - 40);
+
+        // Color circles animation
+        for (var i = MaxCircles - 1; (i >= 0) && !pause; i--)
+        {
+            circles[i].Alpha += circles[i].Speed;
+            circles[i].Radius += circles[i].Speed * 10.0f;
+
+            if (circles[i].Alpha > 1.0f)
+            {
+                circles[i].Speed *= -1;
+            }
+
+            if (circles[i].Alpha <= 0.0f)
+            {
+                circles[i].Alpha = 0.0f;
+                circles[i].Radius = GetRandomValue(10, 40);
+                circles[i].Position.X = GetRandomValue(
+                    (int)circles[i].Radius,
+                    screenWidth - (int)circles[i].Radius
+                );
+                circles[i].Position.Y = GetRandomValue(
+                    (int)circles[i].Radius,
+                    screenHeight - (int)circles[i].Radius
+                );
+                circles[i].Color = colors[GetRandomValue(0, 13)];
+                circles[i].Speed = (float)GetRandomValue(1, 100) / 2000.0f;
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        for (var i = MaxCircles - 1; i >= 0; i--)
+        {
+            DrawCircleV(
+                circles[i].Position,
+                circles[i].Radius,
+                Fade(circles[i].Color, circles[i].Alpha)
+            );
+        }
+
+        // Draw time bar
+        DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, Color.LightGray);
+        DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, Color.Maroon);
+        DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, Color.Gray);
+
+        // Draw help instructions
+        DrawRectangle(20, 20, 425, 145, Color.White);
+        DrawRectangleLines(20, 20, 425, 145, Color.Gray);
+        DrawText("PRESS SPACE TO RESTART MUSIC", 40, 40, 20, Color.Black);
+        DrawText("PRESS P TO PAUSE/RESUME", 40, 70, 20, Color.Black);
+        DrawText("PRESS UP/DOWN TO CHANGE SPEED", 40, 100, 20, Color.Black);
+        DrawText($"SPEED: {pitch:F6}", 40, 130, 20, Color.Maroon);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+        UnloadMusicStream(music);          // Unload music stream buffers from RAM
+
+        CloseAudioDevice();     // Close audio device (music streaming is automatically stopped)
+    }
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        SetConfigFlags(ConfigFlags.Msaa4xHint);  // NOTE: Try to enable MSAA 4X
+
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - module playing");
+
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
         //--------------------------------------------------------------------------------------
 
+        var game = new ModulePlaying();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            UpdateMusicStream(music);        // Update music buffer with new stream data
-
-            // Restart music playing (stop and play)
-            if (IsKeyPressed(KeyboardKey.Space))
-            {
-                StopMusicStream(music);
-                PlayMusicStream(music);
-            }
-
-            // Pause/Resume music playing
-            if (IsKeyPressed(KeyboardKey.P))
-            {
-                pause = !pause;
-
-                if (pause)
-                {
-                    PauseMusicStream(music);
-                }
-                else
-                {
-                    ResumeMusicStream(music);
-                }
-            }
-
-            if (IsKeyDown(KeyboardKey.Down))
-            {
-                pitch -= 0.01f;
-            }
-            else if (IsKeyDown(KeyboardKey.Up))
-            {
-                pitch += 0.01f;
-            }
-
-            SetMusicPitch(music, pitch);
-
-            // Get timePlayed scaled to bar dimensions
-            timePlayed = GetMusicTimePlayed(music) / GetMusicTimeLength(music) * (screenWidth - 40);
-
-            // Color circles animation
-            for (int i = MaxCircles - 1; (i >= 0) && !pause; i--)
-            {
-                circles[i].Alpha += circles[i].Speed;
-                circles[i].Radius += circles[i].Speed * 10.0f;
-
-                if (circles[i].Alpha > 1.0f)
-                {
-                    circles[i].Speed *= -1;
-                }
-
-                if (circles[i].Alpha <= 0.0f)
-                {
-                    circles[i].Alpha = 0.0f;
-                    circles[i].Radius = GetRandomValue(10, 40);
-                    circles[i].Position.X = GetRandomValue(
-                        (int)circles[i].Radius,
-                        screenWidth - (int)circles[i].Radius
-                    );
-                    circles[i].Position.Y = GetRandomValue(
-                        (int)circles[i].Radius,
-                        screenHeight - (int)circles[i].Radius
-                    );
-                    circles[i].Color = colors[GetRandomValue(0, 13)];
-                    circles[i].Speed = (float)GetRandomValue(1, 100) / 2000.0f;
-                }
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            for (int i = MaxCircles - 1; i >= 0; i--)
-            {
-                DrawCircleV(
-                    circles[i].Position,
-                    circles[i].Radius,
-                    ColorAlpha(circles[i].Color, circles[i].Alpha)
-                );
-            }
-
-            // Draw time bar
-            DrawRectangle(20, screenHeight - 20 - 12, screenWidth - 40, 12, Color.LightGray);
-            DrawRectangle(20, screenHeight - 20 - 12, (int)timePlayed, 12, Color.Maroon);
-            DrawRectangleLines(20, screenHeight - 20 - 12, screenWidth - 40, 12, Color.Gray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        UnloadMusicStream(music);
+        CloseWindow();          // Close window and OpenGL context
-
-        CloseAudioDevice();
-
-        CloseWindow();
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Audio/MusicStreamDemo.cs

@@ -1,13 +1,15 @@
 /*******************************************************************************************
 *
-*   raylib [audio] example - IntPtr playing (streaming)
+*   raylib [audio] example - music stream
 *
-*   NOTE: This example requires OpenAL Soft library installed
+*   Example complexity rating: [★☆☆☆] 1/4
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
+*   Example originally created with raylib 1.3, last time updated with raylib 4.2
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2015-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -15,90 +17,176 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Audio;
 
-public class MusicStreamDemo
+public partial class MusicStreamDemo : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Audio / Music Stream Demo";
+
+    public string Title => "raylib [audio] example - music stream";
+
+    public int TargetFps => 30;
+
+    private Music music;
+    private float timePlayed;
+    private bool pause;
+    private float pan;
+    private float volume;
+
+    public void Init()
+    {
+        InitAudioDevice();              // Initialize audio device
+
+        music = LoadMusicStream("resources/audio/country.mp3");
+
+        PlayMusicStream(music);
+
+        timePlayed = 0.0f;              // Time played normalized [0.0f..1.0f]
+        pause = false;                  // Music playing paused
+
+        pan = 0.0f;                     // Default audio pan center [-1.0f..1.0f]
+        SetMusicPan(music, pan);
+
+        volume = 0.8f;                  // Default audio volume [0.0f..1.0f]
+        SetMusicVolume(music, volume);
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateMusicStream(music);   // Update music buffer with new stream data
+
+        // Restart music playing (stop and play)
+        if (IsKeyPressed(KeyboardKey.Space))
+        {
+            StopMusicStream(music);
+            PlayMusicStream(music);
+        }
+
+        // Pause/Resume music playing
+        if (IsKeyPressed(KeyboardKey.P))
+        {
+            pause = !pause;
+
+            if (pause)
+            {
+                PauseMusicStream(music);
+            }
+            else
+            {
+                ResumeMusicStream(music);
+            }
+        }
+
+        // Set audio pan
+        if (IsKeyDown(KeyboardKey.Left))
+        {
+            pan -= 0.05f;
+            if (pan < -1.0f)
+            {
+                pan = -1.0f;
+            }
+            SetMusicPan(music, pan);
+        }
+        else if (IsKeyDown(KeyboardKey.Right))
+        {
+            pan += 0.05f;
+            if (pan > 1.0f)
+            {
+                pan = 1.0f;
+            }
+            SetMusicPan(music, pan);
+        }
+
+        // Set audio volume
+        if (IsKeyDown(KeyboardKey.Down))
+        {
+            volume -= 0.05f;
+            if (volume < 0.0f)
+            {
+                volume = 0.0f;
+            }
+            SetMusicVolume(music, volume);
+        }
+        else if (IsKeyDown(KeyboardKey.Up))
+        {
+            volume += 0.05f;
+            if (volume > 1.0f)
+            {
+                volume = 1.0f;
+            }
+            SetMusicVolume(music, volume);
+        }
+
+        // Get normalized time played for current music stream
+        timePlayed = GetMusicTimePlayed(music) / GetMusicTimeLength(music);
+
+        if (timePlayed > 1.0f)
+        {
+            timePlayed = 1.0f;   // Make sure time played is no longer than music
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, Color.LightGray);
+
+        DrawText("LEFT-RIGHT for PAN CONTROL", 320, 74, 10, Color.DarkBlue);
+        DrawRectangle(300, 100, 200, 12, Color.LightGray);
+        DrawRectangleLines(300, 100, 200, 12, Color.Gray);
+        DrawRectangle((int)(300 + (pan + 1.0f) / 2.0f * 200 - 5), 92, 10, 28, Color.DarkGray);
+
+        DrawRectangle(200, 200, 400, 12, Color.LightGray);
+        DrawRectangle(200, 200, (int)(timePlayed * 400.0f), 12, Color.Maroon);
+        DrawRectangleLines(200, 200, 400, 12, Color.Gray);
+
+        DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, Color.LightGray);
+        DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, Color.LightGray);
+
+        DrawText("UP-DOWN for VOLUME CONTROL", 320, 334, 10, Color.DarkGreen);
+        DrawRectangle(300, 360, 200, 12, Color.LightGray);
+        DrawRectangleLines(300, 360, 200, 12, Color.Gray);
+        DrawRectangle((int)(300 + volume * 200 - 5), 352, 10, 28, Color.DarkGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+        UnloadMusicStream(music);   // Unload music stream buffers from RAM
+
+        CloseAudioDevice();         // Close audio device (music streaming is automatically stopped)
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music stream");
-        const int screenHeight = 450;
 
-        InitWindow(screenWidth, screenHeight, "raylib [audio] example - music playing (streaming)");
+        SetTargetFPS(30);               // Set our game to run at 30 frames-per-second
-        InitAudioDevice();
-
-        Music music = LoadMusicStream("resources/audio/country.mp3");
-        PlayMusicStream(music);
-
-        float timePlayed = 0.0f;
-        bool pause = false;
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new MusicStreamDemo();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            UpdateMusicStream(music);        // Update music buffer with new stream data
-
-            // Restart music playing (stop and play)
-            if (IsKeyPressed(KeyboardKey.Space))
-            {
-                StopMusicStream(music);
-                PlayMusicStream(music);
-            }
-
-            // Pause/Resume music playing
-            if (IsKeyPressed(KeyboardKey.P))
-            {
-                pause = !pause;
-
-                if (pause)
-                {
-                    PauseMusicStream(music);
-                }
-                else
-                {
-                    ResumeMusicStream(music);
-                }
-            }
-
-            // Get timePlayed scaled to bar dimensions (400 pixels)
-            timePlayed = GetMusicTimePlayed(music) / GetMusicTimeLength(music) * 400;
-
-            if (timePlayed > 400)
-            {
-                StopMusicStream(music);
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawText("MUSIC SHOULD BE PLAYING!", 255, 150, 20, Color.LightGray);
-
-            DrawRectangle(200, 200, 400, 12, Color.LightGray);
-            DrawRectangle(200, 200, (int)timePlayed, 12, Color.Maroon);
-            DrawRectangleLines(200, 200, 400, 12, Color.Gray);
-
-            DrawText("PRESS SPACE TO RESTART MUSIC", 215, 250, 20, Color.LightGray);
-            DrawText("PRESS P TO PAUSE/RESUME MUSIC", 208, 280, 20, Color.LightGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        UnloadMusicStream(music);
+        CloseWindow();              // Close window and OpenGL context
-
-        CloseAudioDevice();
-
-        CloseWindow();
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Audio/SoundLoading.cs

@@ -1,13 +1,15 @@
 /*******************************************************************************************
 *
-*   raylib [audio] example - Sound loading and playing
+*   raylib [audio] example - sound loading
 *
-*   NOTE: This example requires OpenAL Soft library installed
+*   Example complexity rating: [★☆☆☆] 1/4
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
+*   Example originally created with raylib 1.1, last time updated with raylib 3.5
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2014-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -15,60 +17,84 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Audio;
 
-public class SoundLoading
+public partial class SoundLoading : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Audio / Sound Loading";
+
+    public string Title => "raylib [audio] example - sound loading";
+
+    private Sound fxWav;
+    private Sound fxOgg;
+
+    public void Init()
+    {
+        InitAudioDevice();      // Initialize audio device
+
+        fxWav = LoadSound("resources/audio/sound.wav");         // Load WAV audio file
+        fxOgg = LoadSound("resources/audio/target.ogg");        // Load OGG audio file
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KeyboardKey.Space))
+        {
+            PlaySound(fxWav);      // Play WAV sound
+        }
+
+        if (IsKeyPressed(KeyboardKey.Enter))
+        {
+            PlaySound(fxOgg);      // Play OGG sound
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, Color.LightGray);
+        DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, Color.LightGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+        UnloadSound(fxWav);     // Unload sound data
+        UnloadSound(fxOgg);     // Unload sound data
+
+        CloseAudioDevice();     // Close audio device
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
+        InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading");
-        const int screenHeight = 450;
 
-        InitWindow(screenWidth, screenHeight, "raylib [audio] example - sound loading and playing");
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        InitAudioDevice();
-
-        Sound fxWav = LoadSound("resources/audio/sound.wav");
-        Sound fxOgg = LoadSound("resources/audio/target.ogg");
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new SoundLoading();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            if (IsKeyPressed(KeyboardKey.Space))
-            {
-                PlaySound(fxWav);
-            }
-
-            if (IsKeyPressed(KeyboardKey.Enter))
-            {
-                PlaySound(fxOgg);
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawText("Press SPACE to PLAY the WAV sound!", 200, 180, 20, Color.LightGray);
-            DrawText("Press ENTER to PLAY the OGG sound!", 200, 220, 20, Color.LightGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        UnloadSound(fxWav);
+        CloseWindow();          // Close window and OpenGL context
-        UnloadSound(fxOgg);
-
-        CloseAudioDevice();
-
-        CloseWindow();
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/BasicScreenManager.cs

@@ -1,21 +1,17 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Basic window
+*   raylib [core] example - basic screen manager
 *
-*   Welcome to raylib!
+*   Example complexity rating: [★☆☆☆] 1/4
 *
-*   To test examples, just press F6 and execute raylib_compile_execute script
+*   NOTE: This example illustrates a very simple screen manager based on a states machines
-*   Note that compiled executable is placed in the same folder as .c file
 *
-*   You can find all basic examples on C:\raylib\raylib\examples folder or
+*   Example originally created with raylib 4.0, last time updated with raylib 4.0
-*   raylib official webpage: www.raylib.com
 *
-*   Enjoy using raylib. :)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
+*   Copyright (c) 2021-2025 Ramon Santamaria (@raysan5)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
-*
-*   Copyright (c) 2013-2016 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -23,7 +19,7 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-enum GameScreen
+internal enum GameScreen
 {
     Logo = 0,
     Title,
@@ -31,143 +27,160 @@ enum GameScreen
     Ending
 }
 
-public class BasicScreenManager
+public partial class BasicScreenManager : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Basic Screen Manager";
+
+    public string Title => "raylib [core] example - basic screen manager";
+
+    private GameScreen currentScreen;
+    private int framesCounter;
+
+    public void Init()
+    {
+        currentScreen = GameScreen.Logo;
+
+        // TODO: Initialize all required variables and load all required data here!
+
+        framesCounter = 0;          // Useful to count frames
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        switch (currentScreen)
+        {
+            case GameScreen.Logo:
+                {
+                    // TODO: Update LOGO screen variables here!
+
+                    framesCounter++;    // Count frames
+
+                    // Wait for 2 seconds (120 frames) before jumping to TITLE screen
+                    if (framesCounter > 120)
+                    {
+                        currentScreen = GameScreen.Title;
+                    }
+                }
+                break;
+            case GameScreen.Title:
+                {
+                    // TODO: Update TITLE screen variables here!
+
+                    // Press enter to change to GAMEPLAY screen
+                    if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
+                    {
+                        currentScreen = GameScreen.Gameplay;
+                    }
+                }
+                break;
+            case GameScreen.Gameplay:
+                {
+                    // TODO: Update GAMEPLAY screen variables here!
+
+                    // Press enter to change to ENDING screen
+                    if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
+                    {
+                        currentScreen = GameScreen.Ending;
+                    }
+                }
+                break;
+            case GameScreen.Ending:
+                {
+                    // TODO: Update ENDING screen variables here!
+
+                    // Press enter to return to TITLE screen
+                    if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
+                    {
+                        currentScreen = GameScreen.Title;
+                    }
+                }
+                break;
+            default:
+                break;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+        ClearBackground(Color.RayWhite);
+
+        switch (currentScreen)
+        {
+            case GameScreen.Logo:
+                {
+                    // TODO: Draw LOGO screen here!
+                    DrawText("LOGO SCREEN", 20, 20, 40, Color.LightGray);
+                    DrawText("WAIT for 2 SECONDS...", 290, 220, 20, Color.Gray);
+                }
+                break;
+            case GameScreen.Title:
+                {
+                    // TODO: Draw TITLE screen here!
+                    DrawRectangle(0, 0, screenWidth, screenHeight, Color.Green);
+                    DrawText("TITLE SCREEN", 20, 20, 40, Color.DarkGreen);
+                    DrawText("PRESS ENTER or TAP to JUMP to GAMEPLAY SCREEN", 120, 220, 20, Color.DarkGreen);
+                }
+                break;
+            case GameScreen.Gameplay:
+                {
+                    // TODO: Draw GAMEPLAY screen here!
+                    DrawRectangle(0, 0, screenWidth, screenHeight, Color.Purple);
+                    DrawText("GAMEPLAY SCREEN", 20, 20, 40, Color.Maroon);
+                    DrawText("PRESS ENTER or TAP to JUMP to ENDING SCREEN", 130, 220, 20, Color.Maroon);
+
+                }
+                break;
+            case GameScreen.Ending:
+                {
+                    // TODO: Draw ENDING screen here!
+                    DrawRectangle(0, 0, screenWidth, screenHeight, Color.Blue);
+                    DrawText("ENDING SCREEN", 20, 20, 40, Color.DarkBlue);
+                    DrawText("PRESS ENTER or TAP to RETURN to TITLE SCREEN", 120, 220, 20, Color.DarkBlue);
+                }
+                break;
+            default:
+                break;
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+        // TODO: Unload all loaded data (textures, fonts, audio) here!
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - basic screen manager");
 
-        GameScreen currentScreen = GameScreen.Logo;
-
-        // TODO: Initialize all required variables and load all required data here!
-
-        // Useful to count frames
-        int framesCounter = 0;
-
         SetTargetFPS(60);               // Set desired framerate (frames-per-second)
         //--------------------------------------------------------------------------------------
 
+        var game = new BasicScreenManager();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            switch (currentScreen)
-            {
-                case GameScreen.Logo:
-                    {
-                        // TODO: Update LOGO screen variables here!
-
-                        // Count frames
-                        framesCounter++;
-
-                        // Wait for 2 seconds (120 frames) before jumping to TITLE screen
-                        if (framesCounter > 120)
-                        {
-                            currentScreen = GameScreen.Title;
-                        }
-                    }
-                    break;
-                case GameScreen.Title:
-                    {
-                        // TODO: Update TITLE screen variables here!
-
-                        // Press enter to change to GAMEPLAY screen
-                        if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
-                        {
-                            currentScreen = GameScreen.Gameplay;
-                        }
-                    }
-                    break;
-                case GameScreen.Gameplay:
-                    {
-                        // TODO: Update GAMEPLAY screen variables here!
-
-                        // Press enter to change to ENDING screen
-                        if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
-                        {
-                            currentScreen = GameScreen.Ending;
-                        }
-                    }
-                    break;
-                case GameScreen.Ending:
-                    {
-                        // TODO: Update ENDING screen variables here!
-
-                        // Press enter to return to TITLE screen
-                        if (IsKeyPressed(KeyboardKey.Enter) || IsGestureDetected(Gesture.Tap))
-                        {
-                            currentScreen = GameScreen.Title;
-                        }
-                    }
-                    break;
-                default:
-                    break;
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-
-            ClearBackground(Color.RayWhite);
-
-            switch (currentScreen)
-            {
-                case GameScreen.Logo:
-                    {
-                        // TODO: Draw LOGO screen here!
-                        DrawText("LOGO SCREEN", 20, 20, 40, Color.LightGray);
-                        DrawText("WAIT for 2 SECONDS...", 290, 220, 20, Color.Gray);
-
-                    }
-                    break;
-                case GameScreen.Title:
-                    {
-                        // TODO: Draw TITLE screen here!
-                        DrawRectangle(0, 0, screenWidth, screenHeight, Color.Green);
-                        DrawText("TITLE SCREEN", 20, 20, 40, Color.DarkGreen);
-                        DrawText("PRESS ENTER or TAP to JUMP to GAMEPLAY SCREEN", 120, 220, 20, Color.DarkGreen);
-
-                    }
-                    break;
-                case GameScreen.Gameplay:
-                    {
-                        // TODO: Draw GAMEPLAY screen here!
-                        DrawRectangle(0, 0, screenWidth, screenHeight, Color.Purple);
-                        DrawText("GAMEPLAY SCREEN", 20, 20, 40, Color.Maroon);
-                        DrawText("PRESS ENTER or TAP to JUMP to ENDING SCREEN", 130, 220, 20, Color.Maroon);
-
-                    }
-                    break;
-                case GameScreen.Ending:
-                    {
-                        // TODO: Draw ENDING screen here!
-                        DrawRectangle(0, 0, screenWidth, screenHeight, Color.Blue);
-                        DrawText("ENDING SCREEN", 20, 20, 40, Color.DarkBlue);
-                        DrawText("PRESS ENTER or TAP to RETURN to TITLE SCREEN", 120, 220, 20, Color.DarkBlue);
-
-                    }
-                    break;
-                default:
-                    break;
-            }
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-
+        CloseWindow();        // Close window and OpenGL context
-        // TODO: Unload all loaded data (textures, fonts, audio) here!
-
-        CloseWindow();
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/BasicWindow.cs

@@ -33,43 +33,56 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class BasicWindow
+public partial class BasicWindow : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Basic Window";
+
+    public string Title => "raylib [core] example - basic window";
+
+    public void Init()
+    {
+    }
+
+    public void Update()
+    {
+
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawText("Congrats! You created your first window!", 190, 200, 20, Color.LightGray);
+
+        EndDrawing();
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - basic window");
 
-        SetTargetFPS(60);
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        //--------------------------------------------------------------------------------------
+
+        var game = new BasicWindow();
+        game.Init();
 
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            // TODO: Update your variables here
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawText("Congrats! You created your first window!", 190, 200, 20, Color.LightGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
-        //--------------------------------------------------------------------------------------
 
         return 0;
     }

Examples/Core/Camera2dDemo.cs

@@ -13,31 +13,37 @@
 *
 ********************************************************************************************/
 
+using System;
 using System.Numerics;
 using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class Camera2dDemo
+public partial class Camera2dDemo : IExample
 {
     public const int MaxBuildings = 100;
 
-    public static int Main()
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Camera 2D Demo";
+
+    public string Title => "raylib [core] example - 2d camera";
+
+    private Rectangle player;
+    private Rectangle[] buildings;
+    private Color[] buildColors;
+    private Camera2D camera;
+
+    public void Init()
     {
-        // Initialization
+        player = new(400, 280, 40, 40);
-        //--------------------------------------------------------------------------------------
+        buildings = new Rectangle[MaxBuildings];
-        const int screenWidth = 800;
+        buildColors = new Color[MaxBuildings];
-        const int screenHeight = 450;
 
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
+        var spacing = 0;
 
-        Rectangle player = new(400, 280, 40, 40);
+        for (var i = 0; i < MaxBuildings; i++)
-        Rectangle[] buildings = new Rectangle[MaxBuildings];
-        Color[] buildColors = new Color[MaxBuildings];
-
-        int spacing = 0;
-
-        for (int i = 0; i < MaxBuildings; i++)
         {
             buildings[i].Width = GetRandomValue(50, 200);
             buildings[i].Height = GetRandomValue(100, 800);
@@ -54,124 +60,139 @@ public class Camera2dDemo
             );
         }
 
-        Camera2D camera = new();
+        camera = new();
         camera.Target = new Vector2(player.X + 20, player.Y + 20);
-        camera.Offset = new Vector2(screenWidth / 2, screenHeight / 2);
+        camera.Offset = new Vector2(screenWidth / 2.0f, screenHeight / 2.0f);
         camera.Rotation = 0.0f;
         camera.Zoom = 1.0f;
+    }
 
-        SetTargetFPS(60);
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // Player movement
+        if (IsKeyDown(KeyboardKey.Right))
+        {
+            player.X += 2;
+        }
+        else if (IsKeyDown(KeyboardKey.Left))
+        {
+            player.X -= 2;
+        }
+
+        // Camera target follows player
+        camera.Target = new Vector2(player.X + 20, player.Y + 20);
+
+        // Camera rotation controls
+        if (IsKeyDown(KeyboardKey.A))
+        {
+            camera.Rotation--;
+        }
+        else if (IsKeyDown(KeyboardKey.S))
+        {
+            camera.Rotation++;
+        }
+
+        // Limit camera rotation to 80 degrees (-40 to 40)
+        if (camera.Rotation > 40)
+        {
+            camera.Rotation = 40;
+        }
+        else if (camera.Rotation < -40)
+        {
+            camera.Rotation = -40;
+        }
+
+        // Camera zoom controls
+        // Uses log scaling to provide consistent zoom speed
+        camera.Zoom = MathF.Exp(MathF.Log(camera.Zoom) + ((float)GetMouseWheelMove() * 0.1f));
+
+        if (camera.Zoom > 3.0f)
+        {
+            camera.Zoom = 3.0f;
+        }
+        else if (camera.Zoom < 0.1f)
+        {
+            camera.Zoom = 0.1f;
+        }
+
+        // Camera reset (zoom and rotation)
+        if (IsKeyPressed(KeyboardKey.R))
+        {
+            camera.Zoom = 1.0f;
+            camera.Rotation = 0.0f;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        BeginMode2D(camera);
+
+        DrawRectangle(-6000, 320, 13000, 8000, Color.DarkGray);
+
+        for (var i = 0; i < MaxBuildings; i++)
+        {
+            DrawRectangleRec(buildings[i], buildColors[i]);
+        }
+
+        DrawRectangleRec(player, Color.Red);
+
+        DrawLine((int)camera.Target.X, -screenHeight * 10, (int)camera.Target.X, screenHeight * 10, Color.Green);
+        DrawLine(-screenWidth * 10, (int)camera.Target.Y, screenWidth * 10, (int)camera.Target.Y, Color.Green);
+
+        EndMode2D();
+
+        DrawText("SCREEN AREA", 640, 10, 20, Color.Red);
+
+        DrawRectangle(0, 0, screenWidth, 5, Color.Red);
+        DrawRectangle(0, 5, 5, screenHeight - 10, Color.Red);
+        DrawRectangle(screenWidth - 5, 5, 5, screenHeight - 10, Color.Red);
+        DrawRectangle(0, screenHeight - 5, screenWidth, 5, Color.Red);
+
+        DrawRectangle(10, 10, 250, 113, Fade(Color.SkyBlue, 0.5f));
+        DrawRectangleLines(10, 10, 250, 113, Color.Blue);
+
+        DrawText("Free 2D camera controls:", 20, 20, 10, Color.Black);
+        DrawText("- Right/Left to move player", 40, 40, 10, Color.DarkGray);
+        DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, Color.DarkGray);
+        DrawText("- A / S to Rotate", 40, 80, 10, Color.DarkGray);
+        DrawText("- R to reset Zoom and Rotation", 40, 100, 10, Color.DarkGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
+
+        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
         //--------------------------------------------------------------------------------------
 
+        var game = new Camera2dDemo();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())        // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-
-            // Player movement
-            if (IsKeyDown(KeyboardKey.Right))
-            {
-                player.X += 2;
-            }
-            else if (IsKeyDown(KeyboardKey.Left))
-            {
-                player.X -= 2;
-            }
-
-            // Camera3D target follows player
-            camera.Target = new Vector2(player.X + 20, player.Y + 20);
-
-            // Camera3D rotation controls
-            if (IsKeyDown(KeyboardKey.A))
-            {
-                camera.Rotation--;
-            }
-            else if (IsKeyDown(KeyboardKey.S))
-            {
-                camera.Rotation++;
-            }
-
-            // Limit camera rotation to 80 degrees (-40 to 40)
-            if (camera.Rotation > 40)
-            {
-                camera.Rotation = 40;
-            }
-            else if (camera.Rotation < -40)
-            {
-                camera.Rotation = -40;
-            }
-
-            // Camera3D zoom controls
-            camera.Zoom += ((float)GetMouseWheelMove() * 0.05f);
-
-            if (camera.Zoom > 3.0f)
-            {
-                camera.Zoom = 3.0f;
-            }
-            else if (camera.Zoom < 0.1f)
-            {
-                camera.Zoom = 0.1f;
-            }
-
-            // Camera3D reset (zoom and rotation)
-            if (IsKeyPressed(KeyboardKey.R))
-            {
-                camera.Zoom = 1.0f;
-                camera.Rotation = 0.0f;
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            BeginMode2D(camera);
-
-            DrawRectangle(-6000, 320, 13000, 8000, Color.DarkGray);
-
-            for (int i = 0; i < MaxBuildings; i++)
-            {
-                DrawRectangleRec(buildings[i], buildColors[i]);
-            }
-
-            DrawRectangleRec(player, Color.Red);
-
-            DrawRectangle((int)camera.Target.X, -500, 1, (int)(screenHeight * 4), Color.Green);
-            DrawLine(
-                (int)(-screenWidth * 10),
-                (int)camera.Target.Y,
-                (int)(screenWidth * 10),
-                (int)camera.Target.Y,
-                Color.Green
-            );
-
-            EndMode2D();
-
-            DrawText("SCREEN AREA", 640, 10, 20, Color.Red);
-
-            DrawRectangle(0, 0, (int)screenWidth, 5, Color.Red);
-            DrawRectangle(0, 5, 5, (int)screenHeight - 10, Color.Red);
-            DrawRectangle((int)screenWidth - 5, 5, 5, (int)screenHeight - 10, Color.Red);
-            DrawRectangle(0, (int)screenHeight - 5, (int)screenWidth, 5, Color.Red);
-
-            DrawRectangle(10, 10, 250, 113, ColorAlpha(Color.SkyBlue, 0.5f));
-            DrawRectangleLines(10, 10, 250, 113, Color.Blue);
-
-            DrawText("Free 2d camera controls:", 20, 20, 10, Color.Black);
-            DrawText("- Right/Left to move Offset", 40, 40, 10, Color.DarkGray);
-            DrawText("- Mouse Wheel to Zoom in-out", 40, 60, 10, Color.DarkGray);
-            DrawText("- A / S to Rotate", 40, 80, 10, Color.DarkGray);
-            DrawText("- R to reset Zoom and Rotation", 40, 100, 10, Color.DarkGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/Camera2dPlatformer.cs

@@ -2,12 +2,16 @@
 *
 *   raylib [core] example - 2d camera platformer
 *
-*   This example has been created using raylib 2.5 (www.raylib.com)
+*   Example complexity rating: [★★★☆] 3/4
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Example originally created with raylib 2.5, last time updated with raylib 3.0
 *
 *   Example contributed by arvyy (@arvyy) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2019 arvyy (@arvyy)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2019-2025 arvyy (@arvyy)
 *
 ********************************************************************************************/
 
@@ -18,20 +22,27 @@ using static Raylib_cs.Raymath;
 
 namespace Examples.Core;
 
-public class Camera2dPlatformer
+public partial class Camera2dPlatformer : IExample
 {
-    const int G = 400;
+    private const int screenWidth = 800;
-    const float PlayerJumpSpeed = 350.0f;
+    private const int screenHeight = 450;
-    const float PlayerHorSpeed = 200.0f;
 
-    struct Player
+    private const int G = 400;
+    private const float PlayerJumpSpeed = 350.0f;
+    private const float PlayerHorSpeed = 200.0f;
+
+    public string Name => "Core / 2D Camera Platformer";
+
+    public string Title => "raylib [core] example - 2d camera platformer";
+
+    private struct Player
     {
         public Vector2 Position;
         public float Speed;
         public bool CanJump;
     }
 
-    struct EnvItem
+    private struct EnvItem
     {
         public Rectangle Rect;
         public int Blocking;
@@ -45,7 +56,7 @@ public class Camera2dPlatformer
         }
     }
 
-    delegate void CameraUpdaterCallback(
+    private delegate void CameraUpdaterCallback(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -54,21 +65,22 @@ public class Camera2dPlatformer
         int height
     );
 
-    public static int Main()
+    private Player player;
+    private EnvItem[] envItems;
+    private Camera2D camera;
+    private CameraUpdaterCallback[] cameraUpdaters;
+    private int cameraOption;
+    private int cameraUpdatersLength;
+    private string[] cameraDescriptions;
+
+    public void Init()
     {
-        // Initialization
+        player = new();
-        //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera");
-
-        Player player = new();
         player.Position = new Vector2(400, 280);
         player.Speed = 0;
         player.CanJump = false;
 
-        EnvItem[] envItems = new EnvItem[]
+        envItems = new EnvItem[]
         {
             new EnvItem(new Rectangle(0, 0, 1000, 400), 0, Color.LightGray),
             new EnvItem(new Rectangle(0, 400, 1000, 200), 1, Color.Gray),
@@ -77,14 +89,14 @@ public class Camera2dPlatformer
             new EnvItem(new Rectangle(650, 300, 100, 10), 1, Color.Gray)
         };
 
-        Camera2D camera = new();
+        camera = new();
         camera.Target = player.Position;
-        camera.Offset = new Vector2(screenWidth / 2, screenHeight / 2);
+        camera.Offset = new Vector2(screenWidth / 2.0f, screenHeight / 2.0f);
         camera.Rotation = 0.0f;
         camera.Zoom = 1.0f;
 
-        // Store callbacks to the multiple update camera functions
+        // Store pointers to the multiple update camera functions
-        CameraUpdaterCallback[] cameraUpdaters = new CameraUpdaterCallback[]
+        cameraUpdaters = new CameraUpdaterCallback[]
         {
             UpdateCameraCenter,
             UpdateCameraCenterInsideMap,
@@ -93,93 +105,89 @@ public class Camera2dPlatformer
             UpdateCameraPlayerBoundsPush
         };
 
-        int cameraOption = 0;
+        cameraOption = 0;
-        int cameraUpdatersLength = cameraUpdaters.Length;
+        cameraUpdatersLength = cameraUpdaters.Length;
 
-        string[] cameraDescriptions = new string[]{
+        cameraDescriptions = new string[]{
             "Follow player center",
             "Follow player center, but clamp to map edges",
             "Follow player center; smoothed",
             "Follow player center horizontally; update player center vertically after landing",
             "Player push camera on getting too close to screen edge"
         };
-
-        SetTargetFPS(60);
-        //--------------------------------------------------------------------------------------
-
-        // Main game loop
-        while (!WindowShouldClose())
-        {
-            // Update
-            //----------------------------------------------------------------------------------
-            float deltaTime = GetFrameTime();
-
-            UpdatePlayer(ref player, envItems, deltaTime);
-
-            camera.Zoom += ((float)GetMouseWheelMove() * 0.05f);
-
-            if (camera.Zoom > 3.0f)
-            {
-                camera.Zoom = 3.0f;
-            }
-            else if (camera.Zoom < 0.25f)
-            {
-                camera.Zoom = 0.25f;
-            }
-
-            if (IsKeyPressed(KeyboardKey.R))
-            {
-                camera.Zoom = 1.0f;
-                player.Position = new Vector2(400, 280);
-            }
-
-            if (IsKeyPressed(KeyboardKey.C))
-            {
-                cameraOption = (cameraOption + 1) % cameraUpdatersLength;
-            }
-
-            // Call update camera function by its pointer
-            cameraUpdaters[cameraOption](ref camera, ref player, envItems, deltaTime, screenWidth, screenHeight);
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.LightGray);
-
-            BeginMode2D(camera);
-
-            for (int i = 0; i < envItems.Length; i++)
-            {
-                DrawRectangleRec(envItems[i].Rect, envItems[i].Color);
-            }
-
-            Rectangle playerRect = new(player.Position.X - 20, player.Position.Y - 40, 40, 40);
-            DrawRectangleRec(playerRect, Color.Red);
-
-            EndMode2D();
-
-            DrawText("Controls:", 20, 20, 10, Color.Black);
-            DrawText("- Right/Left to move", 40, 40, 10, Color.DarkGray);
-            DrawText("- Space to jump", 40, 60, 10, Color.DarkGray);
-            DrawText("- Mouse Wheel to Zoom in-out, R to reset zoom", 40, 80, 10, Color.DarkGray);
-            DrawText("- C to change camera mode", 40, 100, 10, Color.DarkGray);
-            DrawText("Current camera mode:", 20, 120, 10, Color.Black);
-            DrawText(cameraDescriptions[cameraOption], 40, 140, 10, Color.DarkGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
-        }
-
-        // De-Initialization
-        //--------------------------------------------------------------------------------------
-        CloseWindow();
-        //--------------------------------------------------------------------------------------
-
-        return 0;
     }
 
-    static void UpdatePlayer(ref Player player, EnvItem[] envItems, float delta)
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        var deltaTime = GetFrameTime();
+
+        UpdatePlayer(ref player, envItems, deltaTime);
+
+        camera.Zoom += ((float)GetMouseWheelMove() * 0.05f);
+
+        if (camera.Zoom > 3.0f)
+        {
+            camera.Zoom = 3.0f;
+        }
+        else if (camera.Zoom < 0.25f)
+        {
+            camera.Zoom = 0.25f;
+        }
+
+        if (IsKeyPressed(KeyboardKey.R))
+        {
+            camera.Zoom = 1.0f;
+            player.Position = new Vector2(400, 280);
+        }
+
+        if (IsKeyPressed(KeyboardKey.C))
+        {
+            cameraOption = (cameraOption + 1) % cameraUpdatersLength;
+        }
+
+        // Call update camera function by its pointer
+        cameraUpdaters[cameraOption](ref camera, ref player, envItems, deltaTime, screenWidth, screenHeight);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.LightGray);
+
+        BeginMode2D(camera);
+
+        for (var i = 0; i < envItems.Length; i++)
+        {
+            DrawRectangleRec(envItems[i].Rect, envItems[i].Color);
+        }
+
+        Rectangle playerRect = new(player.Position.X - 20, player.Position.Y - 40, 40.0f, 40.0f);
+        DrawRectangleRec(playerRect, Color.Red);
+
+        DrawCircleV(player.Position, 5.0f, Color.Gold);
+
+        EndMode2D();
+
+        DrawText("Controls:", 20, 20, 10, Color.Black);
+        DrawText("- Right/Left to move", 40, 40, 10, Color.DarkGray);
+        DrawText("- Space to jump", 40, 60, 10, Color.DarkGray);
+        DrawText("- Mouse Wheel to Zoom in-out", 40, 80, 10, Color.DarkGray);
+        DrawText("- R to reset position + zoom", 40, 100, 10, Color.DarkGray);
+        DrawText("- C to change camera mode", 40, 120, 10, Color.DarkGray);
+        DrawText("Current camera mode:", 20, 140, 10, Color.Black);
+        DrawText(cameraDescriptions[cameraOption], 40, 160, 10, Color.DarkGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
+    private static void UpdatePlayer(ref Player player, EnvItem[] envItems, float delta)
     {
         if (IsKeyDown(KeyboardKey.Left))
         {
@@ -197,11 +205,11 @@ public class Camera2dPlatformer
             player.CanJump = false;
         }
 
-        int hitObstacle = 0;
+        var hitObstacle = 0;
-        for (int i = 0; i < envItems.Length; i++)
+        for (var i = 0; i < envItems.Length; i++)
         {
-            EnvItem ei = envItems[i];
+            var ei = envItems[i];
-            Vector2 p = player.Position;
+            var p = player.Position;
             if (ei.Blocking != 0 &&
                 ei.Rect.X <= p.X &&
                 ei.Rect.X + ei.Rect.Width >= p.X &&
@@ -211,6 +219,7 @@ public class Camera2dPlatformer
                 hitObstacle = 1;
                 player.Speed = 0.0f;
                 player.Position.Y = ei.Rect.Y;
+                break;
             }
         }
 
@@ -226,7 +235,7 @@ public class Camera2dPlatformer
         }
     }
 
-    static void UpdateCameraCenter(
+    private static void UpdateCameraCenter(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -235,11 +244,11 @@ public class Camera2dPlatformer
         int height
     )
     {
-        camera.Offset = new Vector2(width / 2, height / 2);
+        camera.Offset = new Vector2(width / 2.0f, height / 2.0f);
         camera.Target = player.Position;
     }
 
-    static void UpdateCameraCenterInsideMap(
+    private static void UpdateCameraCenterInsideMap(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -248,43 +257,43 @@ public class Camera2dPlatformer
         int height)
     {
         camera.Target = player.Position;
-        camera.Offset = new Vector2(width / 2, height / 2);
+        camera.Offset = new Vector2(width / 2.0f, height / 2.0f);
         float minX = 1000, minY = 1000, maxX = -1000, maxY = -1000;
 
-        for (int i = 0; i < envItems.Length; i++)
+        for (var i = 0; i < envItems.Length; i++)
         {
-            EnvItem ei = envItems[i];
+            var ei = envItems[i];
             minX = Math.Min(ei.Rect.X, minX);
             maxX = Math.Max(ei.Rect.X + ei.Rect.Width, maxX);
             minY = Math.Min(ei.Rect.Y, minY);
             maxY = Math.Max(ei.Rect.Y + ei.Rect.Height, maxY);
         }
 
-        Vector2 max = GetWorldToScreen2D(new Vector2(maxX, maxY), camera);
+        var max = GetWorldToScreen2D(new Vector2(maxX, maxY), camera);
-        Vector2 min = GetWorldToScreen2D(new Vector2(minX, minY), camera);
+        var min = GetWorldToScreen2D(new Vector2(minX, minY), camera);
 
         if (max.X < width)
         {
-            camera.Offset.X = width - (max.X - width / 2);
+            camera.Offset.X = width - (max.X - width / 2.0f);
         }
 
         if (max.Y < height)
         {
-            camera.Offset.Y = height - (max.Y - height / 2);
+            camera.Offset.Y = height - (max.Y - height / 2.0f);
         }
 
         if (min.X > 0)
         {
-            camera.Offset.X = width / 2 - min.X;
+            camera.Offset.X = width / 2.0f - min.X;
         }
 
         if (min.Y > 0)
         {
-            camera.Offset.Y = height / 2 - min.Y;
+            camera.Offset.Y = height / 2.0f - min.Y;
         }
     }
 
-    static void UpdateCameraCenterSmoothFollow(
+    private static void UpdateCameraCenterSmoothFollow(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -297,18 +306,18 @@ public class Camera2dPlatformer
         const float minEffectLength = 10;
         const float fractionSpeed = 0.8f;
 
-        camera.Offset = new Vector2(width / 2, height / 2);
+        camera.Offset = new Vector2(width / 2.0f, height / 2.0f);
-        Vector2 diff = Vector2Subtract(player.Position, camera.Target);
+        var diff = Vector2Subtract(player.Position, camera.Target);
-        float length = Vector2Length(diff);
+        var length = Vector2Length(diff);
 
         if (length > minEffectLength)
         {
-            float speed = Math.Max(fractionSpeed * length, minSpeed);
+            var speed = Math.Max(fractionSpeed * length, minSpeed);
             camera.Target = Vector2Add(camera.Target, Vector2Scale(diff, speed * delta / length));
         }
     }
 
-    static void UpdateCameraEvenOutOnLanding(
+    private static void UpdateCameraEvenOutOnLanding(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -318,10 +327,10 @@ public class Camera2dPlatformer
     )
     {
         float evenOutSpeed = 700;
-        int eveningOut = 0;
+        var eveningOut = 0;
-        float evenOutTarget = 0.0f;
+        var evenOutTarget = 0.0f;
 
-        camera.Offset = new Vector2(width / 2, height / 2);
+        camera.Offset = new Vector2(width / 2.0f, height / 2.0f);
         camera.Target.X = player.Position.X;
 
         if (eveningOut != 0)
@@ -357,7 +366,7 @@ public class Camera2dPlatformer
         }
     }
 
-    static void UpdateCameraPlayerBoundsPush(
+    private static void UpdateCameraPlayerBoundsPush(
         ref Camera2D camera,
         ref Player player,
         EnvItem[] envItems,
@@ -368,11 +377,11 @@ public class Camera2dPlatformer
     {
         Vector2 bbox = new(0.2f, 0.2f);
 
-        Vector2 bboxWorldMin = GetScreenToWorld2D(
+        var bboxWorldMin = GetScreenToWorld2D(
             new Vector2((1 - bbox.X) * 0.5f * width, (1 - bbox.Y) * 0.5f * height),
             camera
         );
-        Vector2 bboxWorldMax = GetScreenToWorld2D(
+        var bboxWorldMax = GetScreenToWorld2D(
             new Vector2((1 + bbox.X) * 0.5f * width,
             (1 + bbox.Y) * 0.5f * height),
             camera
@@ -399,4 +408,32 @@ public class Camera2dPlatformer
             camera.Target.Y = bboxWorldMin.Y + (player.Position.Y - bboxWorldMax.Y);
         }
     }
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - 2d camera platformer");
+
+        SetTargetFPS(60);
+        //--------------------------------------------------------------------------------------
+
+        var game = new Camera2dPlatformer();
+        game.Init();
+
+        // Main game loop
+        while (!WindowShouldClose())
+        {
+            game.Update();
+        }
+
+        game.Unload();
+
+        // De-Initialization
+        //--------------------------------------------------------------------------------------
+        CloseWindow();        // Close window and OpenGL context
+        //--------------------------------------------------------------------------------------
+
+        return 0;
+    }
 }

Examples/Core/Camera3dFirstPerson.cs

@@ -2,10 +2,14 @@
 *
 *   raylib [core] example - 3d camera first person
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
+*   Example complexity rating: [★★☆☆] 2/4
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Example originally created with raylib 1.3, last time updated with raylib 1.3
+*
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2015-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -14,171 +18,202 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class Camera3dFirstPerson
+public partial class Camera3dFirstPerson : IExample
 {
     public const int MaxColumns = 20;
 
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Camera 3D First Person";
+
+    public string Title => "raylib [core] example - 3d camera first person";
+
+    public bool CursorDisabled => true;
+
+    private Camera3D camera;
+    private CameraMode cameraMode;
+    private float[] heights;
+    private Vector3[] positions;
+    private Color[] colors;
+
+    public void Init()
+    {
+        // Define the camera to look into our 3d world (position, target, up vector)
+        camera = new();
+        camera.Position = new Vector3(0.0f, 2.0f, 4.0f);    // Camera position
+        camera.Target = new Vector3(0.0f, 2.0f, 0.0f);      // Camera looking at point
+        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);          // Camera up vector (rotation towards target)
+        camera.FovY = 60.0f;                                // Camera field-of-view Y
+        camera.Projection = CameraProjection.Perspective;   // Camera projection type
+
+        cameraMode = CameraMode.FirstPerson;
+
+        // Generates some random columns
+        heights = new float[MaxColumns];
+        positions = new Vector3[MaxColumns];
+        colors = new Color[MaxColumns];
+
+        for (var i = 0; i < MaxColumns; i++)
+        {
+            heights[i] = (float)GetRandomValue(1, 12);
+            positions[i] = new Vector3(GetRandomValue(-15, 15), heights[i] / 2.0f, GetRandomValue(-15, 15));
+            colors[i] = new Color(GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255);
+        }
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // Switch camera mode
+        if (IsKeyPressed(KeyboardKey.One))
+        {
+            cameraMode = CameraMode.Free;
+            camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+        }
+
+        if (IsKeyPressed(KeyboardKey.Two))
+        {
+            cameraMode = CameraMode.FirstPerson;
+            camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+        }
+
+        if (IsKeyPressed(KeyboardKey.Three))
+        {
+            cameraMode = CameraMode.ThirdPerson;
+            camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+        }
+
+        if (IsKeyPressed(KeyboardKey.Four))
+        {
+            cameraMode = CameraMode.Orbital;
+            camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+        }
+
+        // Switch camera projection
+        if (IsKeyPressed(KeyboardKey.P))
+        {
+            if (camera.Projection == CameraProjection.Perspective)
+            {
+                // Create isometric view
+                cameraMode = CameraMode.ThirdPerson;
+                // Note: The target distance is related to the render distance in the orthographic projection
+                camera.Position = new Vector3(0.0f, 2.0f, -100.0f);
+                camera.Target = new Vector3(0.0f, 2.0f, 0.0f);
+                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+                camera.Projection = CameraProjection.Orthographic;
+                camera.FovY = 20.0f; // near plane width in CAMERA_ORTHOGRAPHIC
+                // CameraYaw(&camera, -135 * DEG2RAD, true);
+                // CameraPitch(&camera, -45 * DEG2RAD, true, true, false);
+            }
+            else if (camera.Projection == CameraProjection.Orthographic)
+            {
+                // Reset to default view
+                cameraMode = CameraMode.ThirdPerson;
+                camera.Position = new Vector3(0.0f, 2.0f, 10.0f);
+                camera.Target = new Vector3(0.0f, 2.0f, 0.0f);
+                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
+                camera.Projection = CameraProjection.Perspective;
+                camera.FovY = 60.0f;
+            }
+        }
+
+        // Update camera computes movement internally depending on the camera mode
+        // Some default standard keyboard/mouse inputs are hardcoded to simplify use
+        // For advanced camera controls, it's recommended to compute camera movement manually
+        UpdateCamera(ref camera, cameraMode);                  // Update camera
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        BeginMode3D(camera);
+
+        // Draw ground
+        DrawPlane(new Vector3(0.0f, 0.0f, 0.0f), new Vector2(32.0f, 32.0f), Color.LightGray);
+
+        // Draw a blue wall
+        DrawCube(new Vector3(-16.0f, 2.5f, 0.0f), 1.0f, 5.0f, 32.0f, Color.Blue);
+
+        // Draw a green wall
+        DrawCube(new Vector3(16.0f, 2.5f, 0.0f), 1.0f, 5.0f, 32.0f, Color.Lime);
+
+        // Draw a yellow wall
+        DrawCube(new Vector3(0.0f, 2.5f, 16.0f), 32.0f, 5.0f, 1.0f, Color.Gold);
+
+        // Draw some cubes around
+        for (var i = 0; i < MaxColumns; i++)
+        {
+            DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
+            DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, Color.Maroon);
+        }
+
+        // Draw player cube
+        if (cameraMode == CameraMode.ThirdPerson)
+        {
+            DrawCube(camera.Target, 0.5f, 0.5f, 0.5f, Color.Purple);
+            DrawCubeWires(camera.Target, 0.5f, 0.5f, 0.5f, Color.DarkPurple);
+        }
+
+        EndMode3D();
+
+        // Draw info boxes
+        DrawRectangle(5, 5, 330, 100, Fade(Color.SkyBlue, 0.5f));
+        DrawRectangleLines(5, 5, 330, 100, Color.Blue);
+
+        DrawText("Camera controls:", 15, 15, 10, Color.Black);
+        DrawText("- Move keys: W, A, S, D, Space, Left-Ctrl", 15, 30, 10, Color.Black);
+        DrawText("- Look around: arrow keys or mouse", 15, 45, 10, Color.Black);
+        DrawText("- Camera mode keys: 1, 2, 3, 4", 15, 60, 10, Color.Black);
+        DrawText("- Zoom keys: num-plus, num-minus or mouse scroll", 15, 75, 10, Color.Black);
+        DrawText("- Camera projection key: P", 15, 90, 10, Color.Black);
+
+        DrawRectangle(600, 5, 195, 100, Fade(Color.SkyBlue, 0.5f));
+        DrawRectangleLines(600, 5, 195, 100, Color.Blue);
+
+        DrawText("Camera status:", 610, 15, 10, Color.Black);
+        DrawText($"- Mode: {cameraMode}", 610, 30, 10, Color.Black);
+        DrawText($"- Projection: {camera.Projection}", 610, 45, 10, Color.Black);
+        DrawText($"- Position: {camera.Position}", 610, 60, 10, Color.Black);
+        DrawText($"- Target: {camera.Target}", 610, 75, 10, Color.Black);
+        DrawText($"- Up: {camera.Up}", 610, 90, 10, Color.Black);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera first person");
 
-        // Define the camera to look into our 3d world (position, target, up vector)
+        DisableCursor();                    // Limit cursor to relative movement inside the window
-        Camera3D camera = new();
-        camera.Position = new Vector3(4.0f, 2.0f, 4.0f);
-        camera.Target = new Vector3(0.0f, 1.8f, 0.0f);
-        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-        camera.FovY = 60.0f;
-        camera.Projection = CameraProjection.Perspective;
 
-        // Generates some random columns
+        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
-        float[] heights = new float[MaxColumns];
-        Vector3[] positions = new Vector3[MaxColumns];
-        Color[] colors = new Color[MaxColumns];
-
-        for (int i = 0; i < MaxColumns; i++)
-        {
-            heights[i] = (float)GetRandomValue(1, 12);
-            positions[i] = new Vector3(GetRandomValue(-15, 15), heights[i] / 2, GetRandomValue(-15, 15));
-            colors[i] = new Color(GetRandomValue(20, 255), GetRandomValue(10, 55), 30, 255);
-        }
-
-        CameraMode cameraMode = CameraMode.FirstPerson;
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new Camera3dFirstPerson();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())        // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            // Switch camera mode
-            if (IsKeyPressed(KeyboardKey.One))
-            {
-                cameraMode = CameraMode.Free;
-                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-            }
-
-            if (IsKeyPressed(KeyboardKey.Two))
-            {
-                cameraMode = CameraMode.FirstPerson;
-                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-            }
-
-            if (IsKeyPressed(KeyboardKey.Three))
-            {
-                cameraMode = CameraMode.ThirdPerson;
-                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-            }
-
-            if (IsKeyPressed(KeyboardKey.Four))
-            {
-                cameraMode = CameraMode.Orbital;
-                camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-            }
-
-            // Switch camera projection
-            if (IsKeyPressed(KeyboardKey.P))
-            {
-                if (camera.Projection == CameraProjection.Perspective)
-                {
-                    // Create isometric view
-                    cameraMode = CameraMode.ThirdPerson;
-                    // Note: The target distance is related to the render distance in the orthographic projection
-                    camera.Position = new Vector3(0.0f, 2.0f, -100.0f);
-                    camera.Target = new Vector3(0.0f, 2.0f, 0.0f);
-                    camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-                    camera.Projection = CameraProjection.Orthographic;
-                    camera.FovY = 20.0f; // near plane width in CAMERA_ORTHOGRAPHIC
-                    // CameraYaw(&camera, -135 * DEG2RAD, true);
-                    // CameraPitch(&camera, -45 * DEG2RAD, true, true, false);
-                }
-                else if (camera.Projection == CameraProjection.Orthographic)
-                {
-                    // Reset to default view
-                    cameraMode = CameraMode.ThirdPerson;
-                    camera.Position = new Vector3(0.0f, 2.0f, 10.0f);
-                    camera.Target = new Vector3(0.0f, 2.0f, 0.0f);
-                    camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-                    camera.Projection = CameraProjection.Perspective;
-                    camera.FovY = 60.0f;
-                }
-            }
-
-            // Update camera computes movement internally depending on the camera mode
-            // Some default standard keyboard/mouse inputs are hardcoded to simplify use
-            // For advance camera controls, it's reecommended to compute camera movement manually
-            UpdateCamera(ref camera, cameraMode);
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            BeginMode3D(camera);
-
-            // Draw ground
-            DrawPlane(new Vector3(0.0f, 0.0f, 0.0f), new Vector2(32.0f, 32.0f), Color.LightGray);
-
-            // Draw a blue wall
-            DrawCube(new Vector3(-16.0f, 2.5f, 0.0f), 1.0f, 5.0f, 32.0f, Color.Blue);
-
-            // Draw a green wall
-            DrawCube(new Vector3(16.0f, 2.5f, 0.0f), 1.0f, 5.0f, 32.0f, Color.Lime);
-
-            // Draw a yellow wall
-            DrawCube(new Vector3(0.0f, 2.5f, 16.0f), 32.0f, 5.0f, 1.0f, Color.Gold);
-
-            // Draw some cubes around
-            for (int i = 0; i < MaxColumns; i++)
-            {
-                DrawCube(positions[i], 2.0f, heights[i], 2.0f, colors[i]);
-                DrawCubeWires(positions[i], 2.0f, heights[i], 2.0f, Color.Maroon);
-            }
-
-            // Draw player cube
-            if (cameraMode == CameraMode.ThirdPerson)
-            {
-                DrawCube(camera.Target, 0.5f, 0.5f, 0.5f, Color.Purple);
-                DrawCubeWires(camera.Target, 0.5f, 0.5f, 0.5f, Color.DarkPurple);
-            }
-
-            EndMode3D();
-
-            // Draw info boxes
-            DrawRectangle(5, 5, 330, 100, ColorAlpha(Color.SkyBlue, 0.5f));
-            DrawRectangleLines(10, 10, 330, 100, Color.Blue);
-
-            DrawText("Camera controls:", 15, 15, 10, Color.Black);
-            DrawText("- Move keys: W, A, S, D, Space, Left-Ctrl", 15, 30, 10, Color.Black);
-            DrawText("- Look around: arrow keys or mouse", 15, 45, 10, Color.Black);
-            DrawText("- Camera mode keys: 1, 2, 3, 4", 15, 60, 10, Color.Black);
-            DrawText("- Zoom keys: num-plus, num-minus or mouse scroll", 15, 75, 10, Color.Black);
-            DrawText("- Camera projection key: P", 15, 90, 10, Color.Black);
-
-            DrawRectangle(600, 5, 195, 100, Fade(Color.SkyBlue, 0.5f));
-            DrawRectangleLines(600, 5, 195, 100, Color.Blue);
-
-            DrawText("Camera status:", 610, 15, 10, Color.Black);
-            DrawText($"- Mode: {cameraMode}", 610, 30, 10, Color.Black);
-            DrawText($"- Projection: {camera.Projection}", 610, 45, 10, Color.Black);
-            DrawText($"- Position: {camera.Position}", 610, 60, 10, Color.Black);
-            DrawText($"- Target: {camera.Target}", 610, 75, 10, Color.Black);
-            DrawText($"- Up: {camera.Up}", 610, 90, 10, Color.Black);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/Camera3dFree.cs

@@ -1,11 +1,15 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Initialize 3d camera free
+*   raylib [core] example - 3d camera free
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
+*   Example complexity rating: [★☆☆☆] 1/4
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Example originally created with raylib 1.3, last time updated with raylib 1.3
+*
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2015-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -14,74 +18,100 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class Camera3dFree
+public partial class Camera3dFree : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Camera 3D Free";
+
+    public string Title => "raylib [core] example - 3d camera free";
+
+    public bool CursorDisabled => true;
+
+    private Camera3D camera;
+    private Vector3 cubePosition;
+
+    public void Init()
+    {
+        // Define the camera to look into our 3d world
+        camera = new();
+        camera.Position = new Vector3(10.0f, 10.0f, 10.0f); // Camera position
+        camera.Target = new Vector3(0.0f, 0.0f, 0.0f);      // Camera looking at point
+        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);          // Camera up vector (rotation towards target)
+        camera.FovY = 45.0f;                                // Camera field-of-view Y
+        camera.Projection = CameraProjection.Perspective;   // Camera projection type
+
+        cubePosition = new(0.0f, 0.0f, 0.0f);
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        UpdateCamera(ref camera, CameraMode.Free);
+
+        if (IsKeyPressed(KeyboardKey.Z))
+        {
+            camera.Target = new Vector3(0.0f, 0.0f, 0.0f);
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        BeginMode3D(camera);
+
+        DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, Color.Red);
+        DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, Color.Maroon);
+
+        DrawGrid(10, 1.0f);
+
+        EndMode3D();
+
+        DrawRectangle(10, 10, 320, 93, Fade(Color.SkyBlue, 0.5f));
+        DrawRectangleLines(10, 10, 320, 93, Color.Blue);
+
+        DrawText("Free camera default controls:", 20, 20, 10, Color.Black);
+        DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, Color.DarkGray);
+        DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, Color.DarkGray);
+        DrawText("- Z to zoom to (0, 0, 0)", 40, 80, 10, Color.DarkGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera free");
 
-        // Define the camera to look into our 3d world
+        DisableCursor();                    // Limit cursor to relative movement inside the window
-        Camera3D camera;
-        camera.Position = new Vector3(10.0f, 10.0f, 10.0f);
-        camera.Target = new Vector3(0.0f, 0.0f, 0.0f);
-        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-        camera.FovY = 45.0f;
-        camera.Projection = CameraProjection.Perspective;
 
-        Vector3 cubePosition = new(0.0f, 0.0f, 0.0f);
+        SetTargetFPS(60);                   // Set our game to run at 60 frames-per-second
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new Camera3dFree();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())        // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            UpdateCamera(ref camera, CameraMode.Free);
-
-            if (IsKeyDown(KeyboardKey.Z))
-            {
-                camera.Target = new Vector3(0.0f, 0.0f, 0.0f);
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            BeginMode3D(camera);
-
-            DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, Color.Red);
-            DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, Color.Maroon);
-
-            DrawGrid(10, 1.0f);
-
-            EndMode3D();
-
-            DrawRectangle(10, 10, 320, 133, ColorAlpha(Color.SkyBlue, 0.5f));
-            DrawRectangleLines(10, 10, 320, 133, Color.Blue);
-
-            DrawText("Free camera default controls:", 20, 20, 10, Color.Black);
-            DrawText("- Mouse Wheel to Zoom in-out", 40, 40, 10, Color.DarkGray);
-            DrawText("- Mouse Wheel Pressed to Pan", 40, 60, 10, Color.DarkGray);
-            DrawText("- Alt + Mouse Wheel Pressed to Rotate", 40, 80, 10, Color.DarkGray);
-            DrawText("- Alt + Ctrl + Mouse Wheel Pressed for Smooth Zoom", 40, 100, 10, Color.DarkGray);
-            DrawText("- Z to zoom to (0, 0, 0)", 40, 120, 10, Color.DarkGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/Camera3dMode.cs

@@ -1,11 +1,15 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Initialize 3d camera mode
+*   raylib [core] example - 3d camera mode
 *
-*   This example has been created using raylib 1.0 (www.raylib.com)
+*   Example complexity rating: [★☆☆☆] 1/4
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2014 Ramon Santamaria (@raysan5)
+*   Example originally created with raylib 1.0, last time updated with raylib 1.0
+*
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2014-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -14,63 +18,82 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class Camera3dMode
+public partial class Camera3dMode : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    private Camera3D camera;
+    private Vector3 cubePosition;
+
+    public string Name => "Core / Camera 3D Mode";
+
+    public string Title => "raylib [core] example - 3d camera mode";
+
+    public void Init()
+    {
+        // Define the camera to look into our 3d world
+        camera = new();
+        camera.Position = new Vector3(0.0f, 10.0f, 10.0f);  // Camera position
+        camera.Target = new Vector3(0.0f, 0.0f, 0.0f);      // Camera looking at point
+        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);          // Camera up vector (rotation towards target)
+        camera.FovY = 45.0f;                                // Camera field-of-view Y
+        camera.Projection = CameraProjection.Perspective;   // Camera mode type
+
+        cubePosition = new(0.0f, 0.0f, 0.0f);
+    }
+
+    public void Update()
+    {
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        BeginMode3D(camera);
+
+        DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, Color.Red);
+        DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, Color.Maroon);
+
+        DrawGrid(10, 1.0f);
+
+        EndMode3D();
+
+        DrawText("Welcome to the third dimension!", 10, 40, 20, Color.DarkGray);
+
+        DrawFPS(10, 10);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - 3d camera mode");
 
-        // Define the camera to look into our 3d world
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        Camera3D camera = new();
-        camera.Position = new Vector3(0.0f, 10.0f, 10.0f);
-        camera.Target = new Vector3(0.0f, 0.0f, 0.0f);
-        camera.Up = new Vector3(0.0f, 1.0f, 0.0f);
-        camera.FovY = 45.0f;
-        camera.Projection = CameraProjection.Perspective;
-
-        Vector3 cubePosition = new(0.0f, 0.0f, 0.0f);
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new Camera3dMode();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            // TODO: Update your variables here
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            BeginMode3D(camera);
-
-            DrawCube(cubePosition, 2.0f, 2.0f, 2.0f, Color.Red);
-            DrawCubeWires(cubePosition, 2.0f, 2.0f, 2.0f, Color.Maroon);
-
-            DrawGrid(10, 1.0f);
-
-            EndMode3D();
-
-            DrawText("Welcome to the third dimension!", 10, 40, 20, Color.DarkGray);
-
-            DrawFPS(10, 10);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/Customlogging.cs

@@ -1,13 +1,17 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Custom logging
+*   raylib [core] example - custom logging
 *
-*   This example has been created using raylib 2.1 (www.raylib.com)
+*   Example complexity rating: [★★★☆] 3/4
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
+*
+*   Example originally created with raylib 2.5, last time updated with raylib 2.5
 *
 *   Example contributed by Pablo Marcos Oltra (@pamarcos) and reviewed by Ramon Santamaria (@raysan5)
 *
-*   Copyright (c) 2018 Pablo Marcos Oltra (@pamarcos) and Ramon Santamaria (@raysan5)
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2018-2025 Pablo Marcos Oltra (@pamarcos) and Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
@@ -17,11 +21,23 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public unsafe class CustomLogging
+public unsafe partial class CustomLogging : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Custom Logging";
+
+    public string Title => "raylib [core] example - custom logging";
+
     [UnmanagedCallersOnly(CallConvs = new[] { typeof(System.Runtime.CompilerServices.CallConvCdecl) })]
     private static void LogCustom(int logLevel, sbyte* text, sbyte* args)
     {
+#if BROWSER
+        // WebAssembly can't invoke the C varargs vsprintf/vsnprintf that Logging.GetLogMessage relies on
+        // (the wasm runtime traps with "function signature mismatch"), so log the raw, unformatted text.
+        string message = Marshal.PtrToStringUTF8(new IntPtr(text)) ?? string.Empty;
+#else
         var message = Logging.GetLogMessage(new IntPtr(text), new IntPtr(args));
 
         /*Console.ForegroundColor = (TraceLogLevel)logLevel switch
@@ -36,50 +52,64 @@ public unsafe class CustomLogging
             TraceLogLevel.LOG_NONE => ConsoleColor.White,
             _ => throw new ArgumentOutOfRangeException(nameof(logLevel), logLevel, null)
         };*/
+#endif
 
         Console.WriteLine($"Custom " + message);
         // Console.ResetColor();
     }
 
+    public void Init()
+    {
+        // First thing we do is setting our custom logger to ensure everything raylib logs
+        // will use our own logger instead of its internal one
+        SetTraceLogCallback(&LogCustom);
+    }
+
+    public void Update()
+    {
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, Color.LightGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+#if !BROWSER
+        // Restore the default formatting logger on desktop. On WebAssembly we leave the (wasm-safe)
+        // custom logger in place — Logging.LogConsole formats via vsprintf, which traps on wasm.
+        SetTraceLogCallback(&Logging.LogConsole);
+#endif
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
-        // First thing we do is setting our custom logger to ensure everything raylib logs
-        // will use our own logger instead of its internal one
-        SetTraceLogCallback(&LogCustom);
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - custom logging");
 
-        SetTargetFPS(60);
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
         //--------------------------------------------------------------------------------------
 
+        var game = new CustomLogging();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            // TODO: Update your variables here
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawText("Check out the console output to see the custom logger in action!", 60, 200, 20, Color.LightGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
-        SetTraceLogCallback(&Logging.LogConsole);
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/DeltaTime.cs

@@ -21,108 +21,137 @@ namespace Examples.Core;
 
 using static Raylib_cs.Raylib;
 
-public class DeltaTime
+public partial class DeltaTime : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    // The speed applied to both circles
+    private const float speed = 10.0f;
+    private const float circleRadius = 32.0f;
+
+    private int currentFps;
+
+    // Store the position for the both of the circles
+    private Vector2 deltaCircle;
+    private Vector2 frameCircle;
+
+    public string Name => "Core / Delta Time";
+
+    public string Title => "raylib [core] example - delta time";
+
+    public void Init()
+    {
+        currentFps = 60;
+
+        // Store the position for the both of the circles
+        deltaCircle = new Vector2(0, (float)screenHeight / 3.0f);
+        frameCircle = new Vector2(0, (float)screenHeight * (2.0f / 3.0f));
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        // Adjust the FPS target based on the mouse wheel
+        var mouseWheel = GetMouseWheelMove();
+        if (mouseWheel != 0)
+        {
+            currentFps += (int)mouseWheel;
+            if (currentFps < 0)
+            {
+                currentFps = 0;
+            }
+            SetTargetFPS(currentFps);
+        }
+
+        // GetFrameTime() returns the time it took to draw the last frame, in seconds (usually called delta time)
+        // Uses the delta time to make the circle look like it's moving at a "consistent" speed regardless of FPS
+
+        // Multiply by 6.0 (an arbitrary value) in order to make the speed
+        // visually closer to the other circle (at 60 fps), for comparison
+        deltaCircle.X += GetFrameTime() * 6.0f * speed;
+        // This circle can move faster or slower visually depending on the FPS
+        frameCircle.X += 0.1f * speed;
+
+        // If either circle is off the screen, reset it back to the start
+        if (deltaCircle.X > screenWidth)
+        {
+            deltaCircle.X = 0;
+        }
+
+        if (frameCircle.X > screenWidth)
+        {
+            frameCircle.X = 0;
+        }
+
+        // Reset both circles positions
+        if (IsKeyPressed(KeyboardKey.R))
+        {
+            deltaCircle.X = 0;
+            frameCircle.X = 0;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        // Draw both circles to the screen
+        DrawCircleV(deltaCircle, circleRadius, Color.Red);
+        DrawCircleV(frameCircle, circleRadius, Color.Blue);
+
+        // Draw the help text
+        // Determine what help text to show depending on the current FPS target
+        var fpsText = "";
+        if (currentFps <= 0)
+        {
+            fpsText = $"FPS: unlimited ({GetFPS()})";
+        }
+        else
+        {
+            fpsText = $"FPS: {GetFPS()} (target: {currentFps})";
+        }
+        DrawText(fpsText, 10, 10, 20, Color.DarkGray);
+        DrawText($"Frame time: {GetFrameTime():F2} ms", 10, 30, 20, Color.DarkGray);
+        DrawText("Use the scroll wheel to change the fps limit, r to reset", 10, 50, 20, Color.DarkGray);
+
+        // Draw the text above the circles
+        DrawText("FUNC: x += GetFrameTime()*speed", 10, 90, 20, Color.Red);
+        DrawText("FUNC: x += speed", 10, 240, 20, Color.Blue);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - delta time");
 
-        int currentFps = 60;
-
-        Vector2 deltaCircle = new Vector2(0, (float)screenHeight / 3.0f);
-        Vector2 frameCircle = new Vector2(0, (float)screenHeight * (2.0f / 3.0f));
-
         SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
-        const float speed = 10.0f;
+        var game = new DeltaTime();
-        const float circleRadius = 32.0f;
+        game.Init();
 
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose()) // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            // Adjust the FPS target based on the mouse wheel
-            float mouseWheel = GetMouseWheelMove();
-            if (mouseWheel != 0)
-            {
-                currentFps += (int)mouseWheel;
-                if (currentFps < 0)
-                {
-                    currentFps = 0;
-                }
-                SetTargetFPS(currentFps);
-            }
-
-            // GetFrameTime() returns the time it took to draw the last frame, in seconds (usually called delta time)
-            // Uses the delta time to make the circle look like it's moving at a "consistent" speed regardless of FPS
-
-            // Multiply by 6.0 (an arbitrary value) in order to make the speed
-            // visually closer to the other circle (at 60 fps), for comparison
-            deltaCircle.X += GetFrameTime() * 6.0f * speed;
-            // This circle can move faster or slower visually depending on the FPS
-            frameCircle.X += 0.1f * speed;
-
-            // If either circle is off the screen, reset it back to the start
-            if (deltaCircle.X > screenWidth)
-            {
-                deltaCircle.X = 0;
-            }
-
-            if (frameCircle.X > screenWidth)
-            {
-                frameCircle.X = 0;
-            }
-
-            // Reset both circles positions
-            if (IsKeyPressed(KeyboardKey.R))
-            {
-                deltaCircle.X = 0;
-                frameCircle.X = 0;
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            // Draw both circles to the screen
-            DrawCircleV(deltaCircle, circleRadius, Color.Red);
-            DrawCircleV(frameCircle, circleRadius, Color.Blue);
-
-            // Draw the help text
-            // Determine what help text to show depending on the current FPS target
-            var fpsText = "";
-            if (currentFps <= 0)
-            {
-                fpsText = $"FPS: unlimited ({GetFPS()})";
-            }
-            else
-            {
-                fpsText = $"FPS: {GetFPS()} (target: {currentFps})";
-            }
-            DrawText(fpsText, 10, 10, 20, Color.DarkGray);
-            DrawText($"Frame time: {GetFrameTime():F2} ms", 10, 30, 20, Color.DarkGray);
-            DrawText("Use the scroll wheel to change the fps limit, r to reset", 10, 50, 20, Color.DarkGray);
-
-            // Draw the text above the circles
-            DrawText("FUNC: x += GetFrameTime()*speed", 10, 90, 20, Color.Red);
-            DrawText("FUNC: x += speed", 10, 240, 20, Color.Blue);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/DropFiles.cs

@@ -1,83 +1,124 @@
 /*******************************************************************************************
 *
-*   raylib [core] example - Windows drop files
+*   raylib [core] example - drop files
 *
-*   This example only works on platforms that support drag ref drop (Windows, Linux, OSX, Html5?)
+*   Example complexity rating: [★★☆☆] 2/4
 *
-*   This example has been created using raylib 1.3 (www.raylib.com)
+*   NOTE: This example only works on platforms that support drag & drop (Windows, Linux, OSX, Html5?)
-*   raylib is licensed under an unmodified zlib/libpng license (View raylib.h for details)
 *
-*   Copyright (c) 2015 Ramon Santamaria (@raysan5)
+*   Example originally created with raylib 1.3, last time updated with raylib 4.2
+*
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   BSD-like license that allows static linking with closed source software
+*
+*   Copyright (c) 2015-2025 Ramon Santamaria (@raysan5)
 *
 ********************************************************************************************/
 
+using System.Collections.Generic;
 using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class DropFiles
+public partial class DropFiles : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public const int MaxFilepathRecorded = 4096;
+
+    public string Name => "Core / Drop Files";
+
+    public string Title => "raylib [core] example - drop files";
+
+    private List<string> filePaths;
+
+    public void Init()
+    {
+        // We will register a maximum of filepaths
+        filePaths = new();
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsFileDropped())
+        {
+            var droppedFiles = GetDroppedFiles();
+
+            for (var i = 0; i < droppedFiles.Length; i++)
+            {
+                if (filePaths.Count < (MaxFilepathRecorded - 1))
+                {
+                    filePaths.Add(droppedFiles[i]);
+                }
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+
+        ClearBackground(Color.RayWhite);
+
+        if (filePaths.Count == 0)
+        {
+            DrawText("Drop your files to this window!", 100, 40, 20, Color.DarkGray);
+        }
+        else
+        {
+            DrawText("Dropped files:", 100, 40, 20, Color.DarkGray);
+
+            for (var i = 0; i < filePaths.Count; i++)
+            {
+                if (i % 2 == 0)
+                {
+                    DrawRectangle(0, 85 + 40 * i, screenWidth, 40, Fade(Color.LightGray, 0.5f));
+                }
+                else
+                {
+                    DrawRectangle(0, 85 + 40 * i, screenWidth, 40, Fade(Color.LightGray, 0.3f));
+                }
+
+                DrawText(filePaths[i], 120, 100 + 40 * i, 10, Color.Gray);
+            }
+
+            DrawText("Drop new files...", 100, 110 + 40 * filePaths.Count, 20, Color.DarkGray);
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - drop files");
 
-        string[] files = new string[0];
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new DropFiles();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            if (IsFileDropped())
-            {
-                files = Raylib.GetDroppedFiles();
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            if (files.Length == 0)
-            {
-                DrawText("Drop your files to this window!", 100, 40, 20, Color.DarkGray);
-            }
-            else
-            {
-                DrawText("Dropped files:", 100, 40, 20, Color.DarkGray);
-
-                for (int i = 0; i < files.Length; i++)
-                {
-                    if (i % 2 == 0)
-                    {
-                        DrawRectangle(0, 85 + 40 * i, screenWidth, 40, ColorAlpha(Color.LightGray, 0.5f));
-                    }
-                    else
-                    {
-                        DrawRectangle(0, 85 + 40 * i, screenWidth, 40, ColorAlpha(Color.LightGray, 0.3f));
-                    }
-                    DrawText(files[i], 120, 100 + 40 * i, 10, Color.Gray);
-                }
-
-                DrawText("Drop new files...", 100, 110 + 40 * files.Length, 20, Color.DarkGray);
-            }
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();          // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/InputGamepad.cs

@@ -1,32 +1,34 @@
 /*******************************************************************************************
-   *
+*
-   *   raylib [core] example - input gamepad
+*   raylib [core] example - input gamepad
-   *
+*
-   *   Example complexity rating: [★☆☆☆] 1/4
+*   Example complexity rating: [★☆☆☆] 1/4
-   *
+*
-   *   NOTE: This example requires a Gamepad connected to the system
+*   NOTE: This example requires a Gamepad connected to the system
-   *         raylib is configured to work with the following gamepads:
+*         raylib is configured to work with the following gamepads:
-   *                - Xbox 360 Controller (Xbox 360, Xbox One)
+*                - Xbox 360 Controller (Xbox 360, Xbox One)
-   *                - PLAYSTATION(R)3 Controller
+*                - PLAYSTATION(R)3 Controller
-   *         Check raylib.h for buttons configuration
+*         Check raylib.h for buttons configuration
-   *
+*
-   *   Example originally created with raylib 1.1, last time updated with raylib 4.2
+*   Example originally created with raylib 1.1, last time updated with raylib 4.2
-   *
+*
-   *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
-   *   BSD-like license that allows static linking with closed source software
+*   BSD-like license that allows static linking with closed source software
-   *
+*
-   *   Copyright (c) 2013-2025 Ramon Santamaria (@raysan5)
+*   Copyright (c) 2013-2025 Ramon Santamaria (@raysan5)
-   *
+*
-   ********************************************************************************************/
+********************************************************************************************/
-
 
 using System.Numerics;
 using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class InputGamepad
+public partial class InputGamepad : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
     // NOTE: Gamepad name ID depends on drivers and OS
     // These are some possible names the gamepads could have.
     public const string XBOX_ALIAS_1 = "xbox";
@@ -34,320 +36,503 @@ public class InputGamepad
     public const string PS_ALIAS_1 = "playstation";
     public const string PS_ALIAS_2 = "sony";
 
+    // Set axis deadzones
+    private const float leftStickDeadzoneX = 0.1f;
+    private const float leftStickDeadzoneY = 0.1f;
+    private const float rightStickDeadzoneX = 0.1f;
+    private const float rightStickDeadzoneY = 0.1f;
+    private const float leftTriggerDeadzone = -0.9f;
+    private const float rightTriggerDeadzone = -0.9f;
+
+    private Texture2D texPs3Pad;
+    private Texture2D texXboxPad;
+
+    private Rectangle vibrateButton;
+
+    private int gamepad; // which gamepad to display
+
+    public string Name => "Core / Input Gamepad";
+
+    public string Title => "raylib [core] example - input gamepad";
+
+    public ConfigFlags ConfigFlags => ConfigFlags.Msaa4xHint;
+
+    public void Init()
+    {
+        texPs3Pad = LoadTexture("resources/ps3.png");
+        texXboxPad = LoadTexture("resources/xbox.png");
+
+        vibrateButton = new Rectangle();
+
+        gamepad = 0; // which gamepad to display
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KeyboardKey.Left) && gamepad > 0)
+        {
+            gamepad--;
+        }
+
+        if (IsKeyPressed(KeyboardKey.Right))
+        {
+            gamepad++;
+        }
+
+        var mousePosition = GetMousePosition();
+
+        vibrateButton = new Rectangle(10, 70.0f + 20 * GetGamepadAxisCount(gamepad) + 20, 75, 24);
+        if (IsMouseButtonPressed(MouseButton.Left) && CheckCollisionPointRec(mousePosition, vibrateButton))
+        {
+            SetGamepadVibration(gamepad, 1.0f, 1.0f, 1.0f);
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        if (IsGamepadAvailable(gamepad))
+        {
+            var gamepadName = GetGamepadName_(gamepad);
+            DrawText($"GP{gamepad}: {gamepadName}", 10, 10, 10, Color.Black);
+
+            // Get axis values
+            var leftStickX = GetGamepadAxisMovement(gamepad, GamepadAxis.LeftX);
+            var leftStickY = GetGamepadAxisMovement(gamepad, GamepadAxis.LeftY);
+            var rightStickX = GetGamepadAxisMovement(gamepad, GamepadAxis.RightX);
+            var rightStickY = GetGamepadAxisMovement(gamepad, GamepadAxis.RightY);
+            var leftTrigger = GetGamepadAxisMovement(gamepad, GamepadAxis.LeftTrigger);
+            var rightTrigger = GetGamepadAxisMovement(gamepad, GamepadAxis.RightTrigger);
+
+            // Calculate deadzones
+            if (leftStickX > -leftStickDeadzoneX && leftStickX < leftStickDeadzoneX)
+            {
+                leftStickX = 0.0f;
+            }
+
+            if (leftStickY > -leftStickDeadzoneY && leftStickY < leftStickDeadzoneY)
+            {
+                leftStickY = 0.0f;
+            }
+
+            if (rightStickX > -rightStickDeadzoneX && rightStickX < rightStickDeadzoneX)
+            {
+                rightStickX = 0.0f;
+            }
+
+            if (rightStickY > -rightStickDeadzoneY && rightStickY < rightStickDeadzoneY)
+            {
+                rightStickY = 0.0f;
+            }
+
+            if (leftTrigger < leftTriggerDeadzone)
+            {
+                leftTrigger = -1.0f;
+            }
+
+            if (rightTrigger < rightTriggerDeadzone)
+            {
+                rightTrigger = -1.0f;
+            }
+
+            if (gamepadName.Contains(XBOX_ALIAS_1, StringComparison.OrdinalIgnoreCase) ||
+                gamepadName.Contains(XBOX_ALIAS_2, StringComparison.OrdinalIgnoreCase))
+            {
+                DrawTexture(texXboxPad, 0, 0, Color.DarkGray);
+
+                // Draw buttons: xbox home
+                if (IsGamepadButtonDown(gamepad, GamepadButton.Middle))
+                {
+                    DrawCircle(394, 89, 19, Color.Red);
+                }
+
+                // Draw buttons: basic
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleRight))
+                {
+                    DrawCircle(436, 150, 9, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleLeft))
+                {
+                    DrawCircle(352, 150, 9, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceLeft))
+                {
+                    DrawCircle(501, 151, 15, Color.Blue);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceDown))
+                {
+                    DrawCircle(536, 187, 15, Color.Lime);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceRight))
+                {
+                    DrawCircle(572, 151, 15, Color.Maroon);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceUp))
+                {
+                    DrawCircle(536, 115, 15, Color.Gold);
+                }
+
+                // Draw buttons: d-pad
+                DrawRectangle(317, 202, 19, 71, Color.Black);
+                DrawRectangle(293, 228, 69, 19, Color.Black);
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceUp))
+                {
+                    DrawRectangle(317, 202, 19, 26, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceDown))
+                {
+                    DrawRectangle(317, 202 + 45, 19, 26, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceLeft))
+                {
+                    DrawRectangle(292, 228, 25, 19, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceRight))
+                {
+                    DrawRectangle(292 + 44, 228, 26, 19, Color.Red);
+                }
+
+                // Draw buttons: left-right back
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftTrigger1))
+                {
+                    DrawCircle(259, 61, 20, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightTrigger1))
+                {
+                    DrawCircle(536, 61, 20, Color.Red);
+                }
+
+                // Draw axis: left joystick
+                var leftGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftThumb))
+                {
+                    leftGamepadColor = Color.Red;
+                }
+
+                DrawCircle(259, 152, 39, Color.Black);
+                DrawCircle(259, 152, 34, Color.LightGray);
+                DrawCircle(259 + (int)(leftStickX * 20), 152 + (int)(leftStickY * 20), 25, leftGamepadColor);
+
+                // Draw axis: right joystick
+                var rightGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightThumb))
+                {
+                    rightGamepadColor = Color.Red;
+                }
+
+                DrawCircle(461, 237, 38, Color.Black);
+                DrawCircle(461, 237, 33, Color.LightGray);
+                DrawCircle(461 + (int)(rightStickX * 20), 237 + (int)(rightStickY * 20), 25, rightGamepadColor);
+
+                // Draw axis: left-right triggers
+                DrawRectangle(170, 30, 15, 70, Color.Gray);
+                DrawRectangle(604, 30, 15, 70, Color.Gray);
+                DrawRectangle(170, 30, 15, (int)(((1 + leftTrigger) / 2) * 70), Color.Red);
+                DrawRectangle(604, 30, 15, (int)(((1 + rightTrigger) / 2) * 70), Color.Red);
+            }
+            else if (gamepadName.Contains(PS_ALIAS_1, StringComparison.OrdinalIgnoreCase) || gamepadName.Contains(PS_ALIAS_2, StringComparison.OrdinalIgnoreCase))
+            {
+                DrawTexture(texPs3Pad, 0, 0, Color.DarkGray);
+
+                // Draw buttons: ps
+                if (IsGamepadButtonDown(gamepad, GamepadButton.Middle))
+                {
+                    DrawCircle(396, 222, 13, Color.Red);
+                }
+
+                // Draw buttons: basic
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleLeft))
+                {
+                    DrawRectangle(328, 170, 32, 13, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleRight))
+                {
+                    DrawTriangle(
+                        new Vector2(436, 168),
+                        new Vector2(436, 185),
+                        new Vector2(464, 177),
+                        Color.Red
+                    );
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceUp))
+                {
+                    DrawCircle(557, 144, 13, Color.Lime);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceRight))
+                {
+                    DrawCircle(586, 173, 13, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceDown))
+                {
+                    DrawCircle(557, 203, 13, Color.Violet);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceLeft))
+                {
+                    DrawCircle(527, 173, 13, Color.Pink);
+                }
+
+                // Draw buttons: d-pad
+                DrawRectangle(225, 132, 24, 84, Color.Black);
+                DrawRectangle(195, 161, 84, 25, Color.Black);
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceUp))
+                {
+                    DrawRectangle(225, 132, 24, 29, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceDown))
+                {
+                    DrawRectangle(225, 132 + 54, 24, 30, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceLeft))
+                {
+                    DrawRectangle(195, 161, 30, 25, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceRight))
+                {
+                    DrawRectangle(195 + 54, 161, 30, 25, Color.Red);
+                }
+
+                // Draw buttons: left-right back buttons
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftTrigger1))
+                {
+                    DrawCircle(239, 82, 20, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightTrigger1))
+                {
+                    DrawCircle(557, 82, 20, Color.Red);
+                }
+
+                // Draw axis: left joystick
+                var leftGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftThumb))
+                {
+                    leftGamepadColor = Color.Red;
+                }
+
+                DrawCircle(319, 255, 35, Color.Black);
+                DrawCircle(319, 255, 31, Color.LightGray);
+                DrawCircle(319 + (int)(leftStickX * 20), 255 + (int)(leftStickY * 20), 25, leftGamepadColor);
+
+                // Draw axis: right joystick
+                var rightGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightThumb))
+                {
+                    rightGamepadColor = Color.Red;
+                }
+
+                DrawCircle(475, 255, 35, Color.Black);
+                DrawCircle(475, 255, 31, Color.LightGray);
+                DrawCircle(475 + (int)(rightStickX * 20), 255 + (int)(rightStickY * 20), 25, rightGamepadColor);
+
+                // Draw axis: left-right triggers
+                DrawRectangle(169, 48, 15, 70, Color.Gray);
+                DrawRectangle(611, 48, 15, 70, Color.Gray);
+                DrawRectangle(169, 48, 15, (int)(((1 + leftTrigger) / 2) * 70), Color.Red);
+                DrawRectangle(611, 48, 15, (int)(((1 + rightTrigger) / 2) * 70), Color.Red);
+            }
+            else
+            {
+                // Draw background: generic
+                DrawRectangleRounded(new Rectangle(175, 110, 460, 220), 0.3f, 16, Color.DarkGray);
+
+                // Draw buttons: basic
+                DrawCircle(365, 170, 12, Color.RayWhite);
+                DrawCircle(405, 170, 12, Color.RayWhite);
+                DrawCircle(445, 170, 12, Color.RayWhite);
+                DrawCircle(516, 191, 17, Color.RayWhite);
+                DrawCircle(551, 227, 17, Color.RayWhite);
+                DrawCircle(587, 191, 17, Color.RayWhite);
+                DrawCircle(551, 155, 17, Color.RayWhite);
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleLeft))
+                {
+                    DrawCircle(365, 170, 10, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.Middle))
+                {
+                    DrawCircle(405, 170, 10, Color.Green);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleRight))
+                {
+                    DrawCircle(445, 170, 10, Color.Blue);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceLeft))
+                {
+                    DrawCircle(516, 191, 15, Color.Gold);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceDown))
+                {
+                    DrawCircle(551, 227, 15, Color.Blue);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceRight))
+                {
+                    DrawCircle(587, 191, 15, Color.Green);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceUp))
+                {
+                    DrawCircle(551, 155, 15, Color.Red);
+                }
+
+                // Draw buttons: d-pad
+                DrawRectangle(245, 145, 28, 88, Color.RayWhite);
+                DrawRectangle(215, 174, 88, 29, Color.RayWhite);
+                DrawRectangle(247, 147, 24, 84, Color.Black);
+                DrawRectangle(217, 176, 84, 25, Color.Black);
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceUp))
+                {
+                    DrawRectangle(247, 147, 24, 29, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceDown))
+                {
+                    DrawRectangle(247, 147 + 54, 24, 30, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceLeft))
+                {
+                    DrawRectangle(217, 176, 30, 25, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceRight))
+                {
+                    DrawRectangle(217 + 54, 176, 30, 25, Color.Red);
+                }
+
+                // Draw buttons: left-right back
+                DrawRectangleRounded(new Rectangle(215, 98, 100, 10), 0.5f, 16, Color.DarkGray);
+                DrawRectangleRounded(new Rectangle(495, 98, 100, 10), 0.5f, 16, Color.DarkGray);
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftTrigger1))
+                {
+                    DrawRectangleRounded(new Rectangle(215, 98, 100, 10), 0.5f, 16, Color.Red);
+                }
+
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightTrigger1))
+                {
+                    DrawRectangleRounded(new Rectangle(495, 98, 100, 10), 0.5f, 16, Color.Red);
+                }
+
+                // Draw axis: left joystick
+                var leftGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.LeftThumb))
+                {
+                    leftGamepadColor = Color.Red;
+                }
+
+                DrawCircle(345, 260, 40, Color.Black);
+                DrawCircle(345, 260, 35, Color.LightGray);
+                DrawCircle(345 + (int)(leftStickX * 20), 260 + (int)(leftStickY * 20), 25, leftGamepadColor);
+
+                // Draw axis: right joystick
+                var rightGamepadColor = Color.Black;
+                if (IsGamepadButtonDown(gamepad, GamepadButton.RightThumb))
+                {
+                    rightGamepadColor = Color.Red;
+                }
+
+                DrawCircle(465, 260, 40, Color.Black);
+                DrawCircle(465, 260, 35, Color.LightGray);
+                DrawCircle(465 + (int)(rightStickX * 20), 260 + (int)(rightStickY * 20), 25, rightGamepadColor);
+
+                // Draw axis: left-right triggers
+                DrawRectangle(151, 110, 15, 70, Color.Gray);
+                DrawRectangle(644, 110, 15, 70, Color.Gray);
+                DrawRectangle(151, 110, 15, (int)(((1 + leftTrigger) / 2) * 70), Color.Red);
+                DrawRectangle(644, 110, 15, (int)(((1 + rightTrigger) / 2) * 70), Color.Red);
+            }
+
+            DrawText($"DETECTED AXIS [{GetGamepadAxisCount(gamepad)}]:", 10, 50, 10, Color.Maroon);
+
+            for (var i = 0; i < GetGamepadAxisCount(gamepad); i++)
+            {
+                DrawText(
+                    $"AXIS {i}: {GetGamepadAxisMovement(gamepad, (GamepadAxis)i):F2}",
+                    20,
+                    70 + 20 * i,
+                    10,
+                    Color.DarkGray
+                );
+            }
+
+            // Draw vibrate button
+            DrawRectangleRec(vibrateButton, Color.SkyBlue);
+            DrawText("VIBRATE", (int)(vibrateButton.X + 14), (int)(vibrateButton.Y + 1), 10, Color.DarkGray);
+
+            if (GetGamepadButtonPressed() != (int)GamepadButton.Unknown)
+            {
+                DrawText($"DETECTED BUTTON: {GetGamepadButtonPressed()}", 10, 430, 10, Color.Red);
+            }
+            else
+            {
+                DrawText("DETECTED BUTTON: NONE", 10, 430, 10, Color.Gray);
+            }
+        }
+        else
+        {
+            DrawText($"GP{gamepad}: NOT DETECTED", 10, 10, 10, Color.Gray);
+            DrawTexture(texXboxPad, 0, 0, Color.LightGray);
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+        UnloadTexture(texPs3Pad);
+        UnloadTexture(texXboxPad);
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
+        SetConfigFlags(ConfigFlags.Msaa4xHint);  // Set MSAA 4X hint before windows creation
-        const int screenHeight = 450;
 
-        // Set MSAA 4X hint before windows creation
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - input gamepad");
-        SetConfigFlags(ConfigFlags.Msaa4xHint);
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - gamepad input");
 
-        Texture2D texPs3Pad = LoadTexture("resources/ps3.png");
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        Texture2D texXboxPad = LoadTexture("resources/xbox.png");
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
-        int gamepad = 0;
+        var game = new InputGamepad();
-        Rectangle vibrateButton = new Rectangle();
+        game.Init();
 
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            if (IsKeyPressed(KeyboardKey.Left) && gamepad > 0)
-            {
-                gamepad--;
-            }
-
-            if (IsKeyPressed(KeyboardKey.Right))
-            {
-                gamepad++;
-            }
-
-            Vector2 mousePosition = GetMousePosition();
-
-            vibrateButton = new Rectangle(10, 70.0f + 20 * GetGamepadAxisCount(gamepad) + 20, 75, 24);
-            if (IsMouseButtonPressed(MouseButton.Left) && CheckCollisionPointRec(mousePosition, vibrateButton))
-            {
-                SetGamepadVibration(gamepad, 1.0f, 1.0f, 1.0f);
-            }
-
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            if (IsGamepadAvailable(gamepad))
-            {
-                string gamepadName = GetGamepadName_(gamepad);
-                DrawText($"GP{gamepad}: {gamepadName}", 10, 10, 10, Color.Black);
-
-                if (gamepadName.Contains(XBOX_ALIAS_1, StringComparison.OrdinalIgnoreCase) ||
-                    gamepadName.Contains(XBOX_ALIAS_2, StringComparison.OrdinalIgnoreCase))
-                {
-                    DrawTexture(texXboxPad, 0, 0, Color.DarkGray);
-
-                    // Draw buttons: xbox home
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.Middle))
-                    {
-                        DrawCircle(394, 89, 19, Color.Red);
-                    }
-
-                    // Draw buttons: basic
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleRight))
-                    {
-                        DrawCircle(436, 150, 9, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleLeft))
-                    {
-                        DrawCircle(352, 150, 9, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceLeft))
-                    {
-                        DrawCircle(501, 151, 15, Color.Blue);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceDown))
-                    {
-                        DrawCircle(536, 187, 15, Color.Lime);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceRight))
-                    {
-                        DrawCircle(572, 151, 15, Color.Maroon);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceUp))
-                    {
-                        DrawCircle(536, 115, 15, Color.Gold);
-                    }
-
-                    // Draw buttons: d-pad
-                    DrawRectangle(317, 202, 19, 71, Color.Black);
-                    DrawRectangle(293, 228, 69, 19, Color.Black);
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceUp))
-                    {
-                        DrawRectangle(317, 202, 19, 26, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceDown))
-                    {
-                        DrawRectangle(317, 202 + 45, 19, 26, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceLeft))
-                    {
-                        DrawRectangle(292, 228, 25, 19, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceRight))
-                    {
-                        DrawRectangle(292 + 44, 228, 26, 19, Color.Red);
-                    }
-
-                    // Draw buttons: left-right back
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftTrigger1))
-                    {
-                        DrawCircle(259, 61, 20, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightTrigger1))
-                    {
-                        DrawCircle(536, 61, 20, Color.Red);
-                    }
-
-                    // Draw axis: left joystick
-                    DrawCircle(259, 152, 39, Color.Black);
-                    DrawCircle(259, 152, 34, Color.LightGray);
-                    DrawCircle(
-                        259 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.LeftX) * 20),
-                        152 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.LeftY) * 20),
-                        25,
-                        Color.Black
-                    );
-
-                    // Draw axis: right joystick
-                    DrawCircle(461, 237, 38, Color.Black);
-                    DrawCircle(461, 237, 33, Color.LightGray);
-                    DrawCircle(
-                        461 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.RightX) * 20),
-                        237 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.RightY) * 20),
-                        25, Color.Black
-                    );
-
-                    // Draw axis: left-right triggers
-                    float leftTriggerX = GetGamepadAxisMovement(gamepad, GamepadAxis.LeftTrigger);
-                    float rightTriggerX = GetGamepadAxisMovement(gamepad, GamepadAxis.RightTrigger);
-                    DrawRectangle(170, 30, 15, 70, Color.Gray);
-                    DrawRectangle(604, 30, 15, 70, Color.Gray);
-                    DrawRectangle(170, 30, 15, (int)(((1.0f + leftTriggerX) / 2.0f) * 70), Color.Red);
-                    DrawRectangle(604, 30, 15, (int)(((1.0f + rightTriggerX) / 2.0f) * 70), Color.Red);
-                }
-                else if (gamepadName.Contains(PS_ALIAS_1, StringComparison.OrdinalIgnoreCase) || gamepadName.Contains(PS_ALIAS_2, StringComparison.OrdinalIgnoreCase))
-                {
-                    DrawTexture(texPs3Pad, 0, 0, Color.DarkGray);
-
-                    // Draw buttons: ps
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.Middle))
-                    {
-                        DrawCircle(396, 222, 13, Color.Red);
-                    }
-
-                    // Draw buttons: basic
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleLeft))
-                    {
-                        DrawRectangle(328, 170, 32, 13, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.MiddleRight))
-                    {
-                        DrawTriangle(
-                            new Vector2(436, 168),
-                            new Vector2(436, 185),
-                            new Vector2(464, 177),
-                            Color.Red
-                        );
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceUp))
-                    {
-                        DrawCircle(557, 144, 13, Color.Lime);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceRight))
-                    {
-                        DrawCircle(586, 173, 13, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceDown))
-                    {
-                        DrawCircle(557, 203, 13, Color.Violet);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightFaceLeft))
-                    {
-                        DrawCircle(527, 173, 13, Color.Pink);
-                    }
-
-                    // Draw buttons: d-pad
-                    DrawRectangle(225, 132, 24, 84, Color.Black);
-                    DrawRectangle(195, 161, 84, 25, Color.Black);
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceUp))
-                    {
-                        DrawRectangle(225, 132, 24, 29, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceDown))
-                    {
-                        DrawRectangle(225, 132 + 54, 24, 30, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceLeft))
-                    {
-                        DrawRectangle(195, 161, 30, 25, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftFaceRight))
-                    {
-                        DrawRectangle(195 + 54, 161, 30, 25, Color.Red);
-                    }
-
-                    // Draw buttons: left-right back buttons
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.LeftTrigger1))
-                    {
-                        DrawCircle(239, 82, 20, Color.Red);
-                    }
-
-                    if (IsGamepadButtonDown(gamepad, GamepadButton.RightTrigger1))
-                    {
-                        DrawCircle(557, 82, 20, Color.Red);
-                    }
-
-                    // Draw axis: left joystick
-                    DrawCircle(319, 255, 35, Color.Black);
-                    DrawCircle(319, 255, 31, Color.LightGray);
-                    DrawCircle(
-                        319 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.LeftX) * 20),
-                        255 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.LeftY) * 20),
-                        25,
-                        Color.Black
-                    );
-
-                    // Draw axis: right joystick
-                    DrawCircle(475, 255, 35, Color.Black);
-                    DrawCircle(475, 255, 31, Color.LightGray);
-                    DrawCircle(
-                        475 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.RightX) * 20),
-                        255 + (int)(GetGamepadAxisMovement(gamepad, GamepadAxis.RightY) * 20),
-                        25,
-                        Color.Black
-                    );
-
-                    // Draw axis: left-right triggers
-                    float leftTriggerX = GetGamepadAxisMovement(gamepad, GamepadAxis.LeftTrigger);
-                    float rightTriggerX = GetGamepadAxisMovement(gamepad, GamepadAxis.RightTrigger);
-                    DrawRectangle(169, 48, 15, 70, Color.Gray);
-                    DrawRectangle(611, 48, 15, 70, Color.Gray);
-                    DrawRectangle(169, 48, 15, (int)(((1.0f - leftTriggerX) / 2.0f) * 70), Color.Red);
-                    DrawRectangle(611, 48, 15, (int)(((1.0f - rightTriggerX) / 2.0f) * 70), Color.Red);
-                }
-                else
-                {
-                    DrawText("- GENERIC GAMEPAD -", 280, 180, 20, Color.Gray);
-                    // TODO: Draw generic gamepad
-                }
-
-                DrawText($"DETECTED AXIS [{GetGamepadAxisCount(gamepad)}]:", 10, 50, 10, Color.Maroon);
-
-                for (int i = 0; i < GetGamepadAxisCount(gamepad); i++)
-                {
-                    DrawText(
-                        $"AXIS {i}: {GetGamepadAxisMovement(gamepad, (GamepadAxis)i)}",
-                        20,
-                        70 + 20 * i,
-                        10,
-                        Color.DarkGray
-                    );
-                }
-
-                DrawRectangleRec(vibrateButton, Color.SkyBlue);
-                DrawText("VIBRATE", (int)(vibrateButton.X + 14), (int)(vibrateButton.Y + 1), 10, Color.DarkGray);
-
-
-                if (GetGamepadButtonPressed() != (int)GamepadButton.Unknown)
-                {
-                    DrawText($"DETECTED BUTTON: {GetGamepadButtonPressed()}", 10, 430, 10, Color.Red);
-                }
-                else
-                {
-                    DrawText("DETECTED BUTTON: NONE", 10, 430, 10, Color.Gray);
-                }
-            }
-            else
-            {
-                DrawText($"GP{gamepad}: NOT DETECTED", 10, 10, 10, Color.Gray);
-                DrawTexture(texXboxPad, 0, 0, Color.LightGray);
-            }
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        UnloadTexture(texPs3Pad);
+        CloseWindow();        // Close window and OpenGL context
-        UnloadTexture(texXboxPad);
-
-        CloseWindow();
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/InputGestures.cs

@@ -18,145 +18,176 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class InputGestures
+public partial class InputGestures : IExample
 {
     public const int MaxGestureStrings = 20;
 
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    private Vector2 touchPosition;
+    private Rectangle touchArea;
+
+    private int gesturesCount;
+    private string[] gestureStrings;
+
+    private Gesture currentGesture;
+    private Gesture lastGesture;
+
+    public string Name => "Core / Input Gestures";
+
+    public string Title => "raylib [core] example - input gestures";
+
+    public void Init()
+    {
+        touchPosition = new(0, 0);
+        touchArea = new(220, 10, screenWidth - 230, screenHeight - 20);
+
+        gesturesCount = 0;
+        gestureStrings = new string[MaxGestureStrings];
+
+        currentGesture = Gesture.None;
+        lastGesture = Gesture.None;
+
+        // SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        lastGesture = currentGesture;
+        currentGesture = GetGestureDetected();
+        touchPosition = GetTouchPosition(0);
+
+        if (CheckCollisionPointRec(touchPosition, touchArea) && (currentGesture != Gesture.None))
+        {
+            if (currentGesture != lastGesture)
+            {
+                // Store gesture string
+                switch ((Gesture)currentGesture)
+                {
+                    case Gesture.Tap:
+                        gestureStrings[gesturesCount] = "GESTURE TAP";
+                        break;
+                    case Gesture.DoubleTap:
+                        gestureStrings[gesturesCount] = "GESTURE DOUBLETAP";
+                        break;
+                    case Gesture.Hold:
+                        gestureStrings[gesturesCount] = "GESTURE HOLD";
+                        break;
+                    case Gesture.Drag:
+                        gestureStrings[gesturesCount] = "GESTURE DRAG";
+                        break;
+                    case Gesture.SwipeRight:
+                        gestureStrings[gesturesCount] = "GESTURE SWIPE RIGHT";
+                        break;
+                    case Gesture.SwipeLeft:
+                        gestureStrings[gesturesCount] = "GESTURE SWIPE LEFT";
+                        break;
+                    case Gesture.SwipeUp:
+                        gestureStrings[gesturesCount] = "GESTURE SWIPE UP";
+                        break;
+                    case Gesture.SwipeDown:
+                        gestureStrings[gesturesCount] = "GESTURE SWIPE DOWN";
+                        break;
+                    case Gesture.PinchIn:
+                        gestureStrings[gesturesCount] = "GESTURE PINCH IN";
+                        break;
+                    case Gesture.PinchOut:
+                        gestureStrings[gesturesCount] = "GESTURE PINCH OUT";
+                        break;
+                    default:
+                        break;
+                }
+
+                gesturesCount++;
+
+                // Reset gestures strings
+                if (gesturesCount >= MaxGestureStrings)
+                {
+                    for (var i = 0; i < MaxGestureStrings; i++)
+                    {
+                        gestureStrings[i] = " ";
+                    }
+                    gesturesCount = 0;
+                }
+            }
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawRectangleRec(touchArea, Color.Gray);
+        DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, Color.RayWhite);
+
+        DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, Fade(Color.Gray, 0.5f));
+
+        for (var i = 0; i < gesturesCount; i++)
+        {
+            if (i % 2 == 0)
+            {
+                DrawRectangle(10, 30 + 20 * i, 200, 20, Fade(Color.LightGray, 0.5f));
+            }
+            else
+            {
+                DrawRectangle(10, 30 + 20 * i, 200, 20, Fade(Color.LightGray, 0.3f));
+            }
+
+            if (i < gesturesCount - 1)
+            {
+                DrawText(gestureStrings[i], 35, 36 + 20 * i, 10, Color.DarkGray);
+            }
+            else
+            {
+                DrawText(gestureStrings[i], 35, 36 + 20 * i, 10, Color.Maroon);
+            }
+        }
+
+        DrawRectangleLines(10, 29, 200, screenHeight - 50, Color.Gray);
+        DrawText("DETECTED GESTURES", 50, 15, 10, Color.Gray);
+
+        if (currentGesture != Gesture.None)
+        {
+            DrawCircleV(touchPosition, 30, Color.Maroon);
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures");
 
-        Vector2 touchPosition = new(0, 0);
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        Rectangle touchArea = new(220, 10, screenWidth - 230, screenHeight - 20);
-
-        int gesturesCount = 0;
-        string[] gestureStrings = new string[MaxGestureStrings];
-
-        Gesture currentGesture = Gesture.None;
-        Gesture lastGesture = Gesture.None;
-
-        // SetGesturesEnabled(0b0000000000001001);   // Enable only some gestures to be detected
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new InputGestures();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            lastGesture = currentGesture;
-            currentGesture = GetGestureDetected();
-            touchPosition = GetTouchPosition(0);
-
-            if (CheckCollisionPointRec(touchPosition, touchArea) && (currentGesture != Gesture.None))
-            {
-                if (currentGesture != lastGesture)
-                {
-                    // Store gesture string
-                    switch ((Gesture)currentGesture)
-                    {
-                        case Gesture.Tap:
-                            gestureStrings[gesturesCount] = "GESTURE TAP";
-                            break;
-                        case Gesture.DoubleTap:
-                            gestureStrings[gesturesCount] = "GESTURE DOUBLETAP";
-                            break;
-                        case Gesture.Hold:
-                            gestureStrings[gesturesCount] = "GESTURE HOLD";
-                            break;
-                        case Gesture.Drag:
-                            gestureStrings[gesturesCount] = "GESTURE DRAG";
-                            break;
-                        case Gesture.SwipeRight:
-                            gestureStrings[gesturesCount] = "GESTURE SWIPE RIGHT";
-                            break;
-                        case Gesture.SwipeLeft:
-                            gestureStrings[gesturesCount] = "GESTURE SWIPE LEFT";
-                            break;
-                        case Gesture.SwipeUp:
-                            gestureStrings[gesturesCount] = "GESTURE SWIPE UP";
-                            break;
-                        case Gesture.SwipeDown:
-                            gestureStrings[gesturesCount] = "GESTURE SWIPE DOWN";
-                            break;
-                        case Gesture.PinchIn:
-                            gestureStrings[gesturesCount] = "GESTURE PINCH IN";
-                            break;
-                        case Gesture.PinchOut:
-                            gestureStrings[gesturesCount] = "GESTURE PINCH OUT";
-                            break;
-                        default:
-                            break;
-                    }
-
-                    gesturesCount++;
-
-                    // Reset gestures strings
-                    if (gesturesCount >= MaxGestureStrings)
-                    {
-                        for (int i = 0; i < MaxGestureStrings; i++)
-                        {
-                            gestureStrings[i] = " ";
-                        }
-                        gesturesCount = 0;
-                    }
-                }
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawRectangleRec(touchArea, Color.Gray);
-            DrawRectangle(225, 15, screenWidth - 240, screenHeight - 30, Color.RayWhite);
-
-            DrawText("GESTURES TEST AREA", screenWidth - 270, screenHeight - 40, 20, ColorAlpha(Color.Gray, 0.5f));
-
-            for (int i = 0; i < gesturesCount; i++)
-            {
-                if (i % 2 == 0)
-                {
-                    DrawRectangle(10, 30 + 20 * i, 200, 20, ColorAlpha(Color.LightGray, 0.5f));
-                }
-                else
-                {
-                    DrawRectangle(10, 30 + 20 * i, 200, 20, ColorAlpha(Color.LightGray, 0.3f));
-                }
-
-                if (i < gesturesCount - 1)
-                {
-                    DrawText(gestureStrings[i], 35, 36 + 20 * i, 10, Color.DarkGray);
-                }
-                else
-                {
-                    DrawText(gestureStrings[i], 35, 36 + 20 * i, 10, Color.Maroon);
-                }
-            }
-
-            DrawRectangleLines(10, 29, 200, screenHeight - 50, Color.Gray);
-            DrawText("DETECTED GESTURES", 50, 15, 10, Color.Gray);
-
-            if (currentGesture != Gesture.None)
-            {
-                DrawCircleV(touchPosition, 30, Color.Maroon);
-            }
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
+
         return 0;
     }
 }

Examples/Core/InputGesturesTestBed.cs

@@ -1,406 +1,454 @@
 /*******************************************************************************************
- *
+*
- *   raylib [core] example - input gestures testbed
+*   raylib [core] example - input gestures testbed
- *
+*
- *   Example complexity rating: [★★★☆] 3/4
+*   Example complexity rating: [★★★☆] 3/4
- *
+*
- *   Example originally created with raylib 5.0, last time updated with raylib 6.0
+*   Example originally created with raylib 5.0, last time updated with raylib 6.0
- *
+*
- *   Example contributed by ubkp (@ubkp) and reviewed by Ramon Santamaria (@raysan5)
+*   Example contributed by ubkp (@ubkp) and reviewed by Ramon Santamaria (@raysan5)
- *
+*
- *   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
+*   Example licensed under an unmodified zlib/libpng license, which is an OSI-certified,
- *   BSD-like license that allows static linking with closed source software
+*   BSD-like license that allows static linking with closed source software
- *
+*
- *   Copyright (c) 2023-2025 ubkp (@ubkp)
+*   Copyright (c) 2023-2025 ubkp (@ubkp)
- *
+*
- ********************************************************************************************/
+********************************************************************************************/
 
+using System;
 using System.Numerics;
+using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-using static Raylib_cs.Raylib;
+public partial class InputGesturesTestBed : IExample
-
-public class InputGesturesTestBed
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
     public const int GESTURE_LOG_SIZE = 20;
     public const int MAX_TOUCH_COUNT = 32;
 
-    //------------------------------------------------------------------------------------
+    public string Name => "Core / Input Gestures Test Bed";
-    // Program main entry point
-    //------------------------------------------------------------------------------------
 
-    public static int Main()
+    public string Title => "raylib [core] example - input gestures testbed";
+
+    private Vector2 messagePosition;
+
+    // Last gesture variables definitions
+    private Gesture lastGesture;
+    private Vector2 lastGesturePosition;
+
+    // Gesture log variables definitions
+    // NOTE: The gesture log uses an array (as an inverted circular queue) to store the performed gestures
+    private string[] gestureLog;
+
+    // NOTE: The index for the inverted circular queue (moving from last to first direction, then looping around)
+    private int gestureLogIndex;
+    private Gesture previousGesture;
+
+    // Log mode values:
+    // - 0 shows repeated events
+    // - 1 hides repeated events
+    // - 2 shows repeated events but hide hold events
+    // - 3 hides repeated events and hide hold events
+    private int logMode;
+
+    private Color gestureColor;
+    private Rectangle logButton1;
+    private Rectangle logButton2;
+    private Vector2 gestureLogPosition;
+
+    // Protractor variables definitions
+    private float angleLength;
+    private float currentAngleDegrees;
+    private Vector2 finalVector;
+    private Vector2 protractorPosition;
+
+    public void Init()
     {
-        // Initialization
+        messagePosition = new Vector2(160, 7);
-        //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures testbed");
-
-        Vector2 messagePosition = new Vector2(160, 7);
 
         // Last gesture variables definitions
-        Gesture lastGesture = 0;
+        lastGesture = 0;
-        Vector2 lastGesturePosition = new Vector2(165, 130);
+        lastGesturePosition = new Vector2(165, 130);
 
         // Gesture log variables definitions
         // NOTE: The gesture log uses an array (as an inverted circular queue) to store the performed gestures
-        string[] gestureLog = new string[GESTURE_LOG_SIZE + 1];
+        gestureLog = new string[GESTURE_LOG_SIZE + 1];
-        for (int i = 0; i < GESTURE_LOG_SIZE; i++)
+        for (var i = 0; i < GESTURE_LOG_SIZE; i++)
         {
             gestureLog[i] = new string(new char[12]);
         }
-        ;
+
         // NOTE: The index for the inverted circular queue (moving from last to first direction, then looping around)
-        int gestureLogIndex = GESTURE_LOG_SIZE;
+        gestureLogIndex = GESTURE_LOG_SIZE;
-        Gesture previousGesture = 0;
+        previousGesture = 0;
 
         // Log mode values:
         // - 0 shows repeated events
         // - 1 hides repeated events
         // - 2 shows repeated events but hide hold events
         // - 3 hides repeated events and hide hold events
-        int logMode = 1;
+        logMode = 1;
 
-        Color gestureColor = new Color(0, 0, 0, 255);
+        gestureColor = new Color(0, 0, 0, 255);
-        Rectangle logButton1 = new Rectangle(53, 7, 48, 26);
+        logButton1 = new Rectangle(53, 7, 48, 26);
-        Rectangle logButton2 = new Rectangle(108, 7, 36, 26);
+        logButton2 = new Rectangle(108, 7, 36, 26);
-        Vector2 gestureLogPosition = new Vector2(10, 10);
+        gestureLogPosition = new Vector2(10, 10);
 
         // Protractor variables definitions
-        float angleLength = 90.0f;
+        angleLength = 90.0f;
-        float currentAngleDegrees = 0.0f;
+        currentAngleDegrees = 0.0f;
-        Vector2 finalVector = new Vector2(0.0f, 0.0f);
+        finalVector = new Vector2(0.0f, 0.0f);
-        Vector2 protractorPosition = new Vector2(266.0f, 315.0f);
+        protractorPosition = new Vector2(266.0f, 315.0f);
+    }
 
-        SetTargetFPS(60); // Set our game to run at 60 frames-per-second
+    public void Update()
+    {
+        // Update
         //--------------------------------------------------------------------------------------
+        // Handle common gestures data
+        int i, ii; // Iterators that will be reused by all for loops
+        var currentGesture = GetGestureDetected();
+        var currentDragDegrees = GetGestureDragAngle();
+        var currentPitchDegrees = GetGesturePinchAngle();
+        var touchCount = GetTouchPointCount();
 
-        // Main game loop
+        // Handle last gesture
-        while (!WindowShouldClose()) // Detect window close button or ESC key
+        if ((currentGesture != 0) && ((int)currentGesture != 4) && (currentGesture != previousGesture))
         {
-            // Update
+            lastGesture = currentGesture; // Filter the meaningful gestures (1, 2, 8 to 512) for the display
-            //--------------------------------------------------------------------------------------
+        }
-            // Handle common gestures data
-            int i, ii; // Iterators that will be reused by all for loops
-            Gesture currentGesture = GetGestureDetected();
-            float currentDragDegrees = GetGestureDragAngle();
-            float currentPitchDegrees = GetGesturePinchAngle();
-            int touchCount = GetTouchPointCount();
 
-            // Handle last gesture
+        // Handle gesture log
-            if ((currentGesture != 0) && ((int)currentGesture != 4) && (currentGesture != previousGesture))
+        if (IsMouseButtonReleased(MouseButton.Left))
+        {
+            if (CheckCollisionPointRec(GetMousePosition(), logButton1))
             {
-                lastGesture = currentGesture; // Filter the meaningful gestures (1, 2, 8 to 512) for the display
+                switch (logMode)
-            }
-
-            // Handle gesture log
-            if (IsMouseButtonReleased(MouseButton.Left))
-            {
-                if (CheckCollisionPointRec(GetMousePosition(), logButton1))
                 {
-                    switch (logMode)
+                    case 3:
-                    {
+                        logMode = 2;
-                        case 3:
+                        break;
-                            logMode = 2;
+                    case 2:
-                            break;
+                        logMode = 3;
-                        case 2:
+                        break;
-                            logMode = 3;
+                    case 1:
-                            break;
+                        logMode = 0;
-                        case 1:
+                        break;
-                            logMode = 0;
+                    default:
-                            break;
+                        logMode = 1;
-                        default:
+                        break;
-                            logMode = 1;
-                            break;
-                    }
-                }
-                else if (CheckCollisionPointRec(GetMousePosition(), logButton2))
-                {
-                    switch (logMode)
-                    {
-                        case 3:
-                            logMode = 1;
-                            break;
-                        case 2:
-                            logMode = 0;
-                            break;
-                        case 1:
-                            logMode = 3;
-                            break;
-                        default:
-                            logMode = 2;
-                            break;
-                    }
                 }
             }
-
+            else if (CheckCollisionPointRec(GetMousePosition(), logButton2))
-            int fillLog = 0; // Gate variable to be used to allow or not the gesture log to be filled
-            if (currentGesture != 0)
             {
-                if (logMode == 3) // 3 hides repeated events and hide hold events
+                switch (logMode)
                 {
-                    if ((((int)currentGesture != 4) && (currentGesture != previousGesture)) || ((int)currentGesture < 3))
+                    case 3:
-                    {
+                        logMode = 1;
-                        fillLog = 1;
+                        break;
-                    }
+                    case 2:
+                        logMode = 0;
+                        break;
+                    case 1:
+                        logMode = 3;
+                        break;
+                    default:
+                        logMode = 2;
+                        break;
                 }
-                else if (logMode == 2) // 2 shows repeated events but hide hold events
+            }
-                {
+        }
-                    if ((int)currentGesture != 4)
+
-                    {
+        var fillLog = 0; // Gate variable to be used to allow or not the gesture log to be filled
-                        fillLog = 1;
+        if (currentGesture != 0)
-                    }
+        {
-                }
+            if (logMode == 3) // 3 hides repeated events and hide hold events
-                else if (logMode == 1) // 1 hides repeated events
+            {
-                {
+                if ((((int)currentGesture != 4) && (currentGesture != previousGesture)) || ((int)currentGesture < 3))
-                    if (currentGesture != previousGesture)
-                    {
-                        fillLog = 1;
-                    }
-                }
-                else // 0 shows repeated events
                 {
                     fillLog = 1;
                 }
             }
-
+            else if (logMode == 2) // 2 shows repeated events but hide hold events
-            if (fillLog > 0) // If one of the conditions from logMode was met, fill the gesture log
             {
-                previousGesture = currentGesture;
+                if ((int)currentGesture != 4)
-                gestureColor = GetGestureColor((int)currentGesture);
-                if (gestureLogIndex <= 0)
                 {
-                    gestureLogIndex = GESTURE_LOG_SIZE;
+                    fillLog = 1;
-                }
-                gestureLogIndex--;
-
-                // Copy the gesture respective name to the gesture log array
-                gestureLog[gestureLogIndex] = GetGestureName((int)currentGesture);
-            }
-
-            // Handle protractor
-            if ((int)currentGesture > 255)
-            {
-                currentAngleDegrees = currentPitchDegrees; // Pinch In and Pinch Out
-            }
-            else if ((int)currentGesture > 15)
-            {
-                currentAngleDegrees = currentDragDegrees; // Swipe Right, Swipe Left, Swipe Up and Swipe Down
-            }
-            else if (currentGesture > 0)
-            {
-                currentAngleDegrees = 0.0f; // Tap, Doubletap, Hold and Grab
-            }
-
-            float currentAngleRadians =
-                ((currentAngleDegrees + 90.0f) * MathF.PI / 180); // Convert the current angle to Radians
-            // Calculate the final vector for display
-            finalVector = new Vector2(
-                (angleLength * MathF.Sin(currentAngleRadians)) + protractorPosition.X,
-                (angleLength * MathF.Cos(currentAngleRadians)) + protractorPosition.Y
-            )
-            ;
-
-            // Handle touch and mouse pointer points
-            Vector2[] touchPosition = new Vector2[MAX_TOUCH_COUNT];
-
-            Vector2 mousePosition = Vector2.Zero;
-            if (currentGesture != Gesture.None)
-            {
-                if (touchCount != 0)
-                {
-                    for (i = 0; i < touchCount; i++)
-                    {
-                        touchPosition[i] = GetTouchPosition(i); // Fill the touch positions
-                    }
-                }
-                else
-                {
-                    mousePosition = GetMousePosition();
                 }
             }
-            //--------------------------------------------------------------------------------------
+            else if (logMode == 1) // 1 hides repeated events
-
-            // Draw
-            //--------------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            // Draw common elements
-            DrawText("*", (int)messagePosition.X + 5, (int)messagePosition.Y + 5, 10, Color.Black);
-            DrawText("Example optimized for Web/HTML5\non Smartphones with Touch Screen.", (int)messagePosition.X + 15,
-                (int)messagePosition.Y + 5, 10, Color.Black);
-            DrawText("*", (int)messagePosition.X + 5, (int)messagePosition.Y + 35, 10, Color.Black);
-            DrawText("While running on Desktop Web Browsers,\ninspect and turn on Touch Emulation.",
-                (int)messagePosition.X + 15, (int)messagePosition.Y + 35, 10, Color.Black);
-
-            // Draw last gesture
-            DrawText("Last gesture", (int)lastGesturePosition.X + 33, (int)lastGesturePosition.Y - 47, 20, Color.Black);
-            DrawText("Swipe         Tap       Pinch  Touch", (int)lastGesturePosition.X + 17,
-                (int)lastGesturePosition.Y - 18, 10, Color.Black);
-            DrawRectangle((int)lastGesturePosition.X + 20, (int)lastGesturePosition.Y, 20, 20,
-                lastGesture == Gesture.SwipeUp ? Color.Red : Color.LightGray);
-            DrawRectangle((int)lastGesturePosition.X, (int)lastGesturePosition.Y + 20, 20, 20,
-                lastGesture == Gesture.SwipeLeft ? Color.Red : Color.LightGray);
-            DrawRectangle((int)lastGesturePosition.X + 40, (int)lastGesturePosition.Y + 20, 20, 20,
-                lastGesture == Gesture.SwipeRight ? Color.Red : Color.LightGray);
-            DrawRectangle((int)lastGesturePosition.X + 20, (int)lastGesturePosition.Y + 40, 20, 20,
-                lastGesture == Gesture.SwipeDown ? Color.Red : Color.LightGray);
-            DrawCircle((int)lastGesturePosition.X + 80, (int)lastGesturePosition.Y + 16, 10,
-                lastGesture == Gesture.Tap ? Color.Blue : Color.LightGray);
-            DrawRing(new Vector2(
-                lastGesturePosition.X + 103, lastGesturePosition.Y + 16
-            ), 6.0f, 11.0f, 0.0f, 360.0f, 0, lastGesture == Gesture.Drag ? Color.Lime : Color.LightGray);
-            DrawCircle((int)lastGesturePosition.X + 80, (int)lastGesturePosition.Y + 43, 10,
-                lastGesture == Gesture.DoubleTap ? Color.SkyBlue : Color.LightGray);
-            DrawCircle((int)lastGesturePosition.X + 103, (int)lastGesturePosition.Y + 43, 10,
-                lastGesture == Gesture.DoubleTap ? Color.SkyBlue : Color.LightGray);
-            DrawTriangle(new Vector2(
-                lastGesturePosition.X + 122, lastGesturePosition.Y + 16
-            ), new Vector2(
-                lastGesturePosition.X + 137, lastGesturePosition.Y + 26
-            ), new Vector2(
-                lastGesturePosition.X + 137, lastGesturePosition.Y + 6
-            ), lastGesture == Gesture.PinchOut ? Color.Orange : Color.LightGray);
-            DrawTriangle(new Vector2(
-                lastGesturePosition.X + 147, lastGesturePosition.Y + 6
-            ), new Vector2(
-                lastGesturePosition.X + 147, lastGesturePosition.Y + 26
-            ), new Vector2(
-                lastGesturePosition.X + 162, lastGesturePosition.Y + 16
-            ), lastGesture == Gesture.PinchOut ? Color.Orange : Color.Gray);
-            DrawTriangle(new Vector2(
-                lastGesturePosition.X + 125, lastGesturePosition.Y + 33
-            ), new Vector2(
-                lastGesturePosition.X + 125, lastGesturePosition.Y + 53
-            ), new Vector2(
-                lastGesturePosition.X + 140, lastGesturePosition.Y + 43
-            ), lastGesture == Gesture.PinchIn ? Color.Violet : Color.LightGray);
-            DrawTriangle(new Vector2(
-                lastGesturePosition.X + 144, lastGesturePosition.Y + 43
-            ), new Vector2(
-                lastGesturePosition.X + 159, lastGesturePosition.Y + 53
-            ), new Vector2(
-                lastGesturePosition.X + 159, lastGesturePosition.Y + 33
-            ), lastGesture == Gesture.PinchIn ? Color.Violet : Color.LightGray);
-            for (i = 0; i < 4; i++)
             {
-                DrawCircle((int)lastGesturePosition.X + 180, (int)lastGesturePosition.Y + 7 + i * 15, 5,
+                if (currentGesture != previousGesture)
-                    touchCount <= i ? Color.LightGray : gestureColor);
-            }
-
-            // Draw gesture log
-            DrawText("Log", (int)gestureLogPosition.X, (int)gestureLogPosition.Y, 20, Color.Black);
-
-            // Loop in both directions to print the gesture log array in the inverted order (and looping around if the index started somewhere in the middle)
-            for (i = 0, ii = gestureLogIndex; i < GESTURE_LOG_SIZE; i++, ii = (ii + 1) % GESTURE_LOG_SIZE)
-            {
-                DrawText(gestureLog[ii], (int)gestureLogPosition.X, (int)gestureLogPosition.Y + 410 - i * 20, 20,
-                    (i == 0 ? gestureColor : Color.LightGray));
-            }
-
-            Color logButton1Color, logButton2Color;
-            switch (logMode)
-            {
-                case 3:
-                    logButton1Color = Color.Maroon;
-                    logButton2Color = Color.Maroon;
-                    break;
-                case 2:
-                    logButton1Color = Color.Gray;
-                    logButton2Color = Color.Maroon;
-                    break;
-                case 1:
-                    logButton1Color = Color.Maroon;
-                    logButton2Color = Color.Gray;
-                    break;
-                default:
-                    logButton1Color = Color.Gray;
-                    logButton2Color = Color.Gray;
-                    break;
-            }
-
-            DrawRectangleRec(logButton1, logButton1Color);
-            DrawText("Hide", (int)logButton1.X + 7, (int)logButton1.Y + 3, 10, Color.White);
-            DrawText("Repeat", (int)logButton1.X + 7, (int)logButton1.Y + 13, 10, Color.White);
-            DrawRectangleRec(logButton2, logButton2Color);
-            DrawText("Hide", (int)logButton1.X + 62, (int)logButton1.Y + 3, 10, Color.White);
-            DrawText("Hold", (int)logButton1.X + 62, (int)logButton1.Y + 13, 10, Color.White);
-
-            // Draw protractor
-            DrawText("Angle", (int)protractorPosition.X + 55, (int)protractorPosition.Y + 76, 10, Color.Black);
-
-            // Note: Official it's using raylibs functions for string manipulation. But in C# it will end up in an unsafe handling.
-            string angleString = currentAngleDegrees.ToString("F3");
-            int angleStringDot = angleString.IndexOf('.');
-            string angleStringTrim = angleString.Substring(0, angleStringDot + 3);
-
-            DrawText(angleStringTrim, (int)protractorPosition.X + 55, (int)protractorPosition.Y + 92, 20, gestureColor);
-            DrawCircleV(protractorPosition, 80.0f, Color.White);
-            DrawLineEx(new Vector2(
-                protractorPosition.X - 90, protractorPosition.Y
-            ), new Vector2(
-                protractorPosition.X + 90, protractorPosition.Y
-            ), 3.0f, Color.LightGray);
-            DrawLineEx(new Vector2(
-                protractorPosition.X, protractorPosition.Y - 90
-            ), new Vector2(
-                protractorPosition.X, protractorPosition.Y + 90
-            ), 3.0f, Color.LightGray);
-            DrawLineEx(new Vector2(
-                protractorPosition.X - 80, protractorPosition.Y - 45
-            ), new Vector2(
-                protractorPosition.X + 80, protractorPosition.Y + 45
-            ), 3.0f, Color.Green);
-            DrawLineEx(new Vector2(
-                protractorPosition.X - 80, protractorPosition.Y + 45
-            ), new Vector2(
-                protractorPosition.X + 80, protractorPosition.Y - 45
-            ), 3.0f, Color.Green);
-            DrawText("0", (int)protractorPosition.X + 96, (int)protractorPosition.Y - 9, 20, Color.Black);
-            DrawText("30", (int)protractorPosition.X + 74, (int)protractorPosition.Y - 68, 20, Color.Black);
-            DrawText("90", (int)protractorPosition.X - 11, (int)protractorPosition.Y - 110, 20, Color.Black);
-            DrawText("150", (int)protractorPosition.X - 100, (int)protractorPosition.Y - 68, 20, Color.Black);
-            DrawText("180", (int)protractorPosition.X - 124, (int)protractorPosition.Y - 9, 20, Color.Black);
-            DrawText("210", (int)protractorPosition.X - 100, (int)protractorPosition.Y + 50, 20, Color.Black);
-            DrawText("270", (int)protractorPosition.X - 18, (int)protractorPosition.Y + 92, 20, Color.Black);
-            DrawText("330", (int)protractorPosition.X + 72, (int)protractorPosition.Y + 50, 20, Color.Black);
-            if (currentAngleDegrees != 0.0f)
-            {
-                DrawLineEx(protractorPosition, finalVector, 3.0f, gestureColor);
-            }
-
-            // Draw touch and mouse pointer points
-            if (currentGesture != Gesture.None)
-            {
-                if (touchCount != 0)
                 {
-                    for (i = 0; i < touchCount; i++)
+                    fillLog = 1;
-                    {
-                        DrawCircleV(touchPosition[i], 50.0f, Fade(gestureColor, 0.5f));
-                        DrawCircleV(touchPosition[i], 5.0f, gestureColor);
-                    }
-
-                    if (touchCount == 2)
-                    {
-                        DrawLineEx(touchPosition[0], touchPosition[1], (((int)currentGesture == 512) ? 8.0f : 12.0f),
-                            gestureColor);
-                    }
-                }
-                else
-                {
-                    DrawCircleV(mousePosition, 35.0f, Fade(gestureColor, 0.5f));
-                    DrawCircleV(mousePosition, 5.0f, gestureColor);
                 }
             }
-
+            else // 0 shows repeated events
-            EndDrawing();
+            {
-            //--------------------------------------------------------------------------------------
+                fillLog = 1;
+            }
         }
 
+        if (fillLog > 0) // If one of the conditions from logMode was met, fill the gesture log
+        {
+            previousGesture = currentGesture;
+            gestureColor = GetGestureColor((int)currentGesture);
+            if (gestureLogIndex <= 0)
+            {
+                gestureLogIndex = GESTURE_LOG_SIZE;
+            }
+            gestureLogIndex--;
+
+            // Copy the gesture respective name to the gesture log array
+            gestureLog[gestureLogIndex] = GetGestureName((int)currentGesture);
+        }
+
+        // Handle protractor
+        if ((int)currentGesture > 255)
+        {
+            currentAngleDegrees = currentPitchDegrees; // Pinch In and Pinch Out
+        }
+        else if ((int)currentGesture > 15)
+        {
+            currentAngleDegrees = currentDragDegrees; // Swipe Right, Swipe Left, Swipe Up and Swipe Down
+        }
+        else if (currentGesture > 0)
+        {
+            currentAngleDegrees = 0.0f; // Tap, Doubletap, Hold and Grab
+        }
+
+        var currentAngleRadians =
+            ((currentAngleDegrees + 90.0f) * MathF.PI / 180); // Convert the current angle to Radians
+        // Calculate the final vector for display
+        finalVector = new Vector2(
+            (angleLength * MathF.Sin(currentAngleRadians)) + protractorPosition.X,
+            (angleLength * MathF.Cos(currentAngleRadians)) + protractorPosition.Y
+        );
+
+        // Handle touch and mouse pointer points
+        var touchPosition = new Vector2[MAX_TOUCH_COUNT];
+
+        var mousePosition = Vector2.Zero;
+        if (currentGesture != Gesture.None)
+        {
+            if (touchCount != 0)
+            {
+                for (i = 0; i < touchCount; i++)
+                {
+                    touchPosition[i] = GetTouchPosition(i); // Fill the touch positions
+                }
+            }
+            else
+            {
+                mousePosition = GetMousePosition();
+            }
+        }
+        //--------------------------------------------------------------------------------------
+
+        // Draw
+        //--------------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        // Draw common elements
+        DrawText("*", (int)messagePosition.X + 5, (int)messagePosition.Y + 5, 10, Color.Black);
+        DrawText("Example optimized for Web/HTML5\non Smartphones with Touch Screen.", (int)messagePosition.X + 15,
+            (int)messagePosition.Y + 5, 10, Color.Black);
+        DrawText("*", (int)messagePosition.X + 5, (int)messagePosition.Y + 35, 10, Color.Black);
+        DrawText("While running on Desktop Web Browsers,\ninspect and turn on Touch Emulation.",
+            (int)messagePosition.X + 15, (int)messagePosition.Y + 35, 10, Color.Black);
+
+        // Draw last gesture
+        DrawText("Last gesture", (int)lastGesturePosition.X + 33, (int)lastGesturePosition.Y - 47, 20, Color.Black);
+        DrawText("Swipe         Tap       Pinch  Touch", (int)lastGesturePosition.X + 17,
+            (int)lastGesturePosition.Y - 18, 10, Color.Black);
+        DrawRectangle((int)lastGesturePosition.X + 20, (int)lastGesturePosition.Y, 20, 20,
+            lastGesture == Gesture.SwipeUp ? Color.Red : Color.LightGray);
+        DrawRectangle((int)lastGesturePosition.X, (int)lastGesturePosition.Y + 20, 20, 20,
+            lastGesture == Gesture.SwipeLeft ? Color.Red : Color.LightGray);
+        DrawRectangle((int)lastGesturePosition.X + 40, (int)lastGesturePosition.Y + 20, 20, 20,
+            lastGesture == Gesture.SwipeRight ? Color.Red : Color.LightGray);
+        DrawRectangle((int)lastGesturePosition.X + 20, (int)lastGesturePosition.Y + 40, 20, 20,
+            lastGesture == Gesture.SwipeDown ? Color.Red : Color.LightGray);
+        DrawCircle((int)lastGesturePosition.X + 80, (int)lastGesturePosition.Y + 16, 10,
+            lastGesture == Gesture.Tap ? Color.Blue : Color.LightGray);
+        DrawRing(new Vector2(
+            lastGesturePosition.X + 103, lastGesturePosition.Y + 16
+        ), 6.0f, 11.0f, 0.0f, 360.0f, 0, lastGesture == Gesture.Drag ? Color.Lime : Color.LightGray);
+        DrawCircle((int)lastGesturePosition.X + 80, (int)lastGesturePosition.Y + 43, 10,
+            lastGesture == Gesture.DoubleTap ? Color.SkyBlue : Color.LightGray);
+        DrawCircle((int)lastGesturePosition.X + 103, (int)lastGesturePosition.Y + 43, 10,
+            lastGesture == Gesture.DoubleTap ? Color.SkyBlue : Color.LightGray);
+        DrawTriangle(new Vector2(
+            lastGesturePosition.X + 122, lastGesturePosition.Y + 16
+        ), new Vector2(
+            lastGesturePosition.X + 137, lastGesturePosition.Y + 26
+        ), new Vector2(
+            lastGesturePosition.X + 137, lastGesturePosition.Y + 6
+        ), lastGesture == Gesture.PinchOut ? Color.Orange : Color.LightGray);
+        DrawTriangle(new Vector2(
+            lastGesturePosition.X + 147, lastGesturePosition.Y + 6
+        ), new Vector2(
+            lastGesturePosition.X + 147, lastGesturePosition.Y + 26
+        ), new Vector2(
+            lastGesturePosition.X + 162, lastGesturePosition.Y + 16
+        ), lastGesture == Gesture.PinchOut ? Color.Orange : Color.Gray);
+        DrawTriangle(new Vector2(
+            lastGesturePosition.X + 125, lastGesturePosition.Y + 33
+        ), new Vector2(
+            lastGesturePosition.X + 125, lastGesturePosition.Y + 53
+        ), new Vector2(
+            lastGesturePosition.X + 140, lastGesturePosition.Y + 43
+        ), lastGesture == Gesture.PinchIn ? Color.Violet : Color.LightGray);
+        DrawTriangle(new Vector2(
+            lastGesturePosition.X + 144, lastGesturePosition.Y + 43
+        ), new Vector2(
+            lastGesturePosition.X + 159, lastGesturePosition.Y + 53
+        ), new Vector2(
+            lastGesturePosition.X + 159, lastGesturePosition.Y + 33
+        ), lastGesture == Gesture.PinchIn ? Color.Violet : Color.LightGray);
+        for (i = 0; i < 4; i++)
+        {
+            DrawCircle((int)lastGesturePosition.X + 180, (int)lastGesturePosition.Y + 7 + i * 15, 5,
+                touchCount <= i ? Color.LightGray : gestureColor);
+        }
+
+        // Draw gesture log
+        DrawText("Log", (int)gestureLogPosition.X, (int)gestureLogPosition.Y, 20, Color.Black);
+
+        // Loop in both directions to print the gesture log array in the inverted order (and looping around if the index started somewhere in the middle)
+        for (i = 0, ii = gestureLogIndex; i < GESTURE_LOG_SIZE; i++, ii = (ii + 1) % GESTURE_LOG_SIZE)
+        {
+            DrawText(gestureLog[ii], (int)gestureLogPosition.X, (int)gestureLogPosition.Y + 410 - i * 20, 20,
+                (i == 0 ? gestureColor : Color.LightGray));
+        }
+
+        Color logButton1Color, logButton2Color;
+        switch (logMode)
+        {
+            case 3:
+                logButton1Color = Color.Maroon;
+                logButton2Color = Color.Maroon;
+                break;
+            case 2:
+                logButton1Color = Color.Gray;
+                logButton2Color = Color.Maroon;
+                break;
+            case 1:
+                logButton1Color = Color.Maroon;
+                logButton2Color = Color.Gray;
+                break;
+            default:
+                logButton1Color = Color.Gray;
+                logButton2Color = Color.Gray;
+                break;
+        }
+
+        DrawRectangleRec(logButton1, logButton1Color);
+        DrawText("Hide", (int)logButton1.X + 7, (int)logButton1.Y + 3, 10, Color.White);
+        DrawText("Repeat", (int)logButton1.X + 7, (int)logButton1.Y + 13, 10, Color.White);
+        DrawRectangleRec(logButton2, logButton2Color);
+        DrawText("Hide", (int)logButton1.X + 62, (int)logButton1.Y + 3, 10, Color.White);
+        DrawText("Hold", (int)logButton1.X + 62, (int)logButton1.Y + 13, 10, Color.White);
+
+        // Draw protractor
+        DrawText("Angle", (int)protractorPosition.X + 55, (int)protractorPosition.Y + 76, 10, Color.Black);
+
+        // Note: Official it's using raylibs functions for string manipulation. But in C# it will end up in an unsafe handling.
+        var angleString = currentAngleDegrees.ToString("F3");
+        var angleStringDot = angleString.IndexOf('.');
+        var angleStringTrim = angleString[..(angleStringDot + 3)];
+
+        DrawText(angleStringTrim, (int)protractorPosition.X + 55, (int)protractorPosition.Y + 92, 20, gestureColor);
+        DrawCircleV(protractorPosition, 80.0f, Color.White);
+        DrawLineEx(new Vector2(
+            protractorPosition.X - 90, protractorPosition.Y
+        ), new Vector2(
+            protractorPosition.X + 90, protractorPosition.Y
+        ), 3.0f, Color.LightGray);
+        DrawLineEx(new Vector2(
+            protractorPosition.X, protractorPosition.Y - 90
+        ), new Vector2(
+            protractorPosition.X, protractorPosition.Y + 90
+        ), 3.0f, Color.LightGray);
+        DrawLineEx(new Vector2(
+            protractorPosition.X - 80, protractorPosition.Y - 45
+        ), new Vector2(
+            protractorPosition.X + 80, protractorPosition.Y + 45
+        ), 3.0f, Color.Green);
+        DrawLineEx(new Vector2(
+            protractorPosition.X - 80, protractorPosition.Y + 45
+        ), new Vector2(
+            protractorPosition.X + 80, protractorPosition.Y - 45
+        ), 3.0f, Color.Green);
+        DrawText("0", (int)protractorPosition.X + 96, (int)protractorPosition.Y - 9, 20, Color.Black);
+        DrawText("30", (int)protractorPosition.X + 74, (int)protractorPosition.Y - 68, 20, Color.Black);
+        DrawText("90", (int)protractorPosition.X - 11, (int)protractorPosition.Y - 110, 20, Color.Black);
+        DrawText("150", (int)protractorPosition.X - 100, (int)protractorPosition.Y - 68, 20, Color.Black);
+        DrawText("180", (int)protractorPosition.X - 124, (int)protractorPosition.Y - 9, 20, Color.Black);
+        DrawText("210", (int)protractorPosition.X - 100, (int)protractorPosition.Y + 50, 20, Color.Black);
+        DrawText("270", (int)protractorPosition.X - 18, (int)protractorPosition.Y + 92, 20, Color.Black);
+        DrawText("330", (int)protractorPosition.X + 72, (int)protractorPosition.Y + 50, 20, Color.Black);
+        if (currentAngleDegrees != 0.0f)
+        {
+            DrawLineEx(protractorPosition, finalVector, 3.0f, gestureColor);
+        }
+
+        // Draw touch and mouse pointer points
+        if (currentGesture != Gesture.None)
+        {
+            if (touchCount != 0)
+            {
+                for (i = 0; i < touchCount; i++)
+                {
+                    DrawCircleV(touchPosition[i], 50.0f, Fade(gestureColor, 0.5f));
+                    DrawCircleV(touchPosition[i], 5.0f, gestureColor);
+                }
+
+                if (touchCount == 2)
+                {
+                    DrawLineEx(touchPosition[0], touchPosition[1], (((int)currentGesture == 512) ? 8.0f : 12.0f),
+                        gestureColor);
+                }
+            }
+            else
+            {
+                DrawCircleV(mousePosition, 35.0f, Fade(gestureColor, 0.5f));
+                DrawCircleV(mousePosition, 5.0f, gestureColor);
+            }
+        }
+
+        EndDrawing();
+        //--------------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
+    public static int Main()
+    {
+        // Initialization
+        //--------------------------------------------------------------------------------------
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - input gestures testbed");
+
+        SetTargetFPS(60); // Set our game to run at 60 frames-per-second
+        //--------------------------------------------------------------------------------------
+
+        var game = new InputGesturesTestBed();
+        game.Init();
+
+        // Main game loop
+        while (!WindowShouldClose()) // Detect window close button or ESC key
+        {
+            game.Update();
+        }
+
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
         CloseWindow(); // Close window and OpenGL context
@@ -409,7 +457,8 @@ public class InputGesturesTestBed
         return 0;
     }
 
-    static string GetGestureName(int gesture)
+    // Get text string for gesture value
+    private static string GetGestureName(int gesture)
     {
         switch (gesture)
         {
@@ -441,7 +490,7 @@ public class InputGesturesTestBed
     }
 
     // Get color for gesture value
-    static Color GetGestureColor(int gesture)
+    private static Color GetGestureColor(int gesture)
     {
         switch (gesture)
         {

Examples/Core/InputKeys.cs

@@ -18,64 +18,87 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class InputKeys
+public partial class InputKeys : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Input Keys";
+
+    public string Title => "raylib [core] example - input keys";
+
+    private Vector2 ballPosition;
+
+    public void Init()
+    {
+        ballPosition = new((float)screenWidth / 2, (float)screenHeight / 2);
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyDown(KeyboardKey.Right))
+        {
+            ballPosition.X += 2.0f;
+        }
+
+        if (IsKeyDown(KeyboardKey.Left))
+        {
+            ballPosition.X -= 2.0f;
+        }
+
+        if (IsKeyDown(KeyboardKey.Up))
+        {
+            ballPosition.Y -= 2.0f;
+        }
+
+        if (IsKeyDown(KeyboardKey.Down))
+        {
+            ballPosition.Y += 2.0f;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawText("move the ball with arrow keys", 10, 10, 20, Color.DarkGray);
+
+        DrawCircleV(ballPosition, 50, Color.Maroon);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - input keys");
-        const int screenHeight = 450;
 
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - keyboard input");
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-
-        Vector2 ballPosition = new((float)screenWidth / 2, (float)screenHeight / 2);
-
-        SetTargetFPS(60);       // Set target frames-per-second
         //--------------------------------------------------------------------------------------
 
+        var game = new InputKeys();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            if (IsKeyDown(KeyboardKey.Right))
-            {
-                ballPosition.X += 2.0f;
-            }
-
-            if (IsKeyDown(KeyboardKey.Left))
-            {
-                ballPosition.X -= 2.0f;
-            }
-
-            if (IsKeyDown(KeyboardKey.Up))
-            {
-                ballPosition.Y -= 2.0f;
-            }
-
-            if (IsKeyDown(KeyboardKey.Down))
-            {
-                ballPosition.Y += 2.0f;
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawText("move the ball with arrow keys", 10, 10, 20, Color.DarkGray);
-
-            DrawCircleV(ballPosition, 50, Color.Maroon);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/InputMouse.cs

@@ -19,95 +19,122 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class InputMouse
+public partial class InputMouse : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Input Mouse";
+
+    public string Title => "raylib [core] example - input mouse";
+
+    private Vector2 ballPosition;
+    private Color ballColor;
+
+    public void Init()
+    {
+        ballPosition = new(-100.0f, -100.0f);
+        ballColor = Color.DarkBlue;
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        if (IsKeyPressed(KeyboardKey.H))
+        {
+            if (IsCursorHidden())
+            {
+                ShowCursor();
+            }
+            else
+            {
+                HideCursor();
+            }
+        }
+
+        ballPosition = GetMousePosition();
+
+        if (IsMouseButtonPressed(MouseButton.Left))
+        {
+            ballColor = Color.Maroon;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Middle))
+        {
+            ballColor = Color.Lime;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Right))
+        {
+            ballColor = Color.DarkBlue;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Side))
+        {
+            ballColor = Color.Purple;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Extra))
+        {
+            ballColor = Color.Yellow;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Forward))
+        {
+            ballColor = Color.Orange;
+        }
+        else if (IsMouseButtonPressed(MouseButton.Back))
+        {
+            ballColor = Color.Beige;
+        }
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawCircleV(ballPosition, 40, ballColor);
+
+        DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, Color.DarkGray);
+        DrawText("Press 'H' to toggle cursor visibility", 10, 30, 20, Color.DarkGray);
+
+        if (IsCursorHidden())
+        {
+            DrawText("CURSOR HIDDEN", 20, 60, 20, Color.Red);
+        }
+        else
+        {
+            DrawText("CURSOR VISIBLE", 20, 60, 20, Color.Lime);
+        }
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
+        InitWindow(screenWidth, screenHeight, "raylib [core] example - input mouse");
-        const int screenHeight = 450;
 
-        InitWindow(screenWidth, screenHeight, "raylib [core] example - mouse input");
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-
-        Vector2 ballPosition = new(-100.0f, -100.0f);
-        Color ballColor = Color.DarkBlue;
-
-        SetTargetFPS(60);
         //---------------------------------------------------------------------------------------
 
+        var game = new InputMouse();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-
-            if (IsKeyPressed(KeyboardKey.H))
-            {
-                if (IsCursorHidden())
-                {
-                    ShowCursor();
-                }
-                else
-                {
-                    HideCursor();
-                }
-            }
-
-            ballPosition = GetMousePosition();
-
-            if (IsMouseButtonPressed(MouseButton.Left))
-            {
-                ballColor = Color.Maroon;
-            }
-            else if (IsMouseButtonPressed(MouseButton.Middle))
-            {
-                ballColor = Color.Lime;
-            }
-            else if (IsMouseButtonPressed(MouseButton.Right))
-            {
-                ballColor = Color.DarkBlue;
-            }
-            else if (IsMouseButtonPressed(MouseButton.Extra))
-            {
-                ballColor = Color.Yellow;
-            }
-            else if (IsMouseButtonPressed(MouseButton.Forward))
-            {
-                ballColor = Color.Orange;
-            }
-            else if (IsMouseButtonPressed(MouseButton.Back))
-            {
-                ballColor = Color.Beige;
-            }
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawCircleV(ballPosition, 40, ballColor);
-
-            DrawText("move ball with mouse and click mouse button to change color", 10, 10, 20, Color.DarkGray);
-            DrawText("Press 'H' to toggle cursor visibility", 10, 30, 20, Color.DarkGray);
-
-            if (IsCursorHidden())
-            {
-                DrawText("CURSOR HIDDEN", 20, 60, 20, Color.Red);
-            }
-            else
-            {
-                DrawText("CURSOR VISIBLE", 20, 60, 20, Color.Lime);
-            }
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;

Examples/Core/InputMouseWheel.cs

@@ -17,48 +17,72 @@ using static Raylib_cs.Raylib;
 
 namespace Examples.Core;
 
-public class InputMouseWheel
+public partial class InputMouseWheel : IExample
 {
+    private const int screenWidth = 800;
+    private const int screenHeight = 450;
+
+    public string Name => "Core / Mouse Wheel";
+
+    public string Title => "raylib [core] example - input mouse wheel";
+
+    private int boxPositionY;
+    private int scrollSpeed;                // Scrolling speed in pixels
+
+    public void Init()
+    {
+        boxPositionY = screenHeight / 2 - 40;
+        scrollSpeed = 4;            // Scrolling speed in pixels
+    }
+
+    public void Update()
+    {
+        // Update
+        //----------------------------------------------------------------------------------
+        boxPositionY -= (int)(GetMouseWheelMove() * scrollSpeed);
+        //----------------------------------------------------------------------------------
+
+        // Draw
+        //----------------------------------------------------------------------------------
+        BeginDrawing();
+        ClearBackground(Color.RayWhite);
+
+        DrawRectangle(screenWidth / 2 - 40, boxPositionY, 80, 80, Color.Maroon);
+
+        DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, Color.Gray);
+        DrawText($"Box position Y: {boxPositionY:000}", 10, 40, 20, Color.LightGray);
+
+        EndDrawing();
+        //----------------------------------------------------------------------------------
+    }
+
+    public void Unload()
+    {
+    }
+
     public static int Main()
     {
         // Initialization
         //--------------------------------------------------------------------------------------
-        const int screenWidth = 800;
-        const int screenHeight = 450;
-
         InitWindow(screenWidth, screenHeight, "raylib [core] example - input mouse wheel");
 
-        int boxPositionY = screenHeight / 2 - 40;
+        SetTargetFPS(60);               // Set our game to run at 60 frames-per-second
-        int scrollSpeed = 4;            // Scrolling speed in pixels
-
-        SetTargetFPS(60);
         //--------------------------------------------------------------------------------------
 
+        var game = new InputMouseWheel();
+        game.Init();
+
         // Main game loop
-        while (!WindowShouldClose())
+        while (!WindowShouldClose())    // Detect window close button or ESC key
         {
-            // Update
+            game.Update();
-            //----------------------------------------------------------------------------------
-            boxPositionY -= (int)(GetMouseWheelMove() * scrollSpeed);
-            //----------------------------------------------------------------------------------
-
-            // Draw
-            //----------------------------------------------------------------------------------
-            BeginDrawing();
-            ClearBackground(Color.RayWhite);
-
-            DrawRectangle(screenWidth / 2 - 40, boxPositionY, 80, 80, Color.Maroon);
-
-            DrawText("Use mouse wheel to move the cube up and down!", 10, 10, 20, Color.Gray);
-            DrawText($"Box position Y: {boxPositionY}", 10, 40, 20, Color.LightGray);
-
-            EndDrawing();
-            //----------------------------------------------------------------------------------
         }
 
+        game.Unload();
+
         // De-Initialization
         //--------------------------------------------------------------------------------------
-        CloseWindow();
+        CloseWindow();        // Close window and OpenGL context
         //--------------------------------------------------------------------------------------
 
         return 0;