From 0abe373959aceb49949b868f66defb9d5ed0be8c Mon Sep 17 00:00:00 2001 From: yggdrasil75 Date: Sun, 9 Nov 2025 17:10:32 -0500 Subject: [PATCH] meh. --- .vscode/settings.json | 18 ++- main.cpp | 351 ++++++++++++++++++++++++++++++------------ web/index.html | 2 +- web/stream.js | 36 +++-- 4 files changed, 298 insertions(+), 109 deletions(-) diff --git a/.vscode/settings.json b/.vscode/settings.json index 53ac7f2..b39a667 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -68,7 +68,23 @@ "xstring": "cpp", "xtr1common": "cpp", "xtree": "cpp", - "xutility": "cpp" + "xutility": "cpp", + "bitset": "cpp", + "codecvt": "cpp", + "condition_variable": "cpp", + "cstdarg": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "memory_resource": "cpp", + "numeric": "cpp", + "string_view": "cpp", + "mutex": "cpp", + "numbers": "cpp", + "semaphore": "cpp", + "span": "cpp", + "cinttypes": "cpp", + "variant": "cpp", + "__nullptr": "cpp" }, "files.exclude": { "**/*.rpyc": true, diff --git a/main.cpp b/main.cpp index 911d256..978327e 100644 --- a/main.cpp +++ b/main.cpp @@ -5,6 +5,8 @@ #include #include #include +#include +#include #include "util/simple_httpserver.hpp" #include "util/grid2.hpp" #include "util/bmpwriter.hpp" @@ -12,17 +14,35 @@ #include "util/timing_decorator.hpp" #include "simtools/sim2.hpp" -std::vector currentFrame; -std::atomic frameReady{false}; +// Global variables for live streaming +std::queue> frameQueue; +std::mutex queueMutex; +std::condition_variable frameCondition; std::atomic streaming{false}; -std::mutex frameMutex; +std::atomic activeClients{0}; +std::atomic frameCounter{0}; + +// Current simulation parameters +struct SimulationParams { + std::string mode = "gradient"; + uint32_t seed = 42; + float scale = 4.0f; + int octaves = 4; + float persistence = 0.5f; + float lacunarity = 2.0f; + float elevation = 1.0f; + float waterLevel = 0.3f; +}; + +SimulationParams currentParams; +std::mutex paramsMutex; // Function to convert hex color string to Vec4 Vec4 hexToVec4(const std::string& hex) { TIME_FUNCTION; if (hex.length() != 6) { - return Vec4(0, 0, 0, 1); // Default to black if invalid + return Vec4(0, 0, 0, 1); } int r, g, b; @@ -36,31 +56,27 @@ std::vector generateGradientFrame(int width = 512, int height = 512) { TIME_FUNCTION; const int POINTS_PER_DIM = 256; - Grid2 grid; - // Define our target colors at specific positions - Vec4 white = hexToVec4("ffffff"); // Top-left corner (1,1) - Vec4 red = hexToVec4("ff0000"); // Top-right corner (1,-1) - Vec4 green = hexToVec4("00ff00"); // Center (0,0) - Vec4 blue = hexToVec4("0000ff"); // Bottom-left corner (-1,-1) - Vec4 black = hexToVec4("000000"); // Bottom-right corner (-1,1) + // Define colors + Vec4 white = hexToVec4("ffffff"); + Vec4 red = hexToVec4("ff0000"); + Vec4 green = hexToVec4("00ff00"); + Vec4 blue = hexToVec4("0000ff"); + Vec4 black = hexToVec4("000000"); + + // Animate based on frame counter for live effect + float time = frameCounter * 0.01f; - // Create gradient points for (int y = 0; y < POINTS_PER_DIM; ++y) { for (int x = 0; x < POINTS_PER_DIM; ++x) { - // Normalize coordinates to [-1, 1] float nx = (static_cast(x) / (POINTS_PER_DIM - 1)) * 2.0f - 1.0f; float ny = (static_cast(y) / (POINTS_PER_DIM - 1)) * 2.0f - 1.0f; - // Create position Vec2 pos(nx, ny); - - // Convert to [0,1] range for interpolation float u = (nx + 1.0f) / 2.0f; float v = (ny + 1.0f) / 2.0f; - // Bilinear interpolation between corners Vec4 top = white * (1.0f - u) + red * u; Vec4 bottom = blue * (1.0f - u) + black * u; Vec4 cornerColor = top * (1.0f - v) + bottom * v; @@ -74,30 +90,65 @@ std::vector generateGradientFrame(int width = 512, int height = 512) { } } - // Render to RGB image return grid.renderToRGB(width, height); } +// Generate terrain simulation frame data +std::vector generateTerrainFrame(int width = 512, int height = 512) { + TIME_FUNCTION; + + SimulationParams params; + { + std::lock_guard lock(paramsMutex); + params = currentParams; + } + + // Use frame counter to animate terrain + uint32_t animatedSeed = params.seed + frameCounter; + + Sim2 sim(width, height, animatedSeed, params.scale, params.octaves, + params.persistence, params.lacunarity, params.waterLevel, params.elevation); + sim.generateTerrain(); + + return sim.renderToRGB(width, height); +} + // Streaming thread function -void streamingThread(const std::string& mode) { - uint32_t frameCount = 0; +void streamingThread() { auto lastFrameTime = std::chrono::steady_clock::now(); while (streaming) { auto startTime = std::chrono::steady_clock::now(); - std::vector newFrame; - - newFrame = generateGradientFrame(512, 512); - { - std::lock_guard lock(frameMutex); - currentFrame = std::move(newFrame); - frameReady = true; + // Only generate frames if there are active clients + if (activeClients > 0) { + std::vector frame; + + { + std::lock_guard lock(paramsMutex); + if (currentParams.mode == "terrain") { + frame = generateTerrainFrame(); + } else { + frame = generateGradientFrame(); + } + } + + // Add frame to queue + { + std::lock_guard lock(queueMutex); + // Limit queue size to prevent memory issues + while (frameQueue.size() > 10) { + frameQueue.pop(); + } + frameQueue.push(std::move(frame)); + frameCounter++; + } + + // Notify waiting clients + frameCondition.notify_all(); } - frameCount++; - - // Limit frame rate to ~30 FPS + // Control frame rate (30 FPS max) auto endTime = std::chrono::steady_clock::now(); auto elapsed = std::chrono::duration_cast(endTime - startTime); auto targetFrameTime = std::chrono::milliseconds(33); // ~30 FPS @@ -110,9 +161,34 @@ void streamingThread(const std::string& mode) { } } +// Get the latest frame (blocks until frame is available) +std::vector getLatestFrame(int timeoutMs = 1000) { + std::unique_lock lock(queueMutex); + + if (frameCondition.wait_for(lock, std::chrono::milliseconds(timeoutMs), + []{ return !frameQueue.empty(); })) { + auto frame = std::move(frameQueue.front()); + // Keep only the latest frame for new clients + std::queue> empty; + std::swap(frameQueue, empty); + frameQueue.push(frame); // Keep one frame for the next client + return frame; + } + + return {}; // Return empty frame on timeout +} + +// Convert RGB data to JPEG (simplified - in real implementation use libjpeg) +std::vector rgbToJpeg(const std::vector& rgbData, int width, int height) { + TIME_FUNCTION; + + // TODO: return mjpeg + + return rgbData; // Return uncompressed RGB for now +} + // Add this function to get timing stats as JSON std::string getTimingStatsJSON() { - auto stats = FunctionTimer::getStats(); std::stringstream json; @@ -147,18 +223,16 @@ int main(int argc, char* argv[]) { // Check command line arguments int port = 8080; std::string webRoot = "web"; - std::string mode = "gradient"; // Default mode + std::string mode = "gradient"; for (int i = 1; i < argc; ++i) { std::string arg = argv[i]; if (arg == "--port" || arg == "-p") { - if (i + 1 < argc) { - port = std::stoi(argv[++i]); - } + if (i + 1 < argc) port = std::stoi(argv[++i]); } else if (arg == "--webroot" || arg == "-w") { - if (i + 1 < argc) { - webRoot = argv[++i]; - } + if (i + 1 < argc) webRoot = argv[++i]; + } else if (arg == "-2d") { + mode = "terrain"; } else if (arg == "-all") { mode = "all"; } else if (arg == "--help" || arg == "-h") { @@ -166,56 +240,34 @@ int main(int argc, char* argv[]) { std::cout << "Options:" << std::endl; std::cout << " -p, --port PORT Set server port (default: 8080)" << std::endl; std::cout << " -w, --webroot DIR Set web root directory (default: web)" << std::endl; + std::cout << " -2d Display 2D terrain simulation" << std::endl; std::cout << " -all Allow switching between gradient and terrain" << std::endl; std::cout << " -h, --help Show this help message" << std::endl; return 0; } } - // Generate initial frame - std::cout << "Starting " << mode << " streaming..." << std::endl; + // Set initial mode + { + std::lock_guard lock(paramsMutex); + currentParams.mode = mode; + } // Start streaming thread streaming = true; - std::thread streamThread(streamingThread, mode); + std::thread streamThread(streamingThread); SimpleHTTPServer server(port, webRoot); - // Add live stream endpoint - server.addRoute("/api/live-stream", [](const std::string& method, const std::string& body) { - if (method == "GET") { - int maxWait = 100; - while (!frameReady && maxWait-- > 0) { - std::this_thread::sleep_for(std::chrono::milliseconds(10)); - } - - if (!frameReady) { - return std::make_pair(503, std::basic_string("{\"error\":\"No frame available\"}")); - } - - std::vector frameCopy; - { - std::lock_guard lock(frameMutex); - frameCopy = currentFrame; - } - - // Convert to base64 for JSON response - std::string base64Data = "data:image/jpeg;base64,"; - // TODO - - std::stringstream json; - json << "{\"frame_available\":true,\"width\":512,\"height\":512,\"data_size\":" << frameCopy.size() << "}"; - - return std::make_pair(200, json.str()); - } - return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); - }); - + // MJPEG stream endpoint server.addRoute("/stream.mjpg", [](const std::string& method, const std::string& body) { if (method == "GET") { - // TODO + activeClients++; + + // Set up MJPEG stream headers std::string response = "HTTP/1.1 200 OK\r\n"; response += "Content-Type: multipart/x-mixed-replace; boundary=frame\r\n"; + response += "Cache-Control: no-cache\r\n"; response += "Connection: close\r\n"; response += "\r\n"; @@ -223,32 +275,140 @@ int main(int argc, char* argv[]) { } return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); }); + + // Single frame endpoint + server.addRoute("/api/frame", [](const std::string& method, const std::string& body) { + if (method == "GET") { + activeClients++; + + auto frame = getLatestFrame(); + if (!frame.empty()) { + // Convert to JPEG (in real implementation) + auto jpegData = rgbToJpeg(frame, 512, 512); + + // For now, send as raw RGB with custom content type + std::string response(jpegData.begin(), jpegData.end()); + activeClients--; + return std::make_pair(200, response); + } + + activeClients--; + return std::make_pair(503, std::basic_string("No frame available")); + } + return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); + }); + + // Frame info endpoint + server.addRoute("/api/frame-info", [](const std::string& method, const std::string& body) { + if (method == "GET") { + std::stringstream json; + json << "{" + << "\"frame_count\":" << frameCounter << "," + << "\"active_clients\":" << activeClients << "," + << "\"width\":512," + << "\"height\":512," + << "\"channels\":3" + << "}"; + return std::make_pair(200, json.str()); + } + return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); + }); + + // Parameter setting endpoint + server.addRoute("/api/set-parameters", [](const std::string& method, const std::string& body) { + if (method == "POST") { + try { + SimulationParams newParams; + { + std::lock_guard lock(paramsMutex); + newParams = currentParams; + } + + // Parse parameters from JSON body + if (body.find("\"scale\"") != std::string::npos) { + size_t pos = body.find("\"scale\":") + 8; + newParams.scale = std::stof(body.substr(pos)); + } + if (body.find("\"octaves\"") != std::string::npos) { + size_t pos = body.find("\"octaves\":") + 10; + newParams.octaves = std::stoi(body.substr(pos)); + } + if (body.find("\"persistence\"") != std::string::npos) { + size_t pos = body.find("\"persistence\":") + 14; + newParams.persistence = std::stof(body.substr(pos)); + } + if (body.find("\"lacunarity\"") != std::string::npos) { + size_t pos = body.find("\"lacunarity\":") + 13; + newParams.lacunarity = std::stof(body.substr(pos)); + } + if (body.find("\"elevation\"") != std::string::npos) { + size_t pos = body.find("\"elevation\":") + 12; + newParams.elevation = std::stof(body.substr(pos)); + } + if (body.find("\"waterLevel\"") != std::string::npos) { + size_t pos = body.find("\"waterLevel\":") + 13; + newParams.waterLevel = std::stof(body.substr(pos)); + } + if (body.find("\"seed\"") != std::string::npos) { + size_t pos = body.find("\"seed\":") + 7; + newParams.seed = std::stoul(body.substr(pos)); + } + + { + std::lock_guard lock(paramsMutex); + currentParams = newParams; + } + + return std::make_pair(200, std::basic_string("{\"status\":\"success\"}")); + } catch (const std::exception& e) { + return std::make_pair(400, std::basic_string("{\"error\":\"Invalid parameters\"}")); + } + } + return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); + }); + + // Mode switching endpoint + server.addRoute("/api/switch-mode", [](const std::string& method, const std::string& body) { + if (method == "POST") { + std::lock_guard lock(paramsMutex); + if (currentParams.mode == "gradient") { + currentParams.mode = "terrain"; + } else { + currentParams.mode = "gradient"; + } + + std::string response = "{\"status\":\"success\", \"mode\":\"" + currentParams.mode + "\"}"; + return std::make_pair(200, response); + } + return std::make_pair(405, std::basic_string("Method Not Allowed")); + }); + + // Current mode endpoint + server.addRoute("/api/current-mode", [](const std::string& method, const std::string& body) { + if (method == "GET") { + std::lock_guard lock(paramsMutex); + std::string response = "{\"mode\":\"" + currentParams.mode + "\"}"; + return std::make_pair(200, response); + } + return std::make_pair(405, std::basic_string("Method Not Allowed")); + }); // Add timing stats endpoint server.addRoute("/api/timing-stats", [](const std::string& method, const std::string& body) { if (method == "GET") { return std::make_pair(200, getTimingStatsJSON()); } - return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); + return std::make_pair(405, std::basic_string("Method Not Allowed")); }); - // Add mode switching endpoint for -all mode - if (mode == "all") { - server.addRoute("/api/switch-mode", [](const std::string& method, const std::string& body) { - if (method == "POST") { - //TODO - return std::make_pair(200, std::basic_string("{\"status\":\"success\", \"mode\":\"switched\"}")); - } - return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); - }); - - server.addRoute("/api/current-mode", [](const std::string& method, const std::string& body) { - if (method == "GET") { - return std::make_pair(200, std::basic_string("{\"mode\":\"live\"}")); - } - return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); - }); - } + // Add clear stats endpoint + server.addRoute("/api/clear-stats", [](const std::string& method, const std::string& body) { + if (method == "POST") { + FunctionTimer::clearStats(); + return std::make_pair(200, std::basic_string("{\"status\":\"success\"}")); + } + return std::make_pair(405, std::basic_string("{\"error\":\"Method Not Allowed\"}")); + }); if (!server.start()) { std::cerr << "Failed to start server on port " << port << std::endl; @@ -259,16 +419,11 @@ int main(int argc, char* argv[]) { std::cout << "Server running on http://localhost:" << port << std::endl; std::cout << "Web root: " << webRoot << std::endl; - std::cout << "Mode: " << mode << std::endl; - std::cout << "Live stream available at /api/live-stream" << std::endl; + std::cout << "Mode: " << mode << " (Live Streaming)" << std::endl; + std::cout << "Live stream available at /stream.mjpg" << std::endl; + std::cout << "Single frames available at /api/frame" << std::endl; std::cout << "Timing stats available at /api/timing-stats" << std::endl; - if (mode == "all") { - std::cout << "Mode switching available at /api/switch-mode" << std::endl; - } - - std::cout << "Press Ctrl+C to stop the server" << std::endl; - server.handleRequests(); // Cleanup diff --git a/web/index.html b/web/index.html index 17ae60f..fece022 100644 --- a/web/index.html +++ b/web/index.html @@ -44,6 +44,6 @@ - + \ No newline at end of file diff --git a/web/stream.js b/web/stream.js index 589ca00..55e5af4 100644 --- a/web/stream.js +++ b/web/stream.js @@ -9,6 +9,9 @@ const ctx = canvas.getContext('2d'); const fpsCounter = document.getElementById('fpsCounter'); const frameCounter = document.getElementById('frameCounter'); +// Image data buffer for direct pixel manipulation +let imageData = ctx.createImageData(canvas.width, canvas.height); + function toggleStream() { const button = document.getElementById('streamBtn'); @@ -31,7 +34,7 @@ function startStream() { lastFrameTime = performance.now(); // Start the stream loop - streamInterval = setInterval(fetchFrame, 1000 / 30); // Start with 30 FPS + streamInterval = setInterval(fetchFrame, 1000 / 30); } function stopStream() { @@ -53,14 +56,15 @@ async function fetchFrame() { if (!isStreaming) return; try { - const response = await fetch('/api/live-stream'); - const data = await response.json(); - - if (data.frame_available) { - // In a real implementation, you'd decode the frame data and draw it - // For now, we'll simulate by generating a pattern based on time - drawSimulatedFrame(); - updateFrameCounter(); + const response = await fetch('/api/frame'); + if (response.ok) { + const arrayBuffer = await response.arrayBuffer(); + const rgbData = new Uint8Array(arrayBuffer); + + if (rgbData.length === 512 * 512 * 3) { + drawRGBFrame(rgbData); + updateFrameCounter(); + } } } catch (error) { console.error('Error fetching frame:', error); @@ -68,6 +72,20 @@ async function fetchFrame() { } } +function drawRGBFrame(rgbData) { + const data = imageData.data; + + // Convert RGB to RGBA + for (let i = 0, j = 0; i < data.length; i += 4, j += 3) { + data[i] = rgbData[j]; // R + data[i + 1] = rgbData[j + 1]; // G + data[i + 2] = rgbData[j + 2]; // B + data[i + 3] = 255; // A + } + + ctx.putImageData(imageData, 0, 0); +} + function updateFrameCounter() { frameCount++; const now = performance.now();