c语言如何让图片运动

C语言如何让图片运动主要有以下几种方法：使用图形库（如SDL、OpenGL）、使用游戏引擎（如Allegro）、直接操作帧缓冲区、结合事件驱动编程。 在这些方法中，使用图形库是最常见也是最推荐的方式，因为这些库已经封装了大量的底层操作，简化了开发过程。下面将详细介绍如何使用SDL库来实现图片运动。

一、使用SDL库实现图片运动

1、安装和配置SDL库

SDL（Simple DirectMedia Layer） 是一个跨平台的多媒体库，适用于多种编程任务，包括图形和声音。安装SDL非常简单，在Linux系统下可以通过包管理器安装，如下所示：

sudo apt-get install libsdl2-dev

在Windows系统下，可以从SDL官网（https://www.libsdl.org/）下载开发包，并按照文档进行配置。

2、初始化SDL

在使用SDL之前，需要先进行初始化，并创建一个窗口和渲染器。下面是一个基本的初始化代码：

#include <SDL2/SDL.h>
#include <stdio.h>
int main(int argc, char* argv[]) {
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        printf("SDL could not initialize! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Window* window = SDL_CreateWindow("SDL Tutorial",
                                          SDL_WINDOWPOS_UNDEFINED,
                                          SDL_WINDOWPOS_UNDEFINED,
                                          640, 480,
                                          SDL_WINDOW_SHOWN);
    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        printf("Renderer could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
    // Main loop flag
    int quit = 0;
    // Event handler
    SDL_Event e;
    // While application is running
    while (!quit) {
        // Handle events on queue
        while (SDL_PollEvent(&e) != 0) {
            // User requests quit
            if (e.type == SDL_QUIT) {
                quit = 1;
            }
        }
        // Clear screen
        SDL_RenderClear(renderer);
        // Update screen
        SDL_RenderPresent(renderer);
    }
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

这段代码创建了一个基本的窗口，并处理了退出事件。

3、加载和显示图片

要在窗口中显示图片，首先需要加载图片文件。SDL_image库可以方便地加载多种格式的图片文件。先安装SDL_image库：

sudo apt-get install libsdl2-image-dev

然后在代码中添加图片加载和显示逻辑：

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <stdio.h>
int main(int argc, char* argv[]) {
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        printf("SDL could not initialize! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Window* window = SDL_CreateWindow("SDL Tutorial",
                                          SDL_WINDOWPOS_UNDEFINED,
                                          SDL_WINDOWPOS_UNDEFINED,
                                          640, 480,
                                          SDL_WINDOW_SHOWN);
    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        printf("Renderer could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
    if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) {
        printf("SDL_image could not initialize! SDL_image Error: %sn", IMG_GetError());
        return 1;
    }
    SDL_Texture* texture = NULL;
    SDL_Surface* loadedSurface = IMG_Load("path_to_image.png");
    if (loadedSurface == NULL) {
        printf("Unable to load image %s! SDL_image Error: %sn", "path_to_image.png", IMG_GetError());
        return 1;
    }
    texture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
    if (texture == NULL) {
        printf("Unable to create texture from %s! SDL_Error: %sn", "path_to_image.png", SDL_GetError());
        return 1;
    }
    SDL_FreeSurface(loadedSurface);
    // Main loop flag
    int quit = 0;
    // Event handler
    SDL_Event e;
    // While application is running
    while (!quit) {
        // Handle events on queue
        while (SDL_PollEvent(&e) != 0) {
            // User requests quit
            if (e.type == SDL_QUIT) {
                quit = 1;
            }
        }
        // Clear screen
        SDL_RenderClear(renderer);
        // Render texture to screen
        SDL_RenderCopy(renderer, texture, NULL, NULL);
        // Update screen
        SDL_RenderPresent(renderer);
    }
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    IMG_Quit();
    SDL_Quit();
    return 0;
}

4、实现图片运动

要实现图片运动，可以在每一帧中更新图片的位置，并重新渲染。下面是一个简单的示例，展示了如何让图片在窗口中左右移动：

#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <stdio.h>
int main(int argc, char* argv[]) {
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        printf("SDL could not initialize! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Window* window = SDL_CreateWindow("SDL Tutorial",
                                          SDL_WINDOWPOS_UNDEFINED,
                                          SDL_WINDOWPOS_UNDEFINED,
                                          640, 480,
                                          SDL_WINDOW_SHOWN);
    if (window == NULL) {
        printf("Window could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        printf("Renderer could not be created! SDL_Error: %sn", SDL_GetError());
        return 1;
    }
    SDL_SetRenderDrawColor(renderer, 0xFF, 0xFF, 0xFF, 0xFF);
    if (!(IMG_Init(IMG_INIT_PNG) & IMG_INIT_PNG)) {
        printf("SDL_image could not initialize! SDL_image Error: %sn", IMG_GetError());
        return 1;
    }
    SDL_Texture* texture = NULL;
    SDL_Surface* loadedSurface = IMG_Load("path_to_image.png");
    if (loadedSurface == NULL) {
        printf("Unable to load image %s! SDL_image Error: %sn", "path_to_image.png", IMG_GetError());
        return 1;
    }
    texture = SDL_CreateTextureFromSurface(renderer, loadedSurface);
    if (texture == NULL) {
        printf("Unable to create texture from %s! SDL_Error: %sn", "path_to_image.png", SDL_GetError());
        return 1;
    }
    SDL_FreeSurface(loadedSurface);
    // Main loop flag
    int quit = 0;
    // Event handler
    SDL_Event e;
    // Image position
    int x = 0;
    int y = (480 - 100) / 2; // Centered vertically
    int xVel = 2;
    // While application is running
    while (!quit) {
        // Handle events on queue
        while (SDL_PollEvent(&e) != 0) {
            // User requests quit
            if (e.type == SDL_QUIT) {
                quit = 1;
            }
        }
        // Move the image
        x += xVel;
        if (x < 0 || x + 100 > 640) {
            xVel = -xVel;
        }
        // Clear screen
        SDL_RenderClear(renderer);
        // Render texture to screen
        SDL_Rect renderQuad = { x, y, 100, 100 };
        SDL_RenderCopy(renderer, texture, NULL, &renderQuad);
        // Update screen
        SDL_RenderPresent(renderer);
        // Delay to limit frame rate
        SDL_Delay(16);
    }
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    IMG_Quit();
    SDL_Quit();
    return 0;
}

在这段代码中，我们定义了一个矩形 renderQuad，并在每一帧中更新其 x 坐标，使其在窗口中左右移动。

二、使用OpenGL实现图片运动

OpenGL是一个强大的跨平台图形API，可以用于创建高性能的2D和3D图形应用。虽然OpenGL更适合高级图形编程，但也可以用于简单的2D图形渲染。

1、初始化OpenGL

首先，需要安装OpenGL和GLFW库。GLFW是一个轻量级的开源库，用于创建窗口和处理输入事件。可以使用包管理器进行安装：

sudo apt-get install libglfw3-dev

然后，初始化OpenGL和GLFW：

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stdio.h>
int main() {
    if (!glfwInit()) {
        printf("Failed to initialize GLFWn");
        return -1;
    }
    GLFWwindow* window = glfwCreateWindow(640, 480, "OpenGL Tutorial", NULL, NULL);
    if (!window) {
        printf("Failed to create GLFW windown");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    if (glewInit() != GLEW_OK) {
        printf("Failed to initialize GLEWn");
        return -1;
    }
    while (!glfwWindowShouldClose(window)) {
        glClear(GL_COLOR_BUFFER_BIT);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}

2、加载和显示图片

在OpenGL中显示图片需要更多的设置，包括纹理、着色器和顶点缓冲对象。下面是一个基本的示例，展示了如何加载和显示图片：

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stb_image.h>
#include <stdio.h>
const char* vertexShaderSource = "#version 330 coren"
    "layout (location = 0) in vec3 aPos;n"
    "layout (location = 1) in vec2 aTexCoord;n"
    "out vec2 TexCoord;n"
    "void main()n"
    "{n"
    "   gl_Position = vec4(aPos, 1.0);n"
    "   TexCoord = aTexCoord;n"
    "}";
const char* fragmentShaderSource = "#version 330 coren"
    "out vec4 FragColor;n"
    "in vec2 TexCoord;n"
    "uniform sampler2D texture1;n"
    "void main()n"
    "{n"
    "   FragColor = texture(texture1, TexCoord);n"
    "}n";
int main() {
    if (!glfwInit()) {
        printf("Failed to initialize GLFWn");
        return -1;
    }
    GLFWwindow* window = glfwCreateWindow(640, 480, "OpenGL Tutorial", NULL, NULL);
    if (!window) {
        printf("Failed to create GLFW windown");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    if (glewInit() != GLEW_OK) {
        printf("Failed to initialize GLEWn");
        return -1;
    }
    // Build and compile the shader program
    unsigned int vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL);
    glCompileShader(vertexShader);
    unsigned int fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL);
    glCompileShader(fragmentShader);
    unsigned int shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);
    // Set up vertex data and buffers and configure vertex attributes
    float vertices[] = {
        // positions          // texture coords
         0.5f,  0.5f, 0.0f,   1.0f, 1.0f,
         0.5f, -0.5f, 0.0f,   1.0f, 0.0f,
        -0.5f, -0.5f, 0.0f,   0.0f, 0.0f,
        -0.5f,  0.5f, 0.0f,   0.0f, 1.0f
    };
    unsigned int indices[] = {
        0, 1, 3,
        1, 2, 3
    };
    unsigned int VBO, VAO, EBO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glGenBuffers(1, &EBO);
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
    glEnableVertexAttribArray(0);
    glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
    glEnableVertexAttribArray(1);
    // Load and create a texture
    unsigned int texture;
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    // Set the texture wrapping parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    // Set texture filtering parameters
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    // Load image, create texture and generate mipmaps
    int width, height, nrChannels;
    unsigned char *data = stbi_load("path_to_image.png", &width, &height, &nrChannels, 0);
    if (data) {
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
        glGenerateMipmap(GL_TEXTURE_2D);
    } else {
        printf("Failed to load texturen");
    }
    stbi_image_free(data);
    // Render loop
    while (!glfwWindowShouldClose(window)) {
        glClear(GL_COLOR_BUFFER_BIT);
        // Bind texture
        glBindTexture(GL_TEXTURE_2D, texture);
        // Render container
        glUseProgram(shaderProgram);
        glBindVertexArray(VAO);
        glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
        glfwSwapBuffers(window);
        glfwPollEvents();
    }
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteBuffers(1, &EBO);
    glfwDestroyWindow(window);
    glfwTerminate();
    return 0;
}

3、实现图片运动

要实现图片运动，可以在每一帧中更新顶点数据，使其在窗口中移动：

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include <stb_image.h>
#include <stdio.h>
const char* vertexShaderSource = "#version 330 coren"
    "layout (location = 0) in vec3 aPos;n"
    "layout (location = 1) in vec2 aTexCoord;n"
    "out vec2 TexCoord;n"
    "void main()n"
    "{n"
    "   gl_Position = vec4(aPos, 1.0);n"
    "   TexCoord = aTexCoord;n"
    "}";
const char* fragmentShaderSource = "#version 330 coren"
    "out vec4 FragColor;n"
    "in vec2 TexCoord;n"
    "uniform sampler2D texture1;n"
    "void main()n"
    "{n"
    "   FragColor = texture(texture1, TexCoord);n"
    "}n";
int main() {
    if (!glfwInit()) {
        printf("Failed to initialize GLFWn");
        return -1;
    }
    GLFWwindow* window = glfwCreateWindow(640, 480, "OpenGL Tutorial", NULL, NULL);
    if (!window) {
        printf("Failed to create GLFW windown");
        glfwTerminate();
        return -1;
    }
    glfwMakeContextCurrent(window);
    if (glewInit() != GLEW_OK) {
        printf("Failed to initialize