/* gtkmm example Copyright (C) 2025 gtkmm development team * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License along * with this program; if not, see . */ #include "exampleglarea.h" #include "shaders.h" // Include for shader source strings // epoxy/gl.h is already included in exampleglarea.h, no need to include again here unless specifically needed later. // #include #include // For standard input/output operations #include // For mathematical functions #include // For GLM matrix transformations #include // For glm::value_ptr #include // For std::vector // Initialize the static constant arrays with the actual data // No change needed here, as they are now correctly declared as static const in the header. const GLfloat ExampleGLArea::m_default_cube_vertex_data[24 * 8] = { // Front face (Front: Z=0.5) - Bright Green -0.5f, -0.5f, 0.5f, 1.0f, COLOR_FRONT.r, COLOR_FRONT.g, COLOR_FRONT.b, COLOR_FRONT.a, 0.5f, -0.5f, 0.5f, 1.0f, COLOR_FRONT.r, COLOR_FRONT.g, COLOR_FRONT.b, COLOR_FRONT.a, 0.5f, 0.5f, 0.5f, 1.0f, COLOR_FRONT.r, COLOR_FRONT.g, COLOR_FRONT.b, COLOR_FRONT.a, -0.5f, 0.5f, 0.5f, 1.0f, COLOR_FRONT.r, COLOR_FRONT.g, COLOR_FRONT.b, COLOR_FRONT.a, // Back face (Back: Z=-0.5) - Yellow -0.5f, -0.5f, -0.5f, 1.0f, COLOR_BACK.r, COLOR_BACK.g, COLOR_BACK.b, COLOR_BACK.a, 0.5f, -0.5f, -0.5f, 1.0f, COLOR_BACK.r, COLOR_BACK.g, COLOR_BACK.b, COLOR_BACK.a, 0.5f, 0.5f, -0.5f, 1.0f, COLOR_BACK.r, COLOR_BACK.g, COLOR_BACK.b, COLOR_BACK.a, -0.5f, 0.5f, -0.5f, 1.0f, COLOR_BACK.r, COLOR_BACK.g, COLOR_BACK.b, COLOR_BACK.a, // Top face (Top: Y=0.5) - Light Blue -0.5f, 0.5f, 0.5f, 1.0f, COLOR_TOP.r, COLOR_TOP.g, COLOR_TOP.b, COLOR_TOP.a, 0.5f, 0.5f, 0.5f, 1.0f, COLOR_TOP.r, COLOR_TOP.g, COLOR_TOP.b, COLOR_TOP.a, 0.5f, 0.5f, -0.5f, 1.0f, COLOR_TOP.r, COLOR_TOP.g, COLOR_TOP.b, COLOR_TOP.a, -0.5f, 0.5f, -0.5f, 1.0f, COLOR_TOP.r, COLOR_TOP.g, COLOR_TOP.b, COLOR_TOP.a, // Bottom face (Bottom: Y=-0.5) - Purple -0.5f, -0.5f, -0.5f, 1.0f, COLOR_BOTTOM.r, COLOR_BOTTOM.g, COLOR_BOTTOM.b, COLOR_BOTTOM.a, 0.5f, -0.5f, -0.5f, 1.0f, COLOR_BOTTOM.r, COLOR_BOTTOM.g, COLOR_BOTTOM.b, COLOR_BOTTOM.a, 0.5f, -0.5f, 0.5f, 1.0f, COLOR_BOTTOM.r, COLOR_BOTTOM.g, COLOR_BOTTOM.b, COLOR_BOTTOM.a, -0.5f, -0.5f, 0.5f, 1.0f, COLOR_BOTTOM.r, COLOR_BOTTOM.g, COLOR_BOTTOM.b, COLOR_BOTTOM.a, // Right face (Right: X=0.5) - Red 0.5f, -0.5f, 0.5f, 1.0f, COLOR_RIGHT.r, COLOR_RIGHT.g, COLOR_RIGHT.b, COLOR_RIGHT.a, 0.5f, -0.5f, -0.5f, 1.0f, COLOR_RIGHT.r, COLOR_RIGHT.g, COLOR_RIGHT.b, COLOR_RIGHT.a, 0.5f, 0.5f, -0.5f, 1.0f, COLOR_RIGHT.r, COLOR_RIGHT.g, COLOR_RIGHT.b, COLOR_RIGHT.a, 0.5f, 0.5f, 0.5f, 1.0f, COLOR_RIGHT.r, COLOR_RIGHT.g, COLOR_RIGHT.b, COLOR_RIGHT.a, // Left face (Left: X=-0.5) - Dark Blue -0.5f, -0.5f, -0.5f, 1.0f, COLOR_LEFT.r, COLOR_LEFT.g, COLOR_LEFT.b, COLOR_LEFT.a, -0.5f, -0.5f, 0.5f, 1.0f, COLOR_LEFT.r, COLOR_LEFT.g, COLOR_LEFT.b, COLOR_LEFT.a, -0.5f, 0.5f, 0.5f, 1.0f, COLOR_LEFT.r, COLOR_LEFT.g, COLOR_LEFT.b, COLOR_LEFT.a, -0.5f, 0.5f, -0.5f, 1.0f, COLOR_LEFT.r, COLOR_LEFT.g, COLOR_LEFT.b, COLOR_LEFT.a }; const GLuint ExampleGLArea::m_default_cube_index_data[36] = { 0, 3, 2, 0, 2, 1, 4, 5, 6, 4, 6, 7, 8, 11, 10, 8, 10, 9, 12, 15, 14, 12, 14, 13, 16, 19, 18, 16, 18, 17, 20, 23, 22, 20, 22, 21 }; const GLuint ExampleGLArea::m_edge_index_data[12 * 2] = { 0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 4, 1, 5, 2, 6, 3, 7 }; // Constructor implementation ExampleGLArea::ExampleGLArea() { set_allowed_apis(Gdk::GLApi::GL); m_camera_position = glm::vec3(0.0f, 0.0f, 2.0f); m_camera_target = glm::vec3(0.0f, 0.0f, 0.0f); m_rotation_angles[0] = 327.479f; m_rotation_angles[1] = 142.582f; m_rotation_angles[2] = 0.0f; auto motion_controller = Gtk::EventControllerMotion::create(); motion_controller->signal_motion().connect(sigc::mem_fun(*this, &ExampleGLArea::on_mouse_motion)); add_controller(motion_controller); auto click_controller_middle = Gtk::GestureClick::create(); click_controller_middle->set_button(GDK_BUTTON_MIDDLE); click_controller_middle->signal_pressed().connect( [this](int /*n_press*/, double x, double y) { this->on_mouse_press(GDK_BUTTON_MIDDLE, x, y); } ); click_controller_middle->signal_released().connect(sigc::mem_fun(*this, &ExampleGLArea::on_mouse_release)); add_controller(click_controller_middle); auto click_controller_right = Gtk::GestureClick::create(); click_controller_right->set_button(GDK_BUTTON_SECONDARY); click_controller_right->signal_pressed().connect( [this](int /*n_press*/, double x, double y) { this->on_mouse_press(GDK_BUTTON_SECONDARY, x, y); } ); click_controller_right->signal_released().connect(sigc::mem_fun(*this, &ExampleGLArea::on_mouse_release)); add_controller(click_controller_right); auto scroll_controller = Gtk::EventControllerScroll::create(); scroll_controller->set_flags(Gtk::EventControllerScroll::Flags::VERTICAL); scroll_controller->signal_scroll().connect( [this](double /*dx*/, double dy) { return this->on_scroll(dy); }, false ); add_controller(scroll_controller); set_focusable(true); set_focus_on_click(true); } void ExampleGLArea::on_realize() { Gtk::GLArea::on_realize(); try { make_current(); throw_if_error(); init_buffers(); init_shaders(); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glClearColor(0.5f, 0.5f, 0.5f, 1.0f); } catch (const Gdk::GLError& gle) { std::cerr << "GLArea error on realize: " << gle.domain() << "-" << gle.code() << "-" << gle.what() << std::endl; } } void ExampleGLArea::on_unrealize() { try { make_current(); throw_if_error(); glBindVertexArray(m_vao); glDeleteBuffers(1, &m_position_buffer); glDeleteBuffers(1, &m_index_buffer); glDeleteBuffers(1, &m_edge_index_buffer); glDeleteProgram(m_program); glDeleteVertexArrays(1, &m_vao); } catch (const Gdk::GLError& gle) { std::cerr << "GLArea error on unrealize: " << gle.domain() << "-" << gle.code() << "-" << gle.what() << std::endl; } Gtk::GLArea::on_unrealize(); } bool ExampleGLArea::on_render(const Glib::RefPtr& /*context*/) { try { make_current(); throw_if_error(); glViewport(0, 0, get_width(), get_height()); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); draw_object(); glFlush(); return true; } catch (const Gdk::GLError& gle) { std::cerr << "GLArea error on render: " << gle.domain() << "-" << gle.code() << "-" << gle.what() << std::endl; return false; } } void ExampleGLArea::on_mouse_press(int button, double x, double y) { m_last_mouse_pos = glm::vec2(x, y); m_is_rotating = false; m_is_panning = false; if (button == GDK_BUTTON_MIDDLE) { m_is_rotating = true; } else if (button == GDK_BUTTON_SECONDARY) { m_is_panning = true; } grab_focus(); } void ExampleGLArea::on_mouse_release(int /*n_press*/, double /*x*/, double /*y*/) { m_is_rotating = false; m_is_panning = false; } void ExampleGLArea::on_mouse_motion(double x, double y) { if (m_is_rotating) { float delta_x = static_cast(x - m_last_mouse_pos.x); float delta_y = static_cast(y - m_last_mouse_pos.y); m_rotation_angles[1] += -delta_x * m_rotation_speed; m_rotation_angles[0] += -delta_y * m_rotation_speed; m_rotation_angles[0] = fmod(m_rotation_angles[0], 360.0f); m_rotation_angles[1] = fmod(m_rotation_angles[1], 360.0f); queue_draw(); } else if (m_is_panning) { float delta_x = static_cast(x - m_last_mouse_pos.x); float delta_y = static_cast(y - m_last_mouse_pos.y); float current_zoom_scale = m_camera_position.z / 2.0f; glm::vec3 camera_direction = glm::normalize(m_camera_target - m_camera_position); glm::vec3 world_up = glm::vec3(0.0f, 1.0f, 0.0f); glm::vec3 camera_right = glm::normalize(glm::cross(camera_direction, world_up)); glm::vec3 camera_up = glm::normalize(glm::cross(camera_right, camera_direction)); m_camera_position -= camera_right * delta_x * m_pan_speed * current_zoom_scale; m_camera_target -= camera_right * delta_x * m_pan_speed * current_zoom_scale; m_camera_position += camera_up * delta_y * m_pan_speed * current_zoom_scale; m_camera_target += camera_up * delta_y * m_pan_speed * current_zoom_scale; queue_draw(); } m_last_mouse_pos = glm::vec2(x, y); } bool ExampleGLArea::on_scroll(double double_y) { m_camera_position.z += static_cast(double_y) * m_zoom_speed; m_camera_position.z = glm::clamp(m_camera_position.z, 0.5f, 50.0f); queue_draw(); return true; } void ExampleGLArea::init_buffers() { glGenVertexArrays(1, &m_vao); glBindVertexArray(m_vao); if (m_position_buffer != 0) glDeleteBuffers(1, &m_position_buffer); if (m_index_buffer != 0) glDeleteBuffers(1, &m_index_buffer); if (m_edge_index_buffer != 0) glDeleteBuffers(1, &m_edge_index_buffer); glGenBuffers(1, &m_position_buffer); glBindBuffer(GL_ARRAY_BUFFER, m_position_buffer); glBufferData(GL_ARRAY_BUFFER, sizeof(m_default_cube_vertex_data), m_default_cube_vertex_data, GL_STATIC_DRAW); glEnableVertexAttribArray(0); glVertexAttribPointer(0, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 8, (void*)0); glEnableVertexAttribArray(1); glVertexAttribPointer(1, 4, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 8, (void*)(sizeof(GLfloat) * 4)); glGenBuffers(1, &m_index_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_default_cube_index_data), m_default_cube_index_data, GL_STATIC_DRAW); glGenBuffers(1, &m_edge_index_buffer); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_edge_index_buffer); glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(m_edge_index_data), m_edge_index_data, GL_STATIC_DRAW); glBindVertexArray(0); glBindBuffer(GL_ARRAY_BUFFER, 0); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); } GLuint ExampleGLArea::create_shader(GLenum type, const char* src) { GLuint shader = glCreateShader(type); glShaderSource(shader, 1, &src, nullptr); glCompileShader(shader); GLint status; glGetShaderiv(shader, GL_COMPILE_STATUS, &status); if (status == GL_FALSE) { GLint log_len; glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &log_len); std::vector buffer(log_len + 1); glGetShaderInfoLog(shader, log_len, nullptr, buffer.data()); std::cerr << "Shader compile failure (" << (type == GL_VERTEX_SHADER ? "vertex" : "fragment") << "):\n" << buffer.data() << std::endl; glDeleteShader(shader); return 0; } return shader; } void ExampleGLArea::init_shaders() { GLuint vertex_shader = create_shader(GL_VERTEX_SHADER, VERTEX_SHADER_SRC); GLuint fragment_shader = create_shader(GL_FRAGMENT_SHADER, FRAGMENT_SHADER_SRC); if (vertex_shader == 0 || fragment_shader == 0) { m_program = 0; return; } m_program = glCreateProgram(); glAttachShader(m_program, vertex_shader); glAttachShader(m_program, fragment_shader); glBindAttribLocation(m_program, 0, "in_position"); glBindAttribLocation(m_program, 1, "in_color"); glLinkProgram(m_program); GLint status; glGetProgramiv(m_program, GL_LINK_STATUS, &status); if (status == GL_FALSE) { GLint log_len; glGetProgramiv(m_program, GL_INFO_LOG_LENGTH, &log_len); std::vector buffer(log_len + 1); glGetProgramInfoLog(m_program, log_len, nullptr, buffer.data()); std::cerr << "Program linking failure:\n" << buffer.data() << std::endl; glDeleteProgram(m_program); m_program = 0; } else { m_mvp_location = glGetUniformLocation(m_program, "mvp"); m_use_vertex_color_location = glGetUniformLocation(m_program, "use_vertex_color"); m_line_color_uniform_location = glGetUniformLocation(m_program, "line_color_uniform"); } glDetachShader(m_program, vertex_shader); glDeleteShader(vertex_shader); glDetachShader(m_program, fragment_shader); glDeleteShader(fragment_shader); } glm::mat4 ExampleGLArea::compute_mvp() { glm::mat4 model = glm::mat4(1.0f); model = glm::rotate(model, glm::radians(m_rotation_angles[0]), glm::vec3(1.0f, 0.0f, 0.0f)); model = glm::rotate(model, glm::radians(m_rotation_angles[1]), glm::vec3(0.0f, 1.0f, 0.0f)); model = glm::rotate(model, glm::radians(m_rotation_angles[2]), glm::vec3(0.0f, 0.0f, 1.0f)); glm::mat4 view = glm::lookAt( m_camera_position, m_camera_target, glm::vec3(0.0f, 1.0f, 0.0f) ); float view_height = 1.0f * m_camera_position.z; float aspect_ratio = (float)get_width() / (float)get_height(); float view_width = view_height * aspect_ratio; glm::mat4 projection = glm::ortho(-view_width / 2.0f, view_width / 2.0f, -view_height / 2.0f, view_height / 2.0f, 0.1f, 100.0f); return projection * view * model; } void ExampleGLArea::draw_object() { if (m_program == 0) return; glm::mat4 mvp = compute_mvp(); glUseProgram(m_program); glUniformMatrix4fv(m_mvp_location, 1, GL_FALSE, glm::value_ptr(mvp)); glBindVertexArray(m_vao); glUniform1i(m_use_vertex_color_location, 1); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glDepthMask(GL_TRUE); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_index_buffer); glDrawElements(GL_TRIANGLES, sizeof(m_default_cube_index_data) / sizeof(GLuint), GL_UNSIGNED_INT, 0); glDepthMask(GL_FALSE); glDisable(GL_CULL_FACE); glLineWidth(3.0f); glUniform1i(m_use_vertex_color_location, 0); glUniform4f(m_line_color_uniform_location, 1.0f, 1.0f, 1.0f, 1.0f); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_edge_index_buffer); glDrawElements(GL_LINES, sizeof(m_edge_index_data) / sizeof(GLuint), GL_UNSIGNED_INT, 0); glDepthMask(GL_TRUE); glEnable(GL_CULL_FACE); glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glBindVertexArray(0); glUseProgram(0); }