/* * Copyright 2012 Google, Inc. All Rights Reserved. * Copyright 2026 Behdad Esfahbod. All Rights Reserved. */ #include "demo-view.h" extern "C" { #include "trackball.h" #include "matrix4x4.h" } struct demo_view_t { demo_glstate_t *st; GLFWwindow *window; /* Output */ GLint vsync; hb_bool_t srgb; hb_bool_t fullscreen; /* Mouse handling */ int buttons; int modifiers; bool dragged; bool click_handled; double cursorx, cursory; double beginx, beginy; double lastx, lasty, lastt; double dx,dy, dt; /* Transformation */ float quat[4]; double scalex; double scaley; demo_point_t translate; double perspective; /* Animation */ float rot_axis[3]; double rot_speed; bool animate; int num_frames; double fps_start_time; double last_frame_time; bool has_fps_timer; double fps_timer_interval; double fps_timer_last; /* Vim-style repeat count */ unsigned int repeat_count; /* Dirty flag for redraw */ bool needs_redraw; /* Window geometry just before going fullscreen */ int x; int y; int width; int height; }; demo_view_t * demo_view_create (demo_glstate_t *st, GLFWwindow *window) { demo_view_t *vu = (demo_view_t *) calloc (1, sizeof (demo_view_t)); vu->st = st; vu->window = window; vu->needs_redraw = true; demo_view_reset (vu); return vu; } void demo_view_destroy (demo_view_t *vu) { if (!vu) return; free (vu); } #define ANIMATION_SPEED 1. void demo_view_reset (demo_view_t *vu) { vu->perspective = 4; vu->scalex = vu->scaley = 1; vu->translate.x = vu->translate.y = 0; trackball (vu->quat , 0.0, 0.0, 0.0, 0.0); vset (vu->rot_axis, 0., 0., 1.); vu->rot_speed = ANIMATION_SPEED; vu->needs_redraw = true; } static void demo_view_scale_perspective (demo_view_t *vu, double factor) { vu->perspective = clamp (vu->perspective * factor, .01, 100.); } static void demo_view_scalex (demo_view_t *vu, double factor) { vu->scalex *= factor; } static void demo_view_scaley (demo_view_t *vu, double factor) { vu->scaley *= factor; } static void demo_view_scale (demo_view_t *vu, double sx, double sy) { vu->scalex *= sx; vu->scaley *= sy; } static void demo_view_translate (demo_view_t *vu, double dx, double dy) { vu->translate.x += dx / vu->scalex; vu->translate.y += dy / vu->scaley; } static void demo_view_apply_transform (demo_view_t *vu, float *mat) { int viewport[4]; glGetIntegerv (GL_VIEWPORT, viewport); GLint width = viewport[2]; GLint height = viewport[3]; m4Scale (mat, vu->scalex, vu->scaley, 1); m4Translate (mat, vu->translate.x, vu->translate.y, 0); { double d = std::max (width, height); double near = d / vu->perspective; double far = near + d; double factor = near / (2 * near + d); m4Frustum (mat, -width * factor, width * factor, -height * factor, height * factor, near, far); m4Translate (mat, 0, 0, -(near + d * .5)); } float m[4][4]; build_rotmatrix (m, vu->quat); m4MultMatrix(mat, &m[0][0]); m4Scale (mat, 1, -1, 1); } static double current_time (void) { return glfwGetTime (); } static void start_animation (demo_view_t *vu) { vu->num_frames = 0; vu->last_frame_time = vu->fps_start_time = current_time (); vu->fps_timer_interval = 5.0; vu->fps_timer_last = current_time (); vu->has_fps_timer = true; } static void demo_view_toggle_animation (demo_view_t *vu) { vu->animate = !vu->animate; LOGI ("Setting animation %s.\n", vu->animate ? "on" : "off"); if (vu->animate) start_animation (vu); } static void demo_view_toggle_vsync (demo_view_t *vu) { GLint vsync = !vu->vsync; glfwSwapInterval (vsync); vu->vsync = vsync; LOGI ("Setting vsync %s.\n", vu->vsync ? "on" : "off"); } static void demo_view_toggle_srgb (demo_view_t *vu) { hb_bool_t srgb = !vu->srgb; #if defined(GL_FRAMEBUFFER_SRGB) while (glGetError () != GL_NO_ERROR) ; if (srgb) glEnable (GL_FRAMEBUFFER_SRGB); else glDisable (GL_FRAMEBUFFER_SRGB); if (glGetError () == GL_NO_ERROR) { vu->srgb = srgb; LOGI ("Setting sRGB framebuffer %s.\n", vu->srgb ? "on" : "off"); } else { if (vu->srgb) glEnable (GL_FRAMEBUFFER_SRGB); else glDisable (GL_FRAMEBUFFER_SRGB); while (glGetError () != GL_NO_ERROR) ; LOGW ("Failed to set sRGB framebuffer state\n"); } #else LOGW ("No sRGB framebuffer extension found; failed to set sRGB framebuffer\n"); #endif } static void demo_view_toggle_fullscreen (demo_view_t *vu) { vu->fullscreen = !vu->fullscreen; if (vu->fullscreen) { glfwGetWindowPos (vu->window, &vu->x, &vu->y); glfwGetWindowSize (vu->window, &vu->width, &vu->height); GLFWmonitor *monitor = glfwGetPrimaryMonitor (); const GLFWvidmode *mode = glfwGetVideoMode (monitor); glfwSetWindowMonitor (vu->window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate); } else { glfwSetWindowMonitor (vu->window, NULL, vu->x, vu->y, vu->width, vu->height, 0); } } void demo_view_reshape_func (demo_view_t *vu, int width, int height) { vu->needs_redraw = true; } #define STEP 1.05 void demo_view_char_func (demo_view_t *vu, unsigned int codepoint) { if (codepoint >= '0' && codepoint <= '9') { vu->repeat_count = vu->repeat_count * 10 + (codepoint - '0'); return; } unsigned int count = vu->repeat_count ? vu->repeat_count : 1; vu->repeat_count = 0; for (unsigned int i = 0; i < count; i++) { switch (codepoint) { case '=': demo_view_scale (vu, STEP, STEP); break; case '-': demo_view_scale (vu, 1. / STEP, 1. / STEP); break; case '[': demo_view_scalex (vu, STEP); break; case ']': demo_view_scalex (vu, 1. / STEP); break; case '{': demo_view_scaley (vu, STEP); break; case '}': demo_view_scaley (vu, 1. / STEP); break; case 'k': demo_view_translate (vu, 0, -.1); break; case 'j': demo_view_translate (vu, 0, +.1); break; case 'h': demo_view_translate (vu, +.1, 0); break; case 'l': demo_view_translate (vu, -.1, 0); break; default: return; } } vu->needs_redraw = true; } void demo_view_key_func (demo_view_t *vu, int key, int scancode, int action, int mods) { if (action != GLFW_PRESS) return; switch (key) { case GLFW_KEY_ESCAPE: case GLFW_KEY_Q: glfwSetWindowShouldClose (vu->window, GLFW_TRUE); break; case GLFW_KEY_SPACE: demo_view_toggle_animation (vu); break; case GLFW_KEY_SLASH: if (mods & GLFW_MOD_SHIFT) demo_view_print_help (vu); break; case GLFW_KEY_S: demo_view_toggle_srgb (vu); break; case GLFW_KEY_V: demo_view_toggle_vsync (vu); break; case GLFW_KEY_F: demo_view_toggle_fullscreen (vu); break; case GLFW_KEY_R: demo_view_reset (vu); break; case GLFW_KEY_UP: demo_view_translate (vu, 0, -.1); break; case GLFW_KEY_DOWN: demo_view_translate (vu, 0, +.1); break; case GLFW_KEY_LEFT: demo_view_translate (vu, +.1, 0); break; case GLFW_KEY_RIGHT: demo_view_translate (vu, -.1, 0); break; default: return; } vu->needs_redraw = true; } void demo_view_mouse_func (demo_view_t *vu, int button, int action, int mods) { if (action == GLFW_PRESS) { vu->buttons |= (1 << button); vu->click_handled = false; } else vu->buttons &= ~(1 << button); vu->modifiers = mods; double x = vu->cursorx, y = vu->cursory; switch (button) { case GLFW_MOUSE_BUTTON_RIGHT: switch (action) { case GLFW_PRESS: if (vu->animate) { demo_view_toggle_animation (vu); vu->click_handled = true; } break; case GLFW_RELEASE: if (!vu->animate) { if (!vu->dragged && !vu->click_handled) demo_view_toggle_animation (vu); else if (vu->dt) { double speed = hypot (vu->dx, vu->dy) / vu->dt; if (speed > 0.1) demo_view_toggle_animation (vu); } vu->dx = vu->dy = vu->dt = 0; } break; } break; } vu->beginx = vu->lastx = x; vu->beginy = vu->lasty = y; vu->dragged = false; vu->needs_redraw = true; } void demo_view_scroll_func (demo_view_t *vu, double xoffset, double yoffset) { if (yoffset > 0) demo_view_scale (vu, STEP, STEP); else if (yoffset < 0) demo_view_scale (vu, 1. / STEP, 1. / STEP); vu->needs_redraw = true; } void demo_view_motion_func (demo_view_t *vu, double x, double y) { vu->cursorx = x; vu->cursory = y; if (!vu->buttons) return; vu->dragged = true; int width, height; glfwGetWindowSize (vu->window, &width, &height); if (vu->buttons & (1 << GLFW_MOUSE_BUTTON_LEFT)) { demo_view_translate (vu, +2 * (x - vu->lastx) / width, -2 * (y - vu->lasty) / height); } if (vu->buttons & (1 << GLFW_MOUSE_BUTTON_RIGHT)) { if (vu->modifiers & GLFW_MOD_SHIFT) { demo_view_scale_perspective (vu, 1 - ((y - vu->lasty) / height) * 5); } else { float dquat[4]; trackball (dquat, (2.0*vu->lastx - width) / width, ( height - 2.0*vu->lasty) / height, ( 2.0*x - width) / width, ( height - 2.0*y) / height ); vu->dx = x - vu->lastx; vu->dy = y - vu->lasty; vu->dt = current_time () - vu->lastt; add_quats (dquat, vu->quat, vu->quat); if (vu->dt) { vcopy (dquat, vu->rot_axis); vnormal (vu->rot_axis); vu->rot_speed = 2 * acos (dquat[3]) / vu->dt; } } } if (vu->buttons & (1 << GLFW_MOUSE_BUTTON_MIDDLE)) { double factor = 1 - ((y - vu->lasty) / height) * 5; demo_view_scale (vu, factor, factor); demo_view_translate (vu, +(2. * vu->beginx / width - 1) * (1 - factor), -(2. * vu->beginy / height - 1) * (1 - factor)); } vu->lastx = x; vu->lasty = y; vu->lastt = current_time (); vu->needs_redraw = true; } void demo_view_print_help (demo_view_t *vu) { (void) vu; LOGI ("hb-gpu-demo controls\n"); LOGI ("Keyboard:\n"); LOGI (" Esc, q Quit\n"); LOGI (" ? This help\n"); LOGI (" Space Toggle animation\n"); LOGI (" f Toggle fullscreen\n"); LOGI (" s Toggle sRGB framebuffer\n"); LOGI (" v Toggle vsync\n"); LOGI (" =, - Zoom in/out\n"); LOGI (" [, ] Stretch/shrink horizontally\n"); LOGI (" {, } Stretch/shrink vertically\n"); LOGI (" h, j, k, l Pan (vim-style)\n"); LOGI (" Arrow keys Pan\n"); LOGI (" r Reset view\n"); LOGI (" Repeat key N times (e.g. 30=)\n"); LOGI ("Mouse:\n"); LOGI (" Left drag Pan\n"); LOGI (" Middle drag / wheel Zoom\n"); LOGI (" Right drag Rotate\n"); LOGI (" Shift + right drag Adjust perspective\n"); LOGI (" Right drag and release Spin animation\n"); LOGI (" Right click Toggle animation\n"); LOGI ("\n"); } static void advance_frame (demo_view_t *vu, double dtime) { if (vu->animate) { float dquat[4]; axis_to_quat (vu->rot_axis, vu->rot_speed * dtime, dquat); add_quats (dquat, vu->quat, vu->quat); vu->num_frames++; } } void demo_view_display (demo_view_t *vu, demo_buffer_t *buffer) { double new_time = current_time (); advance_frame (vu, new_time - vu->last_frame_time); vu->last_frame_time = new_time; if (vu->animate && vu->has_fps_timer) { double now = current_time (); if (now - vu->fps_timer_last >= vu->fps_timer_interval) { LOGI ("%gfps\n", vu->num_frames / (now - vu->fps_start_time)); vu->num_frames = 0; vu->fps_start_time = now; vu->fps_timer_last = now; } } int width, height; glfwGetFramebufferSize (vu->window, &width, &height); glViewport (0, 0, width, height); float mat[16]; m4LoadIdentity (mat); demo_view_apply_transform (vu, mat); demo_extents_t extents; demo_buffer_extents (buffer, NULL, &extents); double content_scale = .9 * std::min (width / (extents.max_x - extents.min_x), height / (extents.max_y - extents.min_y)); m4Scale (mat, content_scale, content_scale, 1); m4Translate (mat, -(extents.max_x + extents.min_x) / 2., -(extents.max_y + extents.min_y) / 2., 0); demo_glstate_set_matrix (vu->st, mat); glClearColor (1, 1, 1, 1); glClear (GL_COLOR_BUFFER_BIT); demo_buffer_draw (buffer); glfwSwapBuffers (vu->window); vu->needs_redraw = false; } void demo_view_setup (demo_view_t *vu) { if (!vu->vsync) demo_view_toggle_vsync (vu); if (!vu->srgb) demo_view_toggle_srgb (vu); demo_glstate_setup (vu->st); } bool demo_view_should_redraw (demo_view_t *vu) { return vu->needs_redraw || vu->animate; }