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

Запомни эти файлы, и проанализируй их: //ECamera.c #include "ECamera.h" #include…

  1. User

    Запомни эти файлы, и проанализируй их:

    //ECamera.c

    #include "ECamera.h" #include <math.h> // Для функции fabs()

    // Используем double для повышения точности static double zoom_level = 1.0; static double zoom_target = 1.0; static const double zoom_speed = 0.1; // Скорость зума static const double zoom_factor = 1.1; // Коэффициент увеличения зума static const double max_zoom_level = 10.0; // Максимальный уровень зума (приближения) static double min_zoom_level = 1.0; // Минимальный уровень зума, вычисляется

    // Размеры изображения и окна static int image_width = 0; static int image_height = 0; static int window_width = 0; static int window_height = 0;

    // Свойства камеры static double camera_x = 0.0; static double camera_y = 0.0;

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

    // Переменные для зума вокруг курсора static int is_zooming = 0; static double cursor_world_x = 0.0; static double cursor_world_y = 0.0; static int cursor_screen_x = 0; static int cursor_screen_y = 0;

    // Функция для вычисления минимального уровня зума, чтобы размер камеры не превышал размер изображения static void calculate_min_zoom_level() { double zoom_w = (double)window_width / (double)image_width; double zoom_h = (double)window_height / (double)image_height;

    // Выбираем максимальное значение между отношением размеров окна к изображения по ширине и по высоте min_zoom_level = (zoom_w > zoom_h) ? zoom_w : zoom_h;

    // Убедимся, что min_zoom_level не превышает 1.0 if (min_zoom_level > 1.0) { min_zoom_level = 1.0; }

    // Убедимся, что min_zoom_level не меньше очень малого значения if (min_zoom_level < 0.1) { min_zoom_level = 0.1; }

    }

    // Инициализация настроек зума и камеры void init_zoom(int img_width, int img_height, int win_width, int win_height) { image_width = img_width; image_height = img_height; window_width = win_width; window_height = win_height;

    calculate_min_zoom_level();

    zoom_level = min_zoom_level; zoom_target = min_zoom_level; camera_x = 0.0; camera_y = 0.0;

    }

    // Функции зума void zoom_in(int mouse_x, int mouse_y) { if (zoom_target >= max_zoom_level) { // Достигнуто максимальное приближение return; }

    // Сохранение мировых координат под курсором cursor_world_x = camera_x + (double)mouse_x / zoom_level; cursor_world_y = camera_y + (double)mouse_y / zoom_level; cursor_screen_x = mouse_x; cursor_screen_y = mouse_y;

    zoom_target *= zoom_factor;

    // Ограничение максимального уровня зума if (zoom_target > max_zoom_level) { zoom_target = max_zoom_level; }

    is_zooming = 1;

    }

    void zoom_out(int mouse_x, int mouse_y) { if (zoom_target <= min_zoom_level) { // Достигнуто минимальное отдаление return; }

    // Сохранение мировых координат под курсором cursor_world_x = camera_x + (double)mouse_x / zoom_level; cursor_world_y = camera_y + (double)mouse_y / zoom_level; cursor_screen_x = mouse_x; cursor_screen_y = mouse_y;

    zoom_target /= zoom_factor;

    // Ограничение минимального уровня зума if (zoom_target < min_zoom_level) { zoom_target = min_zoom_level; }

    is_zooming = 1;

    }

    void update_zoom() { if (is_zooming) { // Плавное интерполирование к целевому уровню зума double delta = zoom_target - zoom_level; double step = delta * zoom_speed;

    if (fabs(delta) < 0.001)
    {
        zoom_level = zoom_target;
        is_zooming = 0;
    }
    else
    {
        zoom_level += step;
    }
    
    // Корректировка положения камеры, чтобы удерживать мировую позицию курсора под курсором
    camera_x = cursor_world_x - (double)cursor_screen_x / zoom_level;
    camera_y = cursor_world_y - (double)cursor_screen_y / zoom_level;
    
    // Ограничение позиции камеры после изменения зума
    double view_width = (double)window_width / zoom_level;
    double view_height = (double)window_height / zoom_level;
    
    double max_camera_x = (double)image_width - view_width;
    double max_camera_y = (double)image_height - view_height;
    
    if (camera_x < 0.0)
        camera_x = 0.0;
    if (camera_y < 0.0)
        camera_y = 0.0;
    if (camera_x > max_camera_x)
        camera_x = max_camera_x;
    if (camera_y > max_camera_y)
        camera_y = max_camera_y;
    

    }

    }

    // Функции перетаскивания камеры 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) { // Вычисление разницы в движении мыши int delta_x = mouse_x - prev_mouse_x; int delta_y = mouse_y - prev_mouse_y;

    // Преобразование движения мыши в мировые координаты
    double world_delta_x = delta_x / zoom_level;
    double world_delta_y = delta_y / zoom_level;
    
    // Обновление положения камеры
    camera_x -= world_delta_x;
    camera_y -= world_delta_y;
    
    // Ограничение позиции камеры
    double view_width = (double)window_width / zoom_level;
    double view_height = (double)window_height / zoom_level;
    
    double max_camera_x = (double)image_width - view_width;
    double max_camera_y = (double)image_height - view_height;
    
    if (camera_x < 0.0)
        camera_x = 0.0;
    if (camera_y < 0.0)
        camera_y = 0.0;
    if (camera_x > max_camera_x)
        camera_x = max_camera_x;
    if (camera_y > max_camera_y)
        camera_y = max_camera_y;
    
    // Обновление предыдущего положения мыши
    prev_mouse_x = mouse_x;
    prev_mouse_y = mouse_y;
    

    }

    }

    // Обработка изменения размера окна void set_window_size(int win_width, int win_height) { window_width = win_width; window_height = win_height;

    calculate_min_zoom_level();

    // Убедимся, что текущий уровень зума не меньше минимального if (zoom_level < min_zoom_level) { zoom_level = min_zoom_level; zoom_target = min_zoom_level; }

    // Ограничение позиции камеры double view_width = (double)window_width / zoom_level; double view_height = (double)window_height / zoom_level;

    double max_camera_x = (double)image_width - view_width; double max_camera_y = (double)image_height - view_height;

    if (camera_x < 0.0) camera_x = 0.0; if (camera_y < 0.0) camera_y = 0.0; if (camera_x > max_camera_x) camera_x = max_camera_x; if (camera_y > max_camera_y) camera_y = max_camera_y;

    }

    // Геттеры float get_zoom_level() { return (float)zoom_level; }

    SDL_FRect get_destination_rect() { SDL_FRect dst_rect;

    // Рассчитываем позицию и размер текстуры с учетом камеры и зума dst_rect.x = -(float)(camera_x * zoom_level); dst_rect.y = -(float)(camera_y * zoom_level); dst_rect.w = (float)(image_width * zoom_level); dst_rect.h = (float)(image_height * zoom_level);

    return dst_rect;

    } #ifndef ECAMERA_H #define ECAMERA_H

    #include <SDL2/SDL.h>

    // Инициализация настроек зума и камеры void init_zoom(int image_width, int image_height, int window_width, int window_height);

    // Контроль зума void zoom_in(int mouse_x, int mouse_y); void zoom_out(int mouse_x, int mouse_y); void update_zoom();

    // Контроль камеры 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 set_window_size(int window_width, int window_height);

    // Геттеры float get_zoom_level(); SDL_FRect get_destination_rect();

    #endif // ECAMERA_H #include <SDL2/SDL.h> #include <SDL2/SDL_image.h> #include <stdio.h> #include "ECamera.h"

    #define WINDOW_WIDTH 800 #define WINDOW_HEIGHT 600

    int main() { 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! Ошибка SDL: %s\n", SDL_GetError()); return -1; }

    // Initialize SDL_image if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) { printf("Не удалось инициализировать SDL_image! Ошибка SDL_image: %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("Не удалось создать окно! Ошибка SDL: %s\n", SDL_GetError()); IMG_Quit(); SDL_Quit(); return -1; }

    // Create renderer renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED); if (renderer == NULL) { printf("Не удалось создать рендерер! Ошибка SDL: %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("Не удалось загрузить изображение %s! Ошибка SDL_image: %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("Не удалось создать текстуру из %s! Ошибка SDL: %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)
                {
                    // Обновление размера окна
                    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 destination rectangle for rendering
    SDL_FRect dst_rect = get_destination_rect();
    
    // Clear renderer
    SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255); // Черный фон
    SDL_RenderClear(renderer);
    
    // Render the texture using floating point coordinates
    SDL_RenderCopyF(renderer, texture, NULL, &dst_rect);
    
    // Update screen
    SDL_RenderPresent(renderer);
    
    // Delay to control frame rate
    SDL_Delay(16); // Примерно 60 кадров в секунду
    

    }

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

    return 0;

    }

    Проанализируй код этих файлов заготовки редактора карт. Ps. Это мой авторский код, который распространяется под GNU GPL

  2. Assistant

    Давайте подробно проанализируем предоставленный вами код, состоящий из трёх файлов: ECamera.c, ECamera.h и основного файла, использующего эти модули. Ваш код реализует управление камерой в редакторе карт с возможностью зума и перетаскивания изображения. Ниже приведён детальный анализ каждого файла и рекомендации по улучшению.


    1. Файл ECamera.c

    Общий обзор

    Этот файл реализует функциональность камеры с возможностью плавного зума и перетаскивания изображения. Он отвечает за:

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

    Структура и логика кода

    Глобальные переменные

    • Параметры зума и камеры:

      • double zoom_level — текущий уровень зума.
      • double zoom_target — целевой уровень зума при анимации увеличения/уменьшения.
      • const double zoom_speed — скорость плавного изменения зума.
      • const double zoom_factor — коэффициент изменения зума при увеличении/уменьшении.
      • const double max_zoom_level — максимальный допустимый уровень зума.
      • double min_zoom_level — минимальный уровень зума, вычисляется в зависимости от размеров окна и изображения.
    • Размеры изображения и окна:

      • int image_width, image_height — размеры загруженного изображения.
      • int window_width, window_height — текущие размеры окна.
    • Позиция камеры:

      • double camera_x, camera_y — координаты позиции камеры в мировых координатах.
    • Перетаскивание и зум вокруг курсора:

      • int dragging — флаг, указывающий, происходит ли перетаскивание.
      • int prev_mouse_x, prev_mouse_y — предыдущие координаты мыши для вычисления смещения при перетаскивании.
      • int is_zooming — флаг, указывающий, происходит ли анимация зума.
      • double cursor_world_x, cursor_world_y — мировые координаты курсора при начале зума.
      • int cursor_screen_x, cursor_screen_y — экранные координаты курсора при начале зума.

    Основные функции

    1. calculate_min_zoom_level()

      • Вычисляет min_zoom_level на основе отношения размеров окна к размеру изображения.
      • Устанавливает минимальный уровень зума так, чтобы изображение полностью помещалось в окно.
      • Ограничивает min_zoom_level значениями от 0.1 до 1.0.
    2. init_zoom()

      • Инициализирует параметры зума и камеры.
      • Вызывается при старте программы и при изменении размеров окна.
    3. zoom_in(int mouse_x, int mouse_y) и zoom_out(int mouse_x, int mouse_y)

      • Увеличивают или уменьшают zoom_target с учётом zoom_factor.
      • Сохраняют положение курсора в мировых координатах для того, чтобы зум происходил относительно курсора.
      • Устанавливают флаг is_zooming для последующей плавной анимации зума.
    4. update_zoom()

      • Плавно изменяет zoom_level в направлении zoom_target с учётом zoom_speed.
      • Корректирует положение camera_x и camera_y так, чтобы курсор оставался над той же точкой изображения при зуме.
      • Ограничивает позицию камеры, чтобы не выйти за границы изображения.
    5. Перетаскивание камеры:

      • start_camera_drag(int mouse_x, int mouse_y) — начинает перетаскивание, сохраняет начальное положение мыши.
      • stop_camera_drag() — останавливает перетаскивание.
      • update_camera_drag(int mouse_x, int mouse_y) — обновляет позицию камеры при перетаскивании, учитывая смещение мыши.
    6. set_window_size(int win_width, int win_height)

      • Обновляет размеры окна и пересчитывает min_zoom_level.
      • Корректирует zoom_level, если он меньше нового минимального значения.
      • Ограничивает позицию камеры в соответствии с новыми размерами окна.
    7. Геттеры:

      • get_zoom_level() — возвращает текущий уровень зума.
      • get_destination_rect() — вычисляет и возвращает SDL_FRect для отрисовки текстуры с учётом позиции камеры и уровня зума.

    Замечания и рекомендации

    • Использование глобальных статических переменных:

      • Все переменные объявлены как static, что ограничивает их область видимости в пределах файла ECamera.c. Это хорошо с точки зрения инкапсуляции.
      • Однако, если планируется расширение функционала и работа с несколькими камерами или сценами, стоит рассмотреть возможность создания структуры для камеры и передачи её указателя в функции.
    • Плавность зума:

      • Плавный зум реализован с помощью линейной интерполяции (LERP). Можно улучшить ощущение зума, применив другие методы интерполяции, например, экспоненциальную или добавив эффект инерции.
    • Ограничения позиции камеры:

      • В функции update_zoom() и update_camera_drag() повторяется код для ограничения позиции камеры. Рекомендуется вынести этот код в отдельную функцию для соблюдения принципа DRY (Don't Repeat Yourself).
    • Числовые константы:

      • Значения, такие как 0.1 для минимального значения min_zoom_level, могут быть вынесены в макросы или const переменные с понятными именами для улучшения читаемости кода.
    • Обработка очень больших или очень малых значений:

      • При работе с вычислениями зума и позиции камеры стоит учитывать возможные ошибки округления и деления на ноль. Возможно, стоит добавить минимальные значения (EPSILON) для предотвращения ошибок.

    2. Файл ECamera.h

    Общий обзор

    Заголовочный файл содержит объявления функций, используемых для управления зумом и камерой, а также включает необходимые заголовочные файлы.

    Замечания и рекомендации

    • Структура файла:

      • Файл корректно защищён от множественного включения с помощью директив #ifndef, #define, #endif.
      • Все функции декларированы и соответствуют тем, что реализованы в ECamera.c.
    • Необходимые включения:

      • Подключается SDL2/SDL.h, что необходимо для использования SDL_FRect в функции get_destination_rect().
    • Расширяемость:

      • Если планируется расширение функционала камеры, стоит рассмотреть использование структур и, возможно, создание объекта камеры с методами, особенно если будет переход на объектно-ориентированный стиль с использованием C++.

    3. Основной файл

    Общий обзор

    Этот файл содержит функцию main(), которая:

    • Инициализирует SDL и SDL_image.
    • Создаёт окно и рендерер.
    • Загружает изображение и создаёт из него текстуру.
    • Инициализирует зум и камеру.
    • Обрабатывает события (события окна, мыши, колёсика мыши).
    • Выполняет основной цикл отрисовки, где обновляет зум и отрисовывает текстуру с учётом позиции камеры.

    Структура и логика кода

    1. Инициализация:

      • Проводится инициализация SDL и SDL_image.
      • Создаются окно и рендерер с возможностью изменения размера окна.
      • Загружается изображение и создаётся текстура.
      • Получаются размеры окна и изображения.
      • Инициализируется зум и камера с помощью init_zoom().
    2. Основной цикл:

      • Обработка событий:

        • SDL_QUIT — выход из программы.
        • SDL_WINDOWEVENT_RESIZED — обновление размеров окна и вызов set_window_size().
        • SDL_MOUSEBUTTONDOWN/UP — начало и конец перетаскивания камеры.
        • SDL_MOUSEMOTION — обновление позиции камеры при перетаскивании.
        • SDL_MOUSEWHEEL — зум камеры с учётом позиции мыши.
      • Обновление зума через update_zoom().

      • Получение текущего dst_rect для отрисовки с учётом зума и позиции камеры.

      • Очистка рендерера и отрисовка текстуры.

      • Обновление экрана через SDL_RenderPresent().

    3. Завершение работы:

      • Освобождение всех ресурсов и корректное завершение SDL и SDL_image.

    Замечания и рекомендации

    • Проверка ошибок:

      • В местах, где вызываются функции SDL, стоит добавить проверку ошибок. Например, при вызове SDL_GetWindowSize() и других функций.
      • Можно использовать макросы или функции-обёртки для обработки ошибок, чтобы не загромождать код.
    • Управление частотой кадров:

      • Используется SDL_Delay(16) для приблизительной поддержки 60 FPS. Для более точного управления частотой кадров можно использовать SDL_GetTicks() или SDL_GetPerformanceCounter() и рассчитывать время, прошедшее между кадрами.
    • Читаемость кода:

      • Стоит добавить комментарии в ключевых местах, объясняя логику, особенно в обработке событий.
      • Можно разделить код на функции для обработки событий, обновления логики и отрисовки для улучшения структуры программы.
    • Ресайз окна:

      • При изменении размера окна важно учитывать соотношение сторон, особенно если планируется поддержка фиксированного соотношения сторон изображения.

    Общие рекомендации

    • Документация:

      • Добавьте более подробные комментарии к функциям в ECamera.c и ECamera.h, описывая их поведение, параметры и возвращаемые значения.
      • Это улучшит поддержку и расширяемость кода в будущем.
    • Структурирование кода:

      • Рассмотрите возможность разделения кода на логические модули и файлы, особенно если планируется расширение функционала редактора.
    • Масштабируемость:

      • Если редактор карт будет поддерживать различные инструменты и объекты, стоит заранее продумать архитектуру приложения, возможно, перейти на использование более высокоуровневых библиотек или двигателей, таких как SDL2 вместе с OpenGL или даже использовать готовые игровые движки.
    • Оптимизация:

      • В текущем коде производительность не является критичной, но если планируется поддержка больших карт или сложной графики, стоит обратить внимание на оптимизацию отрисовки и логики обновления.
    • Юзабилити:

      • Добавьте визуальные элементы интерфейса, такие как курсор руки при перетаскивании, индикацию уровня зума, панель инструментов и т.д., чтобы улучшить пользовательский опыт.

    Заключение

    Ваш код предоставляет хорошую основу для реализации редактора карт с поддержкой зума и перетаскивания камеры. Следуя приведённым рекомендациям, вы сможете улучшить структуру, расширяемость и удобство использования приложения. Успехов в дальнейшем развитии вашего проекта!