611 lines
24 KiB
C++
611 lines
24 KiB
C++
#include <iostream>
|
|
#include <vector>
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include "../util/grid/grid3.hpp"
|
|
#include "../util/grid/g3_serialization.hpp"
|
|
#include "../util/output/bmpwriter.hpp"
|
|
#include "../util/output/frame.hpp"
|
|
#include "../util/timing_decorator.cpp"
|
|
#include "../util/noise/pnoise2.hpp"
|
|
|
|
#include "../imgui/imgui.h"
|
|
#include "../imgui/backends/imgui_impl_glfw.h"
|
|
#include "../imgui/backends/imgui_impl_opengl3.h"
|
|
#include <GLFW/glfw3.h>
|
|
#include "../stb/stb_image.h"
|
|
|
|
struct defaults {
|
|
int outWidth = 512;
|
|
int outHeight = 512;
|
|
int gridWidth = 64;
|
|
int gridHeight = 64;
|
|
int gridDepth = 64;
|
|
float fps = 30.0f;
|
|
PNoise2 noise = PNoise2(42);
|
|
};
|
|
|
|
std::mutex PreviewMutex;
|
|
GLuint textu = 0;
|
|
bool textureInitialized = false;
|
|
bool updatePreview = false;
|
|
bool previewRequested = false;
|
|
|
|
struct Shared {
|
|
std::mutex mutex;
|
|
VoxelGrid grid;
|
|
};
|
|
|
|
void setup(defaults config, VoxelGrid& grid) {
|
|
uint8_t threshold = 0.1 * 255;
|
|
grid.resize(config.gridWidth, config.gridHeight, config.gridDepth);
|
|
std::cout << "Generating grid of size " << config.gridWidth << "x" << config.gridHeight << "x" << config.gridDepth << std::endl;
|
|
for (int z = 0; z < config.gridDepth; ++z) {
|
|
if (z % 64 == 0) {
|
|
std::cout << "Processing layer " << z << " of " << config.gridDepth << std::endl;
|
|
}
|
|
|
|
for (int y = 0; y < config.gridHeight; ++y) {
|
|
for (int x = 0; x < config.gridWidth; ++x) {
|
|
uint8_t r = config.noise.permute(Vec3f(static_cast<float>(x) / config.gridWidth / 64, static_cast<float>(y) / config.gridHeight / 64, static_cast<float>(z) / config.gridDepth / 64)) * 255;
|
|
uint8_t g = config.noise.permute(Vec3f(static_cast<float>(x) / config.gridWidth / 32, static_cast<float>(y) / config.gridHeight / 32, static_cast<float>(z) / config.gridDepth / 32)) * 255;
|
|
uint8_t b = config.noise.permute(Vec3f(static_cast<float>(x) / config.gridWidth / 16, static_cast<float>(y) / config.gridHeight / 16, static_cast<float>(z) / config.gridDepth / 16)) * 255;
|
|
uint8_t a = config.noise.permute(Vec3f(static_cast<float>(x) / config.gridWidth / 8 , static_cast<float>(y) / config.gridHeight / 8 , static_cast<float>(z) / config.gridDepth / 8)) * 255;
|
|
//Vec4ui8 noisecolor = config.noise.permuteColor(Vec3f( static_cast<float>(x) / 64, static_cast<float>(y) / 64, static_cast<float>(z) / 64));
|
|
if (a > threshold) {
|
|
//std::cout << "setting a position" << std::endl;
|
|
grid.set(Vec3i(x, y, z), true, Vec3ui8(r,g,b));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
std::cout << "Noise grid generation complete!" << std::endl;
|
|
grid.serializeToFile("output/gridsave.ygg3");
|
|
grid.printStats();
|
|
}
|
|
|
|
void livePreview(VoxelGrid& grid, defaults& config, const Camera& cam) {
|
|
std::lock_guard<std::mutex> lock(PreviewMutex);
|
|
updatePreview = true;
|
|
frame currentPreviewFrame = grid.renderFrame(cam, Vec2i(config.outWidth, config.outHeight), frame::colormap::RGB);
|
|
|
|
glGenTextures(1, &textu);
|
|
glBindTexture(GL_TEXTURE_2D, textu);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
|
|
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
|
|
glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
|
|
|
|
glBindTexture(GL_TEXTURE_2D, textu);
|
|
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, currentPreviewFrame.getWidth(), currentPreviewFrame.getHeight(),
|
|
0, GL_RGB, GL_UNSIGNED_BYTE, currentPreviewFrame.getData().data());
|
|
|
|
updatePreview = false;
|
|
textureInitialized = true;
|
|
}
|
|
|
|
bool savePreview(VoxelGrid& grid, defaults& config, const Camera& cam) {
|
|
TIME_FUNCTION;
|
|
|
|
std::vector<uint8_t> renderBuffer;
|
|
size_t width = config.outWidth;
|
|
size_t height = config.outHeight;
|
|
|
|
// Render the view
|
|
frame output = grid.renderFrame(cam, Vec2i(config.outWidth, config.outHeight), frame::colormap::RGB);
|
|
//grid.renderOut(renderBuffer, width, height, cam);
|
|
|
|
// Save to BMP
|
|
bool success = BMPWriter::saveBMP("output/save.bmp", output);
|
|
//bool success = BMPWriter::saveBMP(filename, renderBuffer, width, height);
|
|
|
|
// if (success) {
|
|
// std::cout << "Saved: " << filename << std::endl;
|
|
// } else {
|
|
// std::cout << "Failed to save: " << filename << std::endl;
|
|
// }
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
static void glfw_error_callback(int error, const char* description)
|
|
{
|
|
fprintf(stderr, "GLFW Error %d: %s\n", error, description);
|
|
}
|
|
|
|
int main() {
|
|
glfwSetErrorCallback(glfw_error_callback);
|
|
if (!glfwInit()) {
|
|
std::cerr << "gui stuff is dumb in c++." << std::endl;
|
|
glfwTerminate();
|
|
return 1;
|
|
}
|
|
// COPIED VERBATIM FROM IMGUI.
|
|
#if defined(IMGUI_IMPL_OPENGL_ES2)
|
|
// GL ES 2.0 + GLSL 100 (WebGL 1.0)
|
|
const char* glsl_version = "#version 100";
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
#elif defined(IMGUI_IMPL_OPENGL_ES3)
|
|
// GL ES 3.0 + GLSL 300 es (WebGL 2.0)
|
|
const char* glsl_version = "#version 300 es";
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
#elif defined(__APPLE__)
|
|
// GL 3.2 + GLSL 150
|
|
const char* glsl_version = "#version 150";
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // Required on Mac
|
|
#else
|
|
// GL 3.0 + GLSL 130
|
|
const char* glsl_version = "#version 130";
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
//glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // 3.2+ only
|
|
//glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // 3.0+ only
|
|
#endif
|
|
|
|
bool application_not_closed = true;
|
|
GLFWwindow* window = glfwCreateWindow((int)(1280), (int)(800), "voxelgrid live renderer", nullptr, nullptr);
|
|
if (window == nullptr) {
|
|
glfwTerminate();
|
|
return 1;
|
|
}
|
|
glfwMakeContextCurrent(window);
|
|
glfwSwapInterval(1);
|
|
IMGUI_CHECKVERSION();
|
|
ImGui::CreateContext();
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
(void)io;
|
|
io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;
|
|
ImGui::StyleColorsDark();
|
|
ImGuiStyle& style = ImGui::GetStyle();
|
|
ImGui_ImplGlfw_InitForOpenGL(window, true);
|
|
|
|
#ifdef __EMSCRIPTEN__
|
|
ImGui_ImplGlfw_InstallEmscriptenCallbacks(window, "#canvas");
|
|
#endif
|
|
ImGui_ImplOpenGL3_Init(glsl_version);
|
|
|
|
bool show_demo_window = true;
|
|
bool show_another_window = false;
|
|
ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);
|
|
|
|
defaults config;
|
|
VoxelGrid grid;
|
|
bool gridInitialized = false;
|
|
auto supposedGrid = VoxelGrid::deserializeFromFile("output/gridsave.ygg3");
|
|
if (supposedGrid) {
|
|
grid = std::move(*supposedGrid);
|
|
gridInitialized = true;
|
|
}
|
|
|
|
|
|
|
|
Camera cam(Vec3f(config.gridWidth/2.0f, config.gridHeight/2.0f, config.gridDepth/2.0f), Vec3f(0,0,1), Vec3f(0,1,0), 80);
|
|
|
|
// Variables for camera sliders
|
|
float camX = 0.0f;
|
|
float camY = 0.0f;
|
|
float camZ = 0.0f;
|
|
float camvX = 0.f;
|
|
float camvY = 0.f;
|
|
float camvZ = 0.f;
|
|
//float camYaw = 0.0f;
|
|
//float camPitch = 0.0f;
|
|
bool autoRotate = false; // Toggle for auto-rotation
|
|
bool autoRotateView = false; // Toggle for auto-rotation of the view only
|
|
float rotationSpeedX = 0.1f; // Speed for X rotation
|
|
float rotationSpeedY = 0.07f; // Speed for Y rotation
|
|
float rotationSpeedZ = 0.05f; // Speed for Z rotation
|
|
float autoRotationTime = 0.0f; // Timer for auto-rotation
|
|
Vec3f initialViewDir = Vec3f(0, 0, 1); // Initial view direction
|
|
float rotationRadius = 50.0f; // Distance from center for rotation
|
|
float yawSpeed = 0.5f; // Horizontal rotation speed (degrees per second)
|
|
float pitchSpeed = 0.3f; // Vertical rotation speed
|
|
float rollSpeed = 0.2f; // Roll rotation speed (optional)
|
|
float autoRotationAngle = 0.0f; // Accumulated rotation angle
|
|
Vec3f initialUpDir = Vec3f(0, 1, 0); // Initial up direction
|
|
|
|
// Variables for framerate limiting
|
|
const double targetFrameTime = 1.0 / config.fps; // 30 FPS
|
|
double lastFrameTime = glfwGetTime();
|
|
double accumulator = 0.0;
|
|
|
|
// For camera movement
|
|
bool cameraMoved = false;
|
|
double lastUpdateTime = glfwGetTime();
|
|
|
|
while (!glfwWindowShouldClose(window)) {
|
|
double currentTime = glfwGetTime();
|
|
double deltaTime = currentTime - lastFrameTime;
|
|
lastFrameTime = currentTime;
|
|
|
|
// Accumulate time
|
|
accumulator += deltaTime;
|
|
|
|
// Limit framerate
|
|
if (accumulator < targetFrameTime) {
|
|
std::this_thread::sleep_for(std::chrono::duration<double>(targetFrameTime - accumulator));
|
|
currentTime = glfwGetTime();
|
|
accumulator = targetFrameTime;
|
|
}
|
|
|
|
glfwPollEvents();
|
|
|
|
// Start the Dear ImGui frame
|
|
ImGui_ImplOpenGL3_NewFrame();
|
|
ImGui_ImplGlfw_NewFrame();
|
|
ImGui::NewFrame();
|
|
|
|
{
|
|
ImGui::Begin("settings");
|
|
|
|
if(ImGui::CollapsingHeader("output", ImGuiTreeNodeFlags_DefaultOpen)) {
|
|
ImGui::SliderInt("Width", &config.outWidth, 256, 4096);
|
|
ImGui::SliderInt("Height", &config.outHeight, 256, 4096);
|
|
}
|
|
|
|
if (ImGui::CollapsingHeader("Grid Settings", ImGuiTreeNodeFlags_DefaultOpen)) {
|
|
ImGui::SliderInt("#Width", &config.gridWidth, 64, 512);
|
|
ImGui::SliderInt("#Height", &config.gridHeight, 64, 512);
|
|
ImGui::SliderInt("#Depth", &config.gridDepth, 64, 512);
|
|
}
|
|
|
|
ImGui::Separator();
|
|
|
|
if (ImGui::Button("Generate Grid")) {
|
|
setup(config, grid);
|
|
gridInitialized = true;
|
|
// Reset camera to center of grid
|
|
camX = config.gridWidth / 2.0f;
|
|
camY = config.gridHeight / 2.0f;
|
|
camZ = config.gridDepth / 2.0f;
|
|
//camYaw = 0.0f;
|
|
//camPitch = 0.0f;
|
|
|
|
// Update camera position
|
|
cam.posfor.origin = Vec3f(camX, camY, camZ);
|
|
cam.posfor.direction = Vec3f(camvX, camvY, camvZ);
|
|
// cam.rotateYaw(camYaw);
|
|
// cam.rotatePitch(camPitch);
|
|
|
|
savePreview(grid, config, cam);
|
|
cameraMoved = true; // Force preview update after generation
|
|
}
|
|
|
|
// Display camera controls
|
|
if (gridInitialized) {
|
|
ImGui::Separator();
|
|
ImGui::Text("Camera Controls:");
|
|
|
|
// Calculate max slider values based on grid size squared
|
|
float maxSliderValueX = config.gridWidth;
|
|
float maxSliderValueY = config.gridHeight;
|
|
float maxSliderValueZ = config.gridDepth;
|
|
float maxSliderValueRotation = 360.0f; // Degrees
|
|
|
|
ImGui::Text("Position (0 to grid size²):");
|
|
if (ImGui::SliderFloat("Camera X", &camX, 0.0f, maxSliderValueX)) {
|
|
cameraMoved = true;
|
|
cam.posfor.origin.x = camX;
|
|
}
|
|
if (ImGui::SliderFloat("Camera Y", &camY, 0.0f, maxSliderValueY)) {
|
|
cameraMoved = true;
|
|
cam.posfor.origin.y = camY;
|
|
}
|
|
if (ImGui::SliderFloat("Camera Z", &camZ, 0.0f, maxSliderValueZ)) {
|
|
cameraMoved = true;
|
|
cam.posfor.origin.z = camZ;
|
|
}
|
|
|
|
ImGui::Separator();
|
|
// ImGui::Text("Rotation (degrees):");
|
|
// if (ImGui::SliderFloat("Yaw", &camYaw, 0.0f, maxSliderValueRotation)) {
|
|
// cameraMoved = true;
|
|
// // Reset and reapply rotation
|
|
// // You might need to adjust this based on your Camera class implementation
|
|
// cam = Camera(config.gridWidth, Vec3f(camX, camY, camZ), Vec3f(0,1,0), 80);
|
|
// cam.rotateYaw(camYaw);
|
|
// cam.rotatePitch(camPitch);
|
|
// }
|
|
// if (ImGui::SliderFloat("Pitch", &camPitch, 0.0f, maxSliderValueRotation)) {
|
|
// cameraMoved = true;
|
|
// // Reset and reapply rotation
|
|
// cam = Camera(config.gridWidth, Vec3f(camX, camY, camZ), Vec3f(0,1,0), 80);
|
|
// cam.rotateYaw(camYaw);
|
|
// cam.rotatePitch(camPitch);
|
|
// }
|
|
ImGui::Text("View Direction:");
|
|
if (ImGui::SliderFloat("Camera View X", &camvX, -1.0f, 1.0f)) {
|
|
cameraMoved = true;
|
|
cam.posfor.direction.x = camvX;
|
|
}
|
|
if (ImGui::SliderFloat("Camera View Y", &camvY, -1.0f, 1.0f)) {
|
|
cameraMoved = true;
|
|
cam.posfor.direction.y = camvY;
|
|
}
|
|
if (ImGui::SliderFloat("Camera View Z", &camvZ, -1.0f, 1.0f)) {
|
|
cameraMoved = true;
|
|
cam.posfor.direction.z = camvZ;
|
|
}
|
|
|
|
ImGui::Separator();
|
|
ImGui::Text("Current Camera Position:");
|
|
ImGui::Text("X: %.2f, Y: %.2f, Z: %.2f",
|
|
cam.posfor.origin.x,
|
|
cam.posfor.origin.y,
|
|
cam.posfor.origin.z);
|
|
// ImGui::Text("Yaw: %.2f°, Pitch: %.2f°", camYaw, camPitch);
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
{
|
|
ImGui::Begin("Preview");
|
|
|
|
if (gridInitialized && textureInitialized) {
|
|
ImGui::Image((void*)(intptr_t)textu, ImVec2(config.outWidth, config.outHeight));
|
|
} else if (gridInitialized) {
|
|
ImGui::Text("Preview not generated yet");
|
|
} else {
|
|
ImGui::Text("No grid generated");
|
|
}
|
|
|
|
ImGui::End();
|
|
}
|
|
|
|
// Update preview if camera moved or enough time has passed
|
|
if (gridInitialized && !updatePreview) {
|
|
double timeSinceLastUpdate = currentTime - lastUpdateTime;
|
|
if (autoRotate) {
|
|
// Update rotation time
|
|
autoRotationTime += deltaTime;
|
|
|
|
// Calculate new view direction using spherical coordinates
|
|
// This creates smooth 360-degree rotation with different speeds
|
|
float angleX = autoRotationTime * rotationSpeedX;
|
|
float angleY = autoRotationTime * rotationSpeedY;
|
|
float angleZ = autoRotationTime * rotationSpeedZ;
|
|
|
|
// Create rotation matrix or calculate new direction
|
|
// Using simple parametric equation for a sphere
|
|
camvX = sinf(angleX) * cosf(angleY);
|
|
camvY = sinf(angleY) * sinf(angleZ);
|
|
camvZ = cosf(angleX) * cosf(angleZ);
|
|
|
|
// Normalize the direction vector (optional but good practice)
|
|
float length = sqrtf(camvX * camvX + camvY * camvY + camvZ * camvZ);
|
|
if (length > 0.001f) {
|
|
camvX /= length;
|
|
camvY /= length;
|
|
camvZ /= length;
|
|
}
|
|
|
|
// Update camera position to orbit around grid center
|
|
camX = config.gridWidth / 2.0f + rotationRadius * camvX;
|
|
camY = config.gridHeight / 2.0f + rotationRadius * camvY;
|
|
camZ = config.gridDepth / 2.0f + rotationRadius * camvZ;
|
|
|
|
// Update camera
|
|
cam.posfor.origin = Vec3f(camX, camY, camZ);
|
|
cam.posfor.direction = Vec3f(camvX, camvY, camvZ);
|
|
|
|
cameraMoved = true;
|
|
}
|
|
|
|
if (autoRotateView) {
|
|
// Update rotation angle based on time
|
|
autoRotationAngle += deltaTime;
|
|
|
|
// Calculate rotation angles (in radians)
|
|
float yaw = autoRotationAngle * yawSpeed * (3.14159f / 180.0f); // Convert to radians
|
|
float pitch = sinf(autoRotationAngle * 0.7f) * pitchSpeed * (3.14159f / 180.0f);
|
|
float roll = sinf(autoRotationAngle * 0.3f) * rollSpeed * (3.14159f / 180.0f);
|
|
|
|
// Start with forward direction
|
|
Vec3f forward = initialViewDir;
|
|
|
|
// Apply yaw rotation (around Y axis)
|
|
float cosYaw = cosf(yaw);
|
|
float sinYaw = sinf(yaw);
|
|
Vec3f tempForward;
|
|
tempForward.x = forward.x * cosYaw + forward.z * sinYaw;
|
|
tempForward.y = forward.y;
|
|
tempForward.z = -forward.x * sinYaw + forward.z * cosYaw;
|
|
forward = tempForward;
|
|
|
|
// Apply pitch rotation (around X axis)
|
|
float cosPitch = cosf(pitch);
|
|
float sinPitch = sinf(pitch);
|
|
tempForward.x = forward.x;
|
|
tempForward.y = forward.y * cosPitch - forward.z * sinPitch;
|
|
tempForward.z = forward.y * sinPitch + forward.z * cosPitch;
|
|
forward = tempForward;
|
|
|
|
// Normalize the direction
|
|
float length = sqrtf(forward.x * forward.x + forward.y * forward.y + forward.z * forward.z);
|
|
if (length > 0.001f) {
|
|
forward.x /= length;
|
|
forward.y /= length;
|
|
forward.z /= length;
|
|
}
|
|
|
|
// Update view direction variables
|
|
camvX = forward.x;
|
|
camvY = forward.y;
|
|
camvZ = forward.z;
|
|
|
|
// Update camera
|
|
cam.posfor.direction = Vec3f(camvX, camvY, camvZ);
|
|
|
|
cameraMoved = true;
|
|
}
|
|
|
|
if (cameraMoved || timeSinceLastUpdate > 0.1) { // Update at least every 0.1 seconds
|
|
livePreview(grid, config, cam);
|
|
lastUpdateTime = currentTime;
|
|
cameraMoved = false;
|
|
}
|
|
}
|
|
|
|
|
|
ImGui::Separator();
|
|
ImGui::Text("Auto-Rotation:");
|
|
|
|
// Toggle button for auto-rotation
|
|
if (ImGui::Button(autoRotate ? "Stop Auto-Rotation" : "Start Auto-Rotation")) {
|
|
autoRotate = !autoRotate;
|
|
if (autoRotate) {
|
|
// Reset rotation time when starting
|
|
autoRotationTime = 0.0f;
|
|
// Save initial positions
|
|
initialViewDir = Vec3f(camvX, camvY, camvZ);
|
|
}
|
|
}
|
|
|
|
if (ImGui::Button(autoRotateView ? "Stop Looking Around" : "Start Looking Around")) {
|
|
autoRotateView = !autoRotateView;
|
|
if (autoRotateView) {
|
|
// Reset rotation when starting
|
|
autoRotationAngle = 0.0f;
|
|
// Save current view direction as initial
|
|
initialViewDir = Vec3f(camvX, camvY, camvZ);
|
|
}
|
|
}
|
|
|
|
if (autoRotate) {
|
|
ImGui::SameLine();
|
|
ImGui::Text("(Running)");
|
|
|
|
// Sliders to control rotation speeds
|
|
ImGui::SliderFloat("X Speed", &rotationSpeedX, 0.01f, 1.0f);
|
|
ImGui::SliderFloat("Y Speed", &rotationSpeedY, 0.01f, 1.0f);
|
|
ImGui::SliderFloat("Z Speed", &rotationSpeedZ, 0.01f, 1.0f);
|
|
|
|
// Slider for orbit radius
|
|
ImGui::SliderFloat("Orbit Radius", &rotationRadius, 10.0f, 200.0f);
|
|
|
|
// Reset button
|
|
if (ImGui::Button("Reset to Center")) {
|
|
camX = config.gridWidth / 2.0f;
|
|
camY = config.gridHeight / 2.0f;
|
|
camZ = config.gridDepth / 2.0f;
|
|
cam.posfor.origin = Vec3f(camX, camY, camZ);
|
|
cameraMoved = true;
|
|
}
|
|
}
|
|
|
|
if (autoRotateView) {
|
|
ImGui::SameLine();
|
|
ImGui::TextColored(ImVec4(0, 1, 0, 1), " ACTIVE");
|
|
|
|
// Show current view direction
|
|
ImGui::Text("Current View: (%.3f, %.3f, %.3f)", camvX, camvY, camvZ);
|
|
|
|
// Sliders to control rotation speeds
|
|
ImGui::SliderFloat("Yaw Speed", &yawSpeed, 0.1f, 5.0f, "%.2f deg/sec");
|
|
ImGui::SliderFloat("Pitch Speed", &pitchSpeed, 0.0f, 2.0f, "%.2f deg/sec");
|
|
ImGui::SliderFloat("Roll Speed", &rollSpeed, 0.0f, 1.0f, "%.2f deg/sec");
|
|
|
|
// Add some presets
|
|
ImGui::Separator();
|
|
ImGui::Text("Presets:");
|
|
|
|
if (ImGui::Button("Slow Pan")) {
|
|
yawSpeed = 0.3f;
|
|
pitchSpeed = 0.1f;
|
|
rollSpeed = 0.0f;
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Full Exploration")) {
|
|
yawSpeed = 0.8f;
|
|
pitchSpeed = 0.5f;
|
|
rollSpeed = 0.2f;
|
|
}
|
|
ImGui::SameLine();
|
|
if (ImGui::Button("Reset View")) {
|
|
// Reset to forward view
|
|
camvX = 0.0f;
|
|
camvY = 0.0f;
|
|
camvZ = 1.0f;
|
|
cam.posfor.direction = Vec3f(camvX, camvY, camvZ);
|
|
cameraMoved = true;
|
|
}
|
|
|
|
// Progress indicator
|
|
float progress = fmodf(autoRotationAngle * yawSpeed / 360.0f, 1.0f);
|
|
ImGui::ProgressBar(progress, ImVec2(-1, 0));
|
|
ImGui::Text("Full rotation progress: %.1f%%", progress * 100.0f);
|
|
}
|
|
|
|
if (ImGui::Button("Save Screenshot During Rotation")) {
|
|
if (autoRotate) {
|
|
// Generate filename with timestamp
|
|
auto now = std::chrono::system_clock::now();
|
|
auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
now.time_since_epoch()).count();
|
|
std::string filename = "output/rotation_frame_" +
|
|
std::to_string(timestamp) + ".bmp";
|
|
|
|
// Save current frame
|
|
frame output = grid.renderFrame(cam, Vec2i(config.outWidth, config.outHeight),
|
|
frame::colormap::RGB);
|
|
BMPWriter::saveBMP(filename.c_str(), output);
|
|
|
|
ImGui::OpenPopup("Screenshot Saved");
|
|
}
|
|
}
|
|
|
|
// Popup notification
|
|
if (ImGui::BeginPopupModal("Screenshot Saved", NULL,
|
|
ImGuiWindowFlags_AlwaysAutoResize)) {
|
|
ImGui::Text("Screenshot saved during rotation!");
|
|
if (ImGui::Button("OK")) {
|
|
ImGui::CloseCurrentPopup();
|
|
}
|
|
ImGui::EndPopup();
|
|
}
|
|
// Reset accumulator for next frame
|
|
accumulator -= targetFrameTime;
|
|
|
|
ImGui::Render();
|
|
int display_w, display_h;
|
|
glfwGetFramebufferSize(window, &display_w, &display_h);
|
|
glViewport(0, 0, display_w, display_h);
|
|
glClearColor(clear_color.x * clear_color.w, clear_color.y * clear_color.w, clear_color.z * clear_color.w, clear_color.w);
|
|
glClear(GL_COLOR_BUFFER_BIT);
|
|
|
|
// std::cout << "rendering" << std::endl;
|
|
ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
|
|
|
|
glfwSwapBuffers(window);
|
|
//mainlogicthread.join();
|
|
|
|
// std::cout << "swapping buffers" << std::endl;
|
|
}
|
|
|
|
|
|
// std::cout << "shutting down" << std::endl;
|
|
ImGui_ImplOpenGL3_Shutdown();
|
|
ImGui_ImplGlfw_Shutdown();
|
|
ImGui::DestroyContext();
|
|
|
|
|
|
// std::cout << "destroying" << std::endl;
|
|
glfwDestroyWindow(window);
|
|
if (textu != 0) {
|
|
glDeleteTextures(1, &textu);
|
|
textu = 0;
|
|
}
|
|
glfwTerminate();
|
|
// std::cout << "printing" << std::endl;
|
|
FunctionTimer::printStats(FunctionTimer::Mode::ENHANCED);
|
|
|
|
return 0;
|
|
} |