Directory cleanup

3 files changed, 355 insertions, 0 deletions

diff --git a/examples/sample1.cpp b/examples/sample1.cpp
new file mode 100644
index 0000000..490b0a1
--- /dev/null
+++ b/examples/sample1.cpp
@@ -0,0 +1,123 @@
+#include "graphics.h"
+#include <cmath>
+
+int main(int argc, char* argv[]) {
+    // Create a window
+    WindowHandle* window = createWindow("TestApp", 800, 600);
+    
+    if (!window) {
+        return -1;
+    }
+    
+    // Animation variables
+    float time = 0.0f;
+    const float PI = 3.14159265359f;
+    
+    // Main loop
+    while (!windowShouldClose(window)) {
+        // Handle events
+        pollEvents(window);
+        
+        // Clear screen with a dark background
+        clearScreen(window, Color(0, 0, 0));
+        
+        // Draw a grid
+        Color gridColor(255, 255, 255);
+        for (int x = 0; x < 800; x += 50) {
+            drawLine(window, x, 0, x, 600, gridColor);
+        }
+        for (int y = 0; y < 600; y += 50) {
+            drawLine(window, 0, y, 800, y, gridColor);
+        }
+        
+        // Draw some static shapes
+        drawFilledRectangle(window, 50, 50, 100, 80, Color(255, 100, 100));
+        drawRectangle(window, 48, 48, 104, 84, Color(255, 150, 150));
+        
+        drawFilledCircle(window, 250, 90, 40, Color(100, 255, 100));
+        drawCircle(window, 250, 90, 42, Color(150, 255, 150));
+        
+        // Animated rotating line
+        int centerX = 400;
+        int centerY = 300;
+        int lineLength = 150;
+        int x2 = centerX + static_cast<int>(lineLength * cos(time));
+        int y2 = centerY + static_cast<int>(lineLength * sin(time));
+        
+        drawLine(window, centerX, centerY, x2, y2, Color(255, 255, 100, 255));
+        drawFilledCircle(window, centerX, centerY, 5, Color(255, 200, 0));
+        
+        // Animated bouncing circle
+        int bounceX = 600;
+        int bounceY = 300 + static_cast<int>(100 * sin(time * 2));
+        drawFilledCircle(window, bounceX, bounceY, 30, Color(100, 200, 255));
+
+        int prevX = bounceX + bounceX + time * 20;
+        int prevY = 300 + static_cast<int>(100 * sin((bounceX + time * 20) * 2));
+
+        for (int i = bounceX + time * 20; i > bounceX; i--) {
+            int x = bounceX + bounceX + time * 20 - i;
+            int y = 300 + static_cast<int>(100 * sin(i * 2));
+            // drawPixel(window, x, y, Color(255, 0, 0));
+            drawLine(window, prevX, prevY, x, y, Color(255, 0, 0));
+            prevX = x;
+            prevY = y;
+        }
+        
+        // Draw multiple small circles in a pattern
+        for (int i = 0; i < 8; i++) {
+            float angle = (time + i * PI / 4);
+            int px = 400 + static_cast<int>(100 * cos(angle));
+            int py = 300 + static_cast<int>(100 * sin(angle));
+            
+            Color particleColor(
+                static_cast<uint8_t>(128 + 127 * sin(time + i)),
+                static_cast<uint8_t>(128 + 127 * sin(time + i + PI * 2 / 3)),
+                static_cast<uint8_t>(128 + 127 * sin(time + i + PI * 4 / 3))
+            );
+            
+            drawFilledCircle(window, px, py, 8, particleColor);
+        }
+        
+        // Draw some text-like pixel art (a simple "HI" pattern)
+        Color pixelColor(255, 255, 255);
+        // Letter H
+        for (int y = 0; y < 20; y++) {
+            drawPixel(window, 50, 500 + y, pixelColor);
+            drawPixel(window, 70, 500 + y, pixelColor);
+        }
+        for (int x = 50; x <= 70; x++) {
+            drawPixel(window, x, 510, pixelColor);
+        }
+        
+        // Letter I
+        for (int y = 0; y < 20; y++) {
+            drawPixel(window, 90, 500 + y, pixelColor);
+        }
+        for (int x = 85; x <= 95; x++) {
+            drawPixel(window, x, 500, pixelColor);
+            drawPixel(window, x, 519, pixelColor);
+        }
+        
+        // Draw a gradient effect using rectangles
+        for (int i = 0; i < 50; i++) {
+            uint8_t colorValue = static_cast<uint8_t>(i * 5);
+            drawFilledRectangle(window, 650 + i * 3, 450, 3, 100, 
+                              Color(colorValue, 0, 255 - colorValue));
+        }
+        
+        // Present the rendered frame
+        swapBuffers(window);
+        
+        // Update animation
+        time += 0.02f;
+        
+        // Small delay to control frame rate (~60 FPS)
+        delay(16);
+    }
+    
+    // Cleanup
+    destroyWindow(window);
+    
+    return 0;
+}
diff --git a/examples/sample2.cpp b/examples/sample2.cpp
new file mode 100644
index 0000000..02e1718
--- /dev/null
+++ b/examples/sample2.cpp
@@ -0,0 +1,102 @@
+#include "graphics.h"
+#include <cmath>
+#include <vector>
+
+struct Vec3 {
+    float x, y, z;
+};
+
+// Rotate point around X axis
+Vec3 rotateX(const Vec3& v, float angle) {
+    float c = std::cos(angle);
+    float s = std::sin(angle);
+    return {
+        v.x,
+        v.y * c - v.z * s,
+        v.y * s + v.z * c
+    };
+}
+
+// Rotate point around Y axis
+Vec3 rotateY(const Vec3& v, float angle) {
+    float c = std::cos(angle);
+    float s = std::sin(angle);
+    return {
+        v.x * c + v.z * s,
+        v.y,
+        -v.x * s + v.z * c
+    };
+}
+
+// Perspective projection
+void project(const Vec3& v, int& x2d, int& y2d, float width, float height) {
+    float distance = 2.0f;        // camera distance
+    float scale = 100.0f;         // zoom factor
+
+    float z = v.z + distance;
+    float factor = scale / z;
+
+    x2d = static_cast<int>(v.x * factor + width / 2);
+    y2d = static_cast<int>(v.y * factor + height / 2);
+}
+
+int main() {
+    const int width = 640;
+    const int height = 480;
+
+    WindowHandle* window = createWindow("3D Spinning Cube", width, height);
+    if (!window) return -1;
+
+    // Cube vertices
+    std::vector<Vec3> vertices = {
+        {-1, -1, -1},
+        { 1, -1, -1},
+        { 1,  1, -1},
+        {-1,  1, -1},
+        {-1, -1,  1},
+        { 1, -1,  1},
+        { 1,  1,  1},
+        {-1,  1,  1}
+    };
+
+    // Cube edges (pairs of vertex indices)
+    std::vector<std::pair<int,int>> edges = {
+        {0,1},{1,2},{2,3},{3,0}, // back face
+        {4,5},{5,6},{6,7},{7,4}, // front face
+        {0,4},{1,5},{2,6},{3,7}  // connecting edges
+    };
+
+    float angle = 0.0f;
+
+    while (!windowShouldClose(window)) {
+        pollEvents(window);
+        clearScreen(window, Color(0, 0, 0)); // RGB 20, 20, 30
+
+        std::vector<Vec3> transformed;
+
+        // Rotate cube
+        for (const auto& v : vertices) {
+            Vec3 r = rotateX(v, angle);
+            r = rotateY(r, angle * 0.7f);
+            transformed.push_back(r);
+        }
+
+        // Draw edges
+        for (const auto& edge : edges) {
+            int x1, y1, x2, y2;
+
+            project(transformed[edge.first], x1, y1, width, height);
+            project(transformed[edge.second], x2, y2, width, height);
+
+            drawLine(window, x1, y1, x2, y2, Color(255, 255, 255)); // RGB 0 255 180
+        }
+
+        swapBuffers(window);
+
+        angle += 0.01f;
+        delay(16); // ~60 FPS
+    }
+
+    destroyWindow(window);
+    return 0;
+}
diff --git a/examples/sample3.cpp b/examples/sample3.cpp
new file mode 100644
index 0000000..70c1e13
--- /dev/null
+++ b/examples/sample3.cpp
@@ -0,0 +1,130 @@
+#include "graphics.h"
+#include <cmath>
+#include <vector>
+#include <cstdlib>
+
+struct Vec3 {
+    float x, y, z;
+};
+
+Vec3 rotateX(const Vec3& v, float angle) {
+    float c = std::cos(angle);
+    float s = std::sin(angle);
+    return { v.x, v.y * c - v.z * s, v.y * s + v.z * c };
+}
+
+Vec3 rotateY(const Vec3& v, float angle) {
+    float c = std::cos(angle);
+    float s = std::sin(angle);
+    return { v.x * c + v.z * s, v.y, -v.x * s + v.z * c };
+}
+
+Vec3 rotateZ(const Vec3& v, float angle) {
+    float c = std::cos(angle);
+    float s = std::sin(angle);
+    return { v.x * c - v.y * s, v.x * s + v.y * c, v.z };
+}
+
+void project(const Vec3& v, int& x2d, int& y2d, float width, float height, float zoom) {
+    float distance = 4.0f;
+    float z = v.z + distance;
+    float factor = zoom / z;
+
+    x2d = static_cast<int>(v.x * factor + width / 2);
+    y2d = static_cast<int>(v.y * factor + height / 2);
+}
+
+struct Star {
+    float x, y, z;
+};
+
+int main() {
+    const int width = 800;
+    const int height = 600;
+
+    WindowHandle* window = createWindow("DEMOSCENE CUBE", width, height);
+    if (!window) return -1;
+
+    std::vector<Vec3> vertices = {
+        {-1,-1,-1},{1,-1,-1},{1,1,-1},{-1,1,-1},
+        {-1,-1,1},{1,-1,1},{1,1,1},{-1,1,1}
+    };
+
+    std::vector<std::pair<int,int>> edges = {
+        {0,1},{1,2},{2,3},{3,0},
+        {4,5},{5,6},{6,7},{7,4},
+        {0,4},{1,5},{2,6},{3,7}
+    };
+
+    // Starfield
+    const int starCount = 300;
+    std::vector<Star> stars;
+    for (int i = 0; i < starCount; ++i) {
+        stars.push_back({
+            ((rand() % 200) - 100) / 10.0f,
+            ((rand() % 200) - 100) / 10.0f,
+            (rand() % 100) / 10.0f
+        });
+    }
+
+    float time = 0.0f;
+
+    while (!windowShouldClose(window)) {
+        pollEvents(window);
+
+        // Pulsing background
+        int bg = static_cast<int>((std::sin(time * 0.5f) + 1.0f) * 20);
+        clearScreen(window, Color(bg, 0, bg + 20));
+
+        // --- STARFIELD ---
+        for (auto& star : stars) {
+            star.z -= 0.05f;
+            if (star.z <= 0.1f)
+                star.z = 10.0f;
+
+            int sx = static_cast<int>((star.x / star.z) * 200 + width/2);
+            int sy = static_cast<int>((star.y / star.z) * 200 + height/2);
+
+            if (sx >= 0 && sx < width && sy >= 0 && sy < height)
+                drawPixel(window, sx, sy, Color(255,255,255));
+        }
+
+        // Color cycling (rainbow)
+        int r = static_cast<int>((std::sin(time) + 1) * 127);
+        int g = static_cast<int>((std::sin(time + 2) + 1) * 127);
+        int b = static_cast<int>((std::sin(time + 4) + 1) * 127);
+
+        float zoom = 150.0f + std::sin(time) * 50.0f;
+
+        // --- MULTI-CUBE EFFECT ---
+        for (int c = 0; c < 3; ++c) {
+
+            float offset = c * 2.5f - 2.5f;
+
+            std::vector<Vec3> transformed;
+
+            for (const auto& v : vertices) {
+                Vec3 r3 = rotateX(v, time + c);
+                r3 = rotateY(r3, time * 0.7f + c);
+                r3 = rotateZ(r3, time * 0.5f);
+                r3.x += offset;
+                transformed.push_back(r3);
+            }
+
+            for (const auto& edge : edges) {
+                int x1, y1, x2, y2;
+                project(transformed[edge.first], x1, y1, width, height, zoom);
+                project(transformed[edge.second], x2, y2, width, height, zoom);
+                drawLine(window, x1, y1, x2, y2, Color(r, g, b));
+            }
+        }
+
+        swapBuffers(window);
+
+        time += 0.02f;
+        delay(16);
+    }
+
+    destroyWindow(window);
+    return 0;
+}