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

Напиши makefile для этого кода: #include "ECamera.h" #include <math.h> // Для функции…

  1. User

    Напиши makefile для этого кода:

    #include "ECamera.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;
    

    } #ifndef ECAMERA_H #define ECAMERA_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 // 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(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;
    

    }

  2. Assistant

    Here's the Makefile that compiles the provided code:

    CC = gcc
    CFLAGS = -Wall -Wextra -g
    SDL_CFLAGS := $(shell sdl2-config --cflags)
    SDL_LDFLAGS := $(shell sdl2-config --libs)
    SDL_IMAGE_CFLAGS := $(shell pkg-config --cflags SDL2_image)
    SDL_IMAGE_LDFLAGS := $(shell pkg-config --libs SDL2_image)
    
    CFLAGS += $(SDL_CFLAGS) $(SDL_IMAGE_CFLAGS)
    LDFLAGS += $(SDL_LDFLAGS) $(SDL_IMAGE_LDFLAGS)
    
    SRCS = ECamera.c main.c
    OBJS = $(SRCS:.c=.o)
    
    TARGET = editor
    
    all: $(TARGET)
    
    $(TARGET): $(OBJS)
    	$(CC) -o $@ $^ $(LDFLAGS)
    
    %.o: %.c
    	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
    
    clean:
    	rm -f $(OBJS) $(TARGET) $(OBJS:.o=.d)
    
    -include $(OBJS:.o=.d)
    

    Explanation:

    • Compiler and Flags:

      • CC = gcc: Specifies the compiler to use.
      • CFLAGS: Includes warnings and debugging symbols.
      • SDL_CFLAGS and SDL_LDFLAGS: Obtained using sdl2-config for SDL2 includes and libraries.
      • SDL_IMAGE_CFLAGS and SDL_IMAGE_LDFLAGS: Obtained using pkg-config for SDL2_image includes and libraries.
      • The CFLAGS and LDFLAGS variables are augmented with the obtained SDL flags.
    • Source Files and Objects:

      • SRCS: Lists your source files.
      • OBJS: Automatically converts .c filenames in SRCS to .o filenames for object files.
    • Build Rules:

      • all: The default target that builds the editor executable.
      • The linking rule combines the object files into the final executable, including the necessary SDL libraries.
      • The compilation rule compiles each .c file into an .o file, generating dependency files (.d) using -MMD -MP.
    • Dependencies:

      • -include $(OBJS:.o=.d): Includes the dependency files generated during compilation to ensure correct rebuilds when headers change.
    • Clean Rule:

      • clean: Removes all object files, dependency files, and the executable.

    Usage:

    1. Build the Project:

      make
      
    2. Clean the Project:

      make clean
      

    Notes:

    • Ensure you have SDL2 and SDL2_image installed on your system.
    • The pkg-config tool is used to find the compiler and linker flags for SDL2_image. Ensure it's installed and properly configured.
    • The dependency generation (-MMD -MP) ensures that changes in header files trigger recompilation of dependent source files.