Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Исправь в этом коде 2 момента: При приближении зума srcRect начинает уменьшаться не…

  1. User

    Исправь в этом коде 2 момента:

    При приближении зума srcRect начинает уменьшаться не сразу. Сделай zoom_speed стартовую скорость, которая будет устанавливаться при начала приближения камеры
    Сделай курсор точкой зума. При зуме srcRect должен уменьшаться вокруг курсора
    

    // mainEditor.c #include <SDL2/SDL.h> #include <SDL2/SDL_image.h> #include <stdio.h> #include "zoom.h"

    #define WINDOW_WIDTH 800 #define WINDOW_HEIGHT 600

    int main(int argc, char *argv[]) { SDL_Window *window = NULL; SDL_Renderer *renderer = NULL; SDL_Texture *texture = NULL; SDL_Event event; int quit = 0;

    int image_width, image_height;

    // Initialize SDL if (SDL_Init(SDL_INIT_VIDEO) < 0) { printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError()); return -1; }

    // Initialize SDL_image if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) { printf("SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError()); SDL_Quit(); return -1; }

    // Create window window = SDL_CreateWindow("OpenAge Map Editor", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_RESIZABLE);

    if (window == NULL) { printf("Window could not be created! SDL_Error: %s\n", SDL_GetError()); IMG_Quit(); SDL_Quit(); return -1; }

    // Create renderer renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); if (renderer == NULL) { printf("Renderer could not be created! SDL_Error: %s\n", SDL_GetError()); SDL_DestroyWindow(window); IMG_Quit(); SDL_Quit(); return -1; }

    // Load image SDL_Surface *loadedSurface = IMG_Load("./map/world/background.png"); if (loadedSurface == NULL) { printf("Unable to load image %s! SDL_image Error: %s\n", "./map/world/background.png", IMG_GetError()); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); IMG_Quit(); SDL_Quit(); return -1; }

    // Create texture from surface texture = SDL_CreateTextureFromSurface(renderer, loadedSurface); if (texture == NULL) { printf("Unable to create texture from %s! SDL Error: %s\n", "./map/world/background.png", SDL_GetError()); SDL_FreeSurface(loadedSurface); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); IMG_Quit(); SDL_Quit(); return -1; // Добавлено завершение при ошибке }

    image_width = loadedSurface->w; image_height = loadedSurface->h;

    SDL_FreeSurface(loadedSurface);

    // Get initial window size int window_width, window_height; SDL_GetWindowSize(window, &window_width, &window_height);

    // Initialize zoom and camera init_zoom(image_width, image_height, window_width, window_height);

    // Main loop while (!quit) { // Event handling while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: quit = 1; break;

    case SDL_WINDOWEVENT:
        if (event.window.event == SDL_WINDOWEVENT_RESIZED)
        {
            // Update window size
            SDL_GetWindowSize(window, &window_width, &window_height);
            set_window_size(window_width, window_height);
        }
        break;
    
    case SDL_MOUSEBUTTONDOWN:
        if (event.button.button == SDL_BUTTON_LEFT)
        {
            // Start dragging
            start_camera_drag(event.button.x, event.button.y);
        }
        break;
    
    case SDL_MOUSEBUTTONUP:
        if (event.button.button == SDL_BUTTON_LEFT)
        {
            // Stop dragging
            stop_camera_drag();
        }
        break;
    
    case SDL_MOUSEMOTION:
        // Update camera dragging
        update_camera_drag(event.motion.x, event.motion.y);
        break;
    
    case SDL_MOUSEWHEEL:
        // Zoom in and out
        if (event.wheel.y > 0)
        {
            zoom_in();
        }
        else if (event.wheel.y < 0)
        {
            zoom_out();
        }
        break;
    
    default:
        break;
    }
    

    }

    // Update zoom level update_zoom();

    // Update camera position update_camera(); // Эта функция может быть оставлена для будущего использования

    // Get the source rectangle for rendering SDL_Rect src_rect = get_source_rect();

    // Set the destination rectangle (where to render the image in the window) SDL_Rect dst_rect; dst_rect.x = 0; dst_rect.y = 0; dst_rect.w = window_width; dst_rect.h = window_height;

    // Clear renderer SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Black background SDL_RenderClear(renderer);

    // Render the texture SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect);

    // Update screen SDL_RenderPresent(renderer);

    // Delay to control frame rate SDL_Delay(16); // Approximately 60 frames per second

    }

    // Clean up SDL_DestroyTexture(texture); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); IMG_Quit(); SDL_Quit();

    return 0;

    }

    // zoom.c #include "zoom.h"

    static float zoom_level = 1.0f; static float zoom_target = 1.0f; static const float zoom_speed = 0.1f; static const float zoom_factor = 1.1f; // Zoom increment factor

    // Image and window dimensions static int image_width = 0; static int image_height = 0; static int window_width = 0; static int window_height = 0;

    // Camera properties static float camera_x = 0.0f; static float camera_y = 0.0f;

    static int dragging = 0; static int prev_mouse_x = 0; static int prev_mouse_y = 0;

    // Initialize zoom and camera settings void init_zoom(int img_width, int img_height, int win_width, int win_height) { zoom_level = 1.0f; zoom_target = 1.0f; image_width = img_width; image_height = img_height; window_width = win_width; window_height = win_height; camera_x = 0.0f; camera_y = 0.0f; }

    // Zoom functions void zoom_in() { zoom_target *= zoom_factor; }

    void zoom_out() { zoom_target /= zoom_factor; }

    void update_zoom() { // Smoothly interpolate towards the target zoom level zoom_level += (zoom_target - zoom_level) * zoom_speed;

    // Clamp zoom level if (zoom_level < 0.1f) { zoom_level = 0.1f; zoom_target = 0.1f; } if (zoom_level > 10.0f) { zoom_level = 10.0f; zoom_target = 10.0f; }

    }

    // Camera drag functions void start_camera_drag(int mouse_x, int mouse_y) { dragging = 1; prev_mouse_x = mouse_x; prev_mouse_y = mouse_y; }

    void stop_camera_drag() { dragging = 0; }

    void update_camera_drag(int mouse_x, int mouse_y) { if (dragging) { // Calculate the difference in mouse movement int delta_x = mouse_x - prev_mouse_x; int delta_y = mouse_y - prev_mouse_y;

    // Update the camera position inversely to the mouse movement camera_x -= delta_x / zoom_level; camera_y -= delta_y / zoom_level;

    // Update previous mouse position prev_mouse_x = mouse_x; prev_mouse_y = mouse_y;

    }

    }

    // Update camera position and enforce boundaries void update_camera() { // Обновление позиции камеры перенесено в get_source_rect() // Эта функция может остаться пустой или использоваться для будущих обновлений }

    // Window resize handling void set_window_size(int win_width, int win_height) { window_width = win_width; window_height = win_height; }

    // Getter functions float get_zoom_level() { return zoom_level; }

    SDL_Rect get_source_rect() { SDL_Rect src_rect;

    // Calculate the aspect ratio of the window float window_aspect_ratio = (float)window_width / (float)window_height;

    // Calculate the initial visible width and height based on zoom level float visible_width = window_width / zoom_level; float visible_height = window_height / zoom_level;

    // Adjust visible area to maintain aspect ratio float adjusted_width = visible_width; float adjusted_height = visible_height;

    float current_aspect_ratio = visible_width / visible_height;

    if (current_aspect_ratio > window_aspect_ratio) { // Width is too big compared to height, adjust width adjusted_width = visible_height * window_aspect_ratio; } else if (current_aspect_ratio < window_aspect_ratio) { // Height is too big compared to width, adjust height adjusted_height = visible_width / window_aspect_ratio; }

    visible_width = adjusted_width; visible_height = adjusted_height;

    // Ensure visible dimensions do not exceed image dimensions if (visible_width > image_width) { visible_width = (float)image_width; visible_height = visible_width / window_aspect_ratio; }

    if (visible_height > image_height) { visible_height = (float)image_height; visible_width = visible_height * window_aspect_ratio; }

    // Adjust camera position to ensure src_rect is within image boundaries float max_camera_x = image_width - visible_width; float max_camera_y = image_height - visible_height;

    if (camera_x < 0) camera_x = 0; if (camera_x > max_camera_x) camera_x = max_camera_x;

    if (camera_y < 0) camera_y = 0; if (camera_y > max_camera_y) camera_y = max_camera_y;

    src_rect.x = (int)camera_x; src_rect.y = (int)camera_y; src_rect.w = (int)visible_width; src_rect.h = (int)visible_height;

    return src_rect;

    }

    // zoom.h #ifndef ZOOM_H #define ZOOM_H

    #include <SDL2/SDL.h>

    // Initialize zoom and camera settings void init_zoom(int image_width, int image_height, int window_width, int window_height);

    // Zoom controls void zoom_in(); void zoom_out(); void update_zoom();

    // Camera controls void start_camera_drag(int mouse_x, int mouse_y); void stop_camera_drag(); void update_camera_drag(int mouse_x, int mouse_y); void update_camera(); // Call this each frame

    // Window resize handling void set_window_size(int window_width, int window_height);

    // Getters float get_zoom_level(); SDL_Rect get_source_rect();

    #endif // ZOOM_H

  2. Assistant

    Конечно! Я исправлю код, чтобы решить две обозначенные проблемы:

    1. Проблема с начальной скоростью зума: Изменим логику так, чтобы zoom_speed был переменной, которая устанавливается при начале зума, и постепенно уменьшается для плавного перехода.

    2. Зум вокруг курсора: Добавим вычисления, чтобы при зуме точка под курсором оставалась на месте, то есть будем корректировать позицию камеры соответственно.

    Вот обновленный код с исправлениями:

    Файл mainEditor.c:

    #include <SDL2/SDL.h>
    #include <SDL2/SDL_image.h>
    #include <stdio.h>
    #include "zoom.h"
    
    #define WINDOW_WIDTH 800
    #define WINDOW_HEIGHT 600
    
    int main(int argc, char *argv[])
    {
        SDL_Window *window = NULL;
        SDL_Renderer *renderer = NULL;
        SDL_Texture *texture = NULL;
        SDL_Event event;
        int quit = 0;
    
        int image_width, image_height;
    
        // Initialize SDL
        if (SDL_Init(SDL_INIT_VIDEO) < 0)
        {
            printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
            return -1;
        }
    
        // Initialize SDL_image
        if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG))
        {
            printf("SDL_image could not initialize! SDL_image Error: %s\n", IMG_GetError());
            SDL_Quit();
            return -1;
        }
    
        // Create window
        window = SDL_CreateWindow("OpenAge Map Editor",
                                  SDL_WINDOWPOS_CENTERED,
                                  SDL_WINDOWPOS_CENTERED,
                                  WINDOW_WIDTH,
                                  WINDOW_HEIGHT,
                                  SDL_WINDOW_RESIZABLE);
    
        if (window == NULL)
        {
            printf("Window could not be created! SDL_Error: %s\n", SDL_GetError());
            IMG_Quit();
            SDL_Quit();
            return -1;
        }
    
        // Create renderer
        renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
        if (renderer == NULL)
        {
            printf("Renderer could not be created! SDL_Error: %s\n", SDL_GetError());
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return -1;
        }
    
        // Load image
        SDL_Surface *loadedSurface = IMG_Load("./map/world/background.png");
        if (loadedSurface == NULL)
        {
            printf("Unable to load image %s! SDL_image Error: %s\n", "./map/world/background.png", IMG_GetError());
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return -1;
        }
    
        // Create texture from surface
        texture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
        if (texture == NULL)
        {
            printf("Unable to create texture from %s! SDL Error: %s\n", "./map/world/background.png", SDL_GetError());
            SDL_FreeSurface(loadedSurface);
            SDL_DestroyRenderer(renderer);
            SDL_DestroyWindow(window);
            IMG_Quit();
            SDL_Quit();
            return -1;
        }
    
        image_width = loadedSurface->w;
        image_height = loadedSurface->h;
    
        SDL_FreeSurface(loadedSurface);
    
        // Get initial window size
        int window_width, window_height;
        SDL_GetWindowSize(window, &window_width, &window_height);
    
        // Initialize zoom and camera
        init_zoom(image_width, image_height, window_width, window_height);
    
        // Main loop
        while (!quit)
        {
            // Event handling
            while (SDL_PollEvent(&event))
            {
                switch (event.type)
                {
                    case SDL_QUIT:
                        quit = 1;
                        break;
    
                    case SDL_WINDOWEVENT:
                        if (event.window.event == SDL_WINDOWEVENT_RESIZED)
                        {
                            // Update window size
                            SDL_GetWindowSize(window, &window_width, &window_height);
                            set_window_size(window_width, window_height);
                        }
                        break;
    
                    case SDL_MOUSEBUTTONDOWN:
                        if (event.button.button == SDL_BUTTON_LEFT)
                        {
                            // Start dragging
                            start_camera_drag(event.button.x, event.button.y);
                        }
                        break;
    
                    case SDL_MOUSEBUTTONUP:
                        if (event.button.button == SDL_BUTTON_LEFT)
                        {
                            // Stop dragging
                            stop_camera_drag();
                        }
                        break;
    
                    case SDL_MOUSEMOTION:
                        // Update camera dragging
                        update_camera_drag(event.motion.x, event.motion.y);
                        break;
    
                    case SDL_MOUSEWHEEL:
                    {
                        // Get mouse position
                        int mouse_x, mouse_y;
                        SDL_GetMouseState(&mouse_x, &mouse_y);
                        // Zoom in and out
                        if (event.wheel.y > 0)
                        {
                            zoom_in(mouse_x, mouse_y);
                        }
                        else if (event.wheel.y < 0)
                        {
                            zoom_out(mouse_x, mouse_y);
                        }
                        break;
                    }
    
                    default:
                        break;
                }
            }
    
            // Update zoom level
            update_zoom();
    
            // Get the source rectangle for rendering
            SDL_Rect src_rect = get_source_rect();
    
            // Set the destination rectangle (where to render the image in the window)
            SDL_Rect dst_rect;
            dst_rect.x = 0;
            dst_rect.y = 0;
            dst_rect.w = window_width;
            dst_rect.h = window_height;
    
            // Clear renderer
            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Black background
            SDL_RenderClear(renderer);
    
            // Render the texture
            SDL_RenderCopy(renderer, texture, &src_rect, &dst_rect);
    
            // Update screen
            SDL_RenderPresent(renderer);
    
            // Delay to control frame rate
            SDL_Delay(16); // Approximately 60 frames per second
    
        }
    
        // Clean up
        SDL_DestroyTexture(texture);
        SDL_DestroyRenderer(renderer);
        SDL_DestroyWindow(window);
        IMG_Quit();
        SDL_Quit();
    
        return 0;
    
    }
    

    Файл zoom.h:

    #ifndef ZOOM_H
    #define ZOOM_H
    
    #include <SDL2/SDL.h>
    
    // Initialize zoom and camera settings
    void init_zoom(int image_width, int image_height, int window_width, int window_height);
    
    // Zoom controls
    void zoom_in(int mouse_x, int mouse_y);
    void zoom_out(int mouse_x, int mouse_y);
    void update_zoom();
    
    // Camera controls
    void start_camera_drag(int mouse_x, int mouse_y);
    void stop_camera_drag();
    void update_camera_drag(int mouse_x, int mouse_y);
    
    // Window resize handling
    void set_window_size(int window_width, int window_height);
    
    // Getters
    float get_zoom_level();
    SDL_Rect get_source_rect();
    
    #endif // ZOOM_H
    

    Файл zoom.c:

    #include "zoom.h"
    #include <math.h> // Для функции fabs()
    
    static float zoom_level = 1.0f;
    static float zoom_target = 1.0f;
    static float zoom_speed = 0.1f;
    static const float initial_zoom_speed = 0.5f; // Стартовая скорость зума
    static const float min_zoom_speed = 0.1f;     // Минимальная скорость зума
    static const float zoom_factor = 1.1f;        // Zoom increment factor
    
    // Image and window dimensions
    static int image_width = 0;
    static int image_height = 0;
    static int window_width = 0;
    static int window_height = 0;
    
    // Camera properties
    static float camera_x = 0.0f;
    static float camera_y = 0.0f;
    
    static int dragging = 0;
    static int prev_mouse_x = 0;
    static int prev_mouse_y = 0;
    
    // Variables for zooming around cursor
    static int is_zooming = 0;
    static float cursor_world_x = 0.0f;
    static float cursor_world_y = 0.0f;
    static int cursor_screen_x = 0;
    static int cursor_screen_y = 0;
    
    // Initialize zoom and camera settings
    void init_zoom(int img_width, int img_height, int win_width, int win_height)
    {
        zoom_level = 1.0f;
        zoom_target = 1.0f;
        image_width = img_width;
        image_height = img_height;
        window_width = win_width;
        window_height = win_height;
        camera_x = 0.0f;
        camera_y = 0.0f;
    }
    
    // Zoom functions
    void zoom_in(int mouse_x, int mouse_y)
    {
        // Store the world coordinates under the cursor
        cursor_world_x = camera_x + (float)mouse_x / zoom_level;
        cursor_world_y = camera_y + (float)mouse_y / zoom_level;
        cursor_screen_x = mouse_x;
        cursor_screen_y = mouse_y;
    
        zoom_target *= zoom_factor;
        is_zooming = 1;
        zoom_speed = initial_zoom_speed;
    }
    
    void zoom_out(int mouse_x, int mouse_y)
    {
        // Store the world coordinates under the cursor
        cursor_world_x = camera_x + (float)mouse_x / zoom_level;
        cursor_world_y = camera_y + (float)mouse_y / zoom_level;
        cursor_screen_x = mouse_x;
        cursor_screen_y = mouse_y;
    
        zoom_target /= zoom_factor;
        is_zooming = 1;
        zoom_speed = initial_zoom_speed;
    }
    
    void update_zoom()
    {
        // Smoothly interpolate towards the target zoom level
        float prev_zoom_level = zoom_level;
        zoom_level += (zoom_target - zoom_level) * zoom_speed;
    
        // Decrease zoom_speed gradually
        if (is_zooming)
        {
            zoom_speed *= 0.9f; // Decrease zoom_speed
            if (zoom_speed < min_zoom_speed)
            {
                zoom_speed = min_zoom_speed;
                is_zooming = 0; // Stop decreasing zoom_speed
            }
    
            // Adjust camera position to keep the cursor world position under the cursor
            camera_x = cursor_world_x - (float)cursor_screen_x / zoom_level;
            camera_y = cursor_world_y - (float)cursor_screen_y / zoom_level;
        }
    
        // Clamp zoom level
        if (zoom_level < 0.1f)
        {
            zoom_level = 0.1f;
            zoom_target = 0.1f;
        }
        if (zoom_level > 10.0f)
        {
            zoom_level = 10.0f;
            zoom_target = 10.0f;
        }
    }
    
    // Camera drag functions
    void start_camera_drag(int mouse_x, int mouse_y)
    {
        dragging = 1;
        prev_mouse_x = mouse_x;
        prev_mouse_y = mouse_y;
    }
    
    void stop_camera_drag()
    {
        dragging = 0;
    }
    
    void update_camera_drag(int mouse_x, int mouse_y)
    {
        if (dragging)
        {
            // Calculate the difference in mouse movement
            int delta_x = mouse_x - prev_mouse_x;
            int delta_y = mouse_y - prev_mouse_y;
    
            // Update the camera position inversely to the mouse movement
            camera_x -= delta_x / zoom_level;
            camera_y -= delta_y / zoom_level;
    
            // Update previous mouse position
            prev_mouse_x = mouse_x;
            prev_mouse_y = mouse_y;
        }
    }
    
    // Window resize handling
    void set_window_size(int win_width, int win_height)
    {
        window_width = win_width;
        window_height = win_height;
    }
    
    // Getters
    float get_zoom_level()
    {
        return zoom_level;
    }
    
    SDL_Rect get_source_rect()
    {
        SDL_Rect src_rect;
    
        // Calculate the aspect ratio of the window
        float window_aspect_ratio = (float)window_width / (float)window_height;
    
        // Calculate the visible width and height based on zoom level
        float visible_width = window_width / zoom_level;
        float visible_height = window_height / zoom_level;
    
        // Adjust visible area to maintain aspect ratio
        float adjusted_width = visible_width;
        float adjusted_height = visible_height;
    
        float current_aspect_ratio = visible_width / visible_height;
    
        if (current_aspect_ratio > window_aspect_ratio)
        {
            // Width is too big compared to height, adjust width
            adjusted_width = visible_height * window_aspect_ratio;
        }
        else if (current_aspect_ratio < window_aspect_ratio)
        {
            // Height is too big compared to width, adjust height
            adjusted_height = visible_width / window_aspect_ratio;
        }
    
        visible_width = adjusted_width;
        visible_height = adjusted_height;
    
        // Ensure visible dimensions do not exceed image dimensions
        if (visible_width > image_width)
        {
            visible_width = (float)image_width;
            visible_height = visible_width / window_aspect_ratio;
        }
    
        if (visible_height > image_height)
        {
            visible_height = (float)image_height;
            visible_width = visible_height * window_aspect_ratio;
        }
    
        // Adjust camera position to ensure src_rect is within image boundaries
        float max_camera_x = image_width - visible_width;
        float max_camera_y = image_height - visible_height;
    
        if (camera_x < 0)
            camera_x = 0;
        if (camera_x > max_camera_x)
            camera_x = max_camera_x;
    
        if (camera_y < 0)
            camera_y = 0;
        if (camera_y > max_camera_y)
            camera_y = max_camera_y;
    
        src_rect.x = (int)camera_x;
        src_rect.y = (int)camera_y;
        src_rect.w = (int)visible_width;
        src_rect.h = (int)visible_height;
    
        return src_rect;
    }
    

    Объяснение внесенных изменений:

    1. Стартовая скорость зума:

      • Добавлены переменные initial_zoom_speed и min_zoom_speed.
      • При начале зума (zoom_in и zoom_out) устанавливаем zoom_speed в initial_zoom_speed.
      • В update_zoom постепенно уменьшаем zoom_speed, чтобы достичь плавного замедления зума.
    2. Зум вокруг курсора:

      • В zoom_in и zoom_out добавлены параметры mouse_x и mouse_y.
      • Вычисляем мировые координаты точки под курсором и сохраняем их в cursor_world_x и cursor_world_y.
      • В update_zoom при обновлении zoom_level корректируем camera_x и camera_y, чтобы точка под курсором оставалась на том же месте на экране.

    Теперь при зуме изображение будет уменьшаться или увеличиваться вокруг позиции курсора, и зум будет начинаться с указанной стартовой скоростью.