Camera quality of life changes

Sekqies · Sekqies · commit eb6e22c3657e · 2026-03-22T19:32:30.000-03:00
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
@@ -46,7 +46,7 @@ add_custom_command(
 )
 
 
-add_executable(complex-plotter WIN32 ${SOURCE_FILES} ${HEADER_SRC} "main.cpp" ${TRANSPILED_MAPPER_CPP})
+add_executable(complex-plotter ${SOURCE_FILES} ${HEADER_SRC} "main.cpp" ${TRANSPILED_MAPPER_CPP})
 
 if(NOT EMSCRIPTEN)
     find_package(OpenGL REQUIRED)
diff --git a/src/graphics/3d/camera_state.cpp b/src/graphics/3d/camera_state.cpp
@@ -1,7 +1,20 @@
 #include <graphics/3d/camera_state.h>
 CameraState camera_state;
 
+void update_camera_orbit(CameraState& state) {
+    state.position.x = state.orbit_target.x + state.orbit_radius * cos(glm::radians(state.yaw)) * cos(glm::radians(state.pitch));
+    state.position.y = state.orbit_target.y + state.orbit_radius * sin(glm::radians(state.pitch));
+    state.position.z = state.orbit_target.z + state.orbit_radius * sin(glm::radians(state.yaw)) * cos(glm::radians(state.pitch));
+    state.front = glm::normalize(state.orbit_target - state.position);
+    state.right = glm::normalize(glm::cross(state.front, state.world_up));
+    state.up = glm::normalize(glm::cross(state.right, state.front));
+}
+
 void update_camera_vectors(CameraState& state) {
+    if (state.is_orbit) {
+        update_camera_orbit(state);
+        return;
+    }
     glm::vec3 new_front;
     new_front.x = cos(glm::radians(state.yaw)) * cos(glm::radians(state.pitch));
     new_front.y = sin(glm::radians(state.pitch));
@@ -17,6 +30,20 @@ glm::mat4 get_view_matrix(const CameraState& state) {
 
 void process_keyboard(CameraState& state, int direction, float delta_time) {
     float velocity = state.movement_speed * delta_time;
+    if (state.is_orbit) {
+        glm::vec3 flat_front = glm::normalize(glm::vec3(state.front.x, 0.0f, state.front.z));
+        glm::vec3 flat_right = glm::normalize(glm::vec3(state.right.x, 0.0f, state.right.z));
+
+        if (direction == 0) state.orbit_target += flat_front * velocity;
+        if (direction == 1) state.orbit_target -= flat_front * velocity;
+        if (direction == 2) state.orbit_target -= flat_right * velocity;
+        if (direction == 3) state.orbit_target += flat_right * velocity;
+        if (direction == 4) state.orbit_target += state.world_up * velocity;
+        if (direction == 5) state.orbit_target -= state.world_up * velocity;
+
+        update_camera_vectors(state);
+        return;
+    }
     if (direction == 0) state.position += state.front * velocity;
     if (direction == 1) state.position -= state.front * velocity;
     if (direction == 2) state.position -= state.right * velocity;
@@ -39,6 +66,11 @@ void process_mouse_movement(CameraState& state, float x_offset, float y_offset,
 }
 
 void process_mouse_scroll(CameraState& state, float y_offset) {
+    if (state.is_orbit) {
+        state.orbit_radius -= (float)y_offset;
+        if (state.orbit_radius < 0.1f) state.orbit_radius = 0.1f;
+        update_camera_vectors(state);
+    }
     state.zoom -= (float)y_offset;
     if (state.zoom < 1.0f) state.zoom = 1.0f;
     if (state.zoom > 45.0f) state.zoom = 45.0f;
diff --git a/src/graphics/3d/camera_state.h b/src/graphics/3d/camera_state.h
@@ -14,17 +14,49 @@ struct CameraState {
     float yaw;
     float pitch;
     float movement_speed = 2.5f;
-    float mouse_sensitivity = 0.05f;
+    float mouse_sensitivity = 0.15f;
     float zoom = 45.0f;
 
+    bool is_orbit = true;
+    glm::vec3 orbit_target = glm::vec3(0.0, 0.0, 0.0);
+    float orbit_radius = 5.0;
+
     CameraState() {
-        glm::vec3 direction = glm::normalize(-position);
-        front = direction;
-        pitch = glm::degrees(asin(direction.y));
-        yaw = glm::degrees(atan2(direction.z, direction.x));
+        orbit_radius = glm::distance(position, orbit_target);
+
+        if (is_orbit) {
+            glm::vec3 dir = glm::normalize(position - orbit_target);
+            pitch = glm::degrees(asin(dir.y));
+            yaw = glm::degrees(atan2(dir.z, dir.x));
+            front = glm::normalize(orbit_target - position);
+            mouse_sensitivity = 0.15f;
+        }
+        else {
+            glm::vec3 direction = glm::normalize(orbit_target - position);
+            front = direction;
+            pitch = glm::degrees(asin(direction.y));
+            yaw = glm::degrees(atan2(direction.z, direction.x));
+            mouse_sensitivity = 0.05f;
+        }
+
         right = glm::normalize(glm::cross(front, world_up));
         up = glm::normalize(glm::cross(right, front));
     }
+
+    void switch_to_orbit() {
+        is_orbit = true;
+        orbit_target = position + front * orbit_radius;
+
+        glm::vec3 dir = glm::normalize(position - orbit_target);
+        pitch = glm::degrees(asin(dir.y));
+        yaw = glm::degrees(atan2(dir.z, dir.x));
+    }
+
+    void switch_to_free() {
+        is_orbit = false;
+        pitch = glm::degrees(asin(front.y));
+        yaw = glm::degrees(atan2(front.z, front.x));
+    }
 };
 
 extern CameraState camera_state;
diff --git a/src/graphics/ui.cpp b/src/graphics/ui.cpp
@@ -3,6 +3,7 @@
 #include <transformer/transformer.h>
 #include <graphics/graphics.h>
 #include <interactions/interactions.h>
+#include <graphics/3d/camera_state.h>
 #include <string>
 #include <iostream>
 
@@ -304,12 +305,6 @@ void render_and_update(FunctionState& state, ViewState& view_state, unsigned int
             ImGui::Unindent();
         }
     }
-    if (UI::CollapsingHeader("3D Keybinds")) {
-        ImGui::BulletText("WASD: Move");
-        ImGui::BulletText("Right click + Drag: Move camera");
-        ImGui::BulletText("Shift/Spacebar: Go up");
-        ImGui::BulletText("Ctrl: Go down");
-    }
     if (UI::CollapsingHeader("Help & Keybinds")) {
         ImGui::BulletText("Left Click + Drag: Pan Camera");
         ImGui::BulletText("Scroll Wheel: Zoom");
@@ -446,34 +441,86 @@ void render_and_update(FunctionState& state, ViewState& view_state, unsigned int
         }
     }
     if (view_state.is_high_precision) {
-                ImGui::Begin("High Precision Render", &view_state.is_high_precision, ImGuiWindowFlags_AlwaysAutoResize);
-                if (view_state.hp_texture != 0) {
-                    ImGui::Text("Resolution: %dx%d", view_state.hp_width, view_state.hp_height);
-                    if (view_state.is_rendering_hp) {
-                        glBindTexture(GL_TEXTURE_2D, view_state.hp_texture);
-                        glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view_state.hp_width, view_state.hp_height, GL_RGBA, GL_UNSIGNED_BYTE, view_state.hp_cpu_buffer.data());
-
-                        float progress = (float)view_state.hp_rows_completed / (float)view_state.hp_height;
-                        ImGui::ProgressBar(progress, ImVec2(-1.0f, 0.0f), "Loading...");
-                    }
-                    else {
-                        if (ImGui::Button("Save to PNG")) {
-                            std::string filename = "high_precision_" + std::to_string(view_state.hp_width) + "x" + std::to_string(view_state.hp_height) + ".png";
-                            export_plot_to_png(view_state.hp_cpu_buffer.data(),view_state.hp_width,view_state.hp_height,"complex-plot-high-precision.png");
-                            view_state.show_export_success = true; 
-                        }
-                    }
-                    ImGui::Image(
-                        (void*)(intptr_t)view_state.hp_texture,
-                        ImVec2((float)view_state.hp_width, (float)view_state.hp_height),
-                        ImVec2(0, 0),
-                        ImVec2(1, 1)
-                    );
-                }
-                else {
-                    ImGui::Text("Initializing...");
+        ImGui::Begin("High Precision Render", &view_state.is_high_precision, ImGuiWindowFlags_AlwaysAutoResize);
+        if (view_state.hp_texture != 0) {
+            ImGui::Text("Resolution: %dx%d", view_state.hp_width, view_state.hp_height);
+            if (view_state.is_rendering_hp) {
+                glBindTexture(GL_TEXTURE_2D, view_state.hp_texture);
+                glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, view_state.hp_width, view_state.hp_height, GL_RGBA, GL_UNSIGNED_BYTE, view_state.hp_cpu_buffer.data());
+
+                float progress = (float)view_state.hp_rows_completed / (float)view_state.hp_height;
+                ImGui::ProgressBar(progress, ImVec2(-1.0f, 0.0f), "Loading...");
+            }
+            else {
+                if (ImGui::Button("Save to PNG")) {
+                    std::string filename = "high_precision_" + std::to_string(view_state.hp_width) + "x" + std::to_string(view_state.hp_height) + ".png";
+                    export_plot_to_png(view_state.hp_cpu_buffer.data(),view_state.hp_width,view_state.hp_height,"complex-plot-high-precision.png");
+                    view_state.show_export_success = true; 
                 }
-                ImGui::End(); 
             }
+            ImGui::Image(
+                (void*)(intptr_t)view_state.hp_texture,
+                ImVec2((float)view_state.hp_width, (float)view_state.hp_height),
+                ImVec2(0, 0),
+                ImVec2(1, 1)
+            );
+        }
+        else {
+            ImGui::Text("Initializing...");
+        }
+        ImGui::End(); 
+    }
+    if (view_state.is_3d) {
+        ImGui::Begin("3D Settings");
+        ImGui::Text("Height = ");
+        if (ImGui::IsItemHovered()) ImGui::SetTooltip("Height function. 'z' evaluates on the output of f(z). Defaults to mag(z).");
+        ImGui::SameLine();
+        bool height_pressed_enter = ImGui::InputText("##height_source",
+            &state.height_expression,
+            ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_CallbackAlways,
+            FunctionInputCallback,
+            (void*)&state);
+        ImGui::SameLine();
+        if (UI::Button("Compile##Height")) {
+            height_pressed_enter = true;
+        }
+        if (ImGui::IsItemHovered()) {
+            ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
+        }
+        if (height_pressed_enter) {
+            state.needs_height_reparse = true;
+        }
+        ImGui::Spacing();
+        if (UI::CollapsingHeader("Camera Settings"), nullptr, ImGuiWindowFlags_AlwaysAutoResize) {
+            ImGui::Text("Camera Mode:");
+            ImGui::SameLine();
+
+            if (UI::RadioButton("Free", !camera_state.is_orbit)) {
+                camera_state.is_orbit = false;
+                camera_state.switch_to_free();
+            }
+            ImGui::SameLine();
+            if (UI::RadioButton("Orbit", camera_state.is_orbit)) {
+                camera_state.is_orbit = true;
+                camera_state.switch_to_orbit();
+                update_camera_vectors(camera_state);
+            }
+            if (UI::Button("Snap camera to origin")) {
+                CameraState new_camerastate;
+                new_camerastate.is_orbit = camera_state.is_orbit;
+                camera_state = new_camerastate;
+
+            }
+        }
+        if (UI::CollapsingHeader("3D Keybinds")) {
+            ImGui::BulletText("WASD: Move");
+            ImGui::BulletText("Right click + Drag: Move camera");
+            ImGui::BulletText("Shift/Spacebar: Go up");
+            ImGui::BulletText("Ctrl: Go down");
+        }
+
+
+        ImGui::End();
+    }
     ImGui::End();
 }
diff --git a/src/graphics/ui.h b/src/graphics/ui.h
@@ -19,6 +19,8 @@ typedef struct FunctionState {
 	bool is_interpreted = true;
 	bool is_3d = false;
 	bool show_grid = true;
+	std::string height_expression = "mag(z)";
+	bool needs_height_reparse = true;
 } FunctionState;
 
 void render(FunctionState& state, unsigned int& op_tex, unsigned int& const_tex, Shader& interpreter_shader);
diff --git a/src/interactions/interactions.cpp b/src/interactions/interactions.cpp
@@ -11,6 +11,11 @@ void scroll_callback(GLFWwindow* window, const double xoffset, const double yoff
     ViewState* state = get_state(window);
     if (ImGui::GetIO().WantCaptureMouse || !state) return;
 
+    if (state->is_3d && camera_state.is_orbit) {
+        process_mouse_scroll(camera_state, yoffset);
+        return;
+    }
+
     double x, y;
     glfwGetCursorPos(window, &x, &y);
 
@@ -30,7 +35,7 @@ void scroll_callback(GLFWwindow* window, const double xoffset, const double yoff
         state->hp_range = state->hp_range / hp_zoom_factor;
     }
 
-    if (state->is_3d) return;
+    //if (state->is_3d) return;
 
     big_float hp_range_diff = prev_hp_range -  state->hp_range;
     state->hp_shift.x = state->hp_shift.x + hp_range_diff * hp_u;
@@ -45,6 +50,7 @@ void mouse_button_callback(GLFWwindow* window, const int button, int action, int
     ViewState* state = get_state(window);
     if (!state || ImGui::GetIO().WantCaptureMouse) return;
 
+
     if (button != GLFW_MOUSE_BUTTON_LEFT && button != GLFW_MOUSE_BUTTON_RIGHT) return;
 
     if (action == GLFW_RELEASE) {
@@ -71,6 +77,11 @@ void cursor_position_callback(GLFWwindow* window, const double xpos, const doubl
         return;
     }
 
+    if (state->is_3d) {
+        process_mouse_movement(camera_state,delta.x, -delta.y);
+        return;
+    }
+
     float inv_height = 1.0f / state->height;
     big_float hp_inv_height = big_float(inv_height);
     big_float hp_scale = state->hp_range * hp_inv_height;
diff --git a/src/main.cpp b/src/main.cpp
@@ -72,12 +72,43 @@ struct AppContext {
 	bool pressing_t;
 };
 
+void update_height_function(AppContext* ctx) {
+	try {
+		std::vector<TokenOperator> height_stack = parser::parse(ctx->function_state->height_expression);
+		string height_glsl = stack_to_glsl_string(height_stack);
 
+		string injection_code = "vec2 _temp_z = z; z = func_value; vec2 _h_val = " + height_glsl + "; float height = _h_val.x; z = _temp_z;";
 
+		string vert_source_3d = get_source("shaders/plotter3d.vert");
+		vert_source_3d = build_shader_string(vert_source_3d, ctx->shader_program->fragment_source);
 
+		string target = "float height = length(func_value);";
+		size_t pos = vert_source_3d.find(target);
+		if (pos != string::npos) {
+			vert_source_3d.replace(pos, target.length(), injection_code);
+		}
+		else {
+			throw std::runtime_error("Could not find height target in vertex shader.");
+		}
+		const string frag_source_3d = get_source("shaders/plotter3d.frag");
 
+		ctx->shader_3d->compile(vert_source_3d, frag_source_3d);
+
+		ctx->compiled_shader_3d->prepare_source(vert_source_3d, frag_source_3d, true);
+
+		if (!ctx->function_state->is_interpreted) {
+			string main_expr_glsl = stack_to_glsl_string(parser::parse(ctx->function_state->expression));
+			ctx->compiled_shader_3d->compile(main_expr_glsl, true);
+		}
 
+		ctx->function_state->error_message = "";
+	}
+	catch (const std::exception& e) {
+		ctx->function_state->error_message = string("Height Function Error: ") + e.what();
+	}
 
+	ctx->function_state->needs_height_reparse = false;
+}
 
 void draw_scene(AppContext* ctx, float render_width, float render_height) {
 	Shader* current_shader = ctx->function_state->current_shader;
@@ -247,7 +278,10 @@ void main_loop_step(AppContext* ctx) {
 		render_and_update(*(ctx->function_state), *(ctx->view_state), stack_tbo_texture, constants_tbo_texture, *(ctx->shader_program), *(ctx->compiled_shader));
 	}
 
-	
+	if (ctx->function_state->needs_height_reparse) {
+		update_height_function(ctx);
+	}
+
 	draw_scene(ctx, ctx->view_state->width, ctx->view_state->height);
 
 	if (is_3d != ctx->view_state->is_3d) {

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,7 @@ add_custom_command(`
`46`	`46`	`)`
`47`	`47`
`48`	`48`
`49`		`-add_executable(complex-plotter WIN32 ${SOURCE_FILES} ${HEADER_SRC} "main.cpp" ${TRANSPILED_MAPPER_CPP})`
	`49`	`+add_executable(complex-plotter ${SOURCE_FILES} ${HEADER_SRC} "main.cpp" ${TRANSPILED_MAPPER_CPP})`
`50`	`50`
`51`	`51`	`if(NOT EMSCRIPTEN)`
`52`	`52`	`find_package(OpenGL REQUIRED)`