游戏开发上手：Pygame、SDL 与 OpenGL 的基础实践

回到 C 语言：SDL 直接操控

Pygame 方便，但性能或底层控制还是得 SDL。初始化 SDL 子系统，创建窗口和渲染器，然后就能画了。但 SDL 错误处理啰嗦，每个步骤都得检查返回值，不然程序静悄悄崩溃。

#include <SDL.h>

int main(int argc, char *argv[]) {
    SDL_Window *window = NULL;
    SDL_Renderer *renderer = NULL;

    // 初始化 SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "SDL 初始化失败：%s\n", SDL_GetError());
        return 0;
    }

    // 创建窗口
    window = SDL_CreateWindow("SDL 窗口", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN);
    if (window == NULL) {
        fprintf(stderr, "窗口创建失败：%s\n", SDL_GetError());
        SDL_Quit();
        return 0;
    }

    // 创建渲染器
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        fprintf(stderr, "渲染器创建失败：%s\n", SDL_GetError());
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 0;
    }

    // 设置渲染器颜色
    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    SDL_RenderClear(renderer);
    SDL_RenderPresent(renderer);

    // 事件循环
    SDL_Event event;
    int quit = 0;
    while (!quit) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = 1;
            }
        }
    }

    // 清理资源
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

绘制图形也很直接，不过 SDL 没有内置画圆函数，只能用点来凑。

#include <SDL.h>

int main(int argc, char *argv[]) {
    SDL_Window *window = NULL;
    SDL_Renderer *renderer = NULL;

    // 初始化 SDL
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "SDL 初始化失败：%s\n", SDL_GetError());
        return 0;
    }

    // 创建窗口
    window = SDL_CreateWindow("SDL 绘制图形", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 800, 600, SDL_WINDOW_SHOWN);
    if (window == NULL) {
        fprintf(stderr, "窗口创建失败：%s\n", SDL_GetError());
        SDL_Quit();
        return 0;
    }

    // 创建渲染器
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        fprintf(stderr, "渲染器创建失败：%s\n", SDL_GetError());
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 0;
    }

    // 绘制图形
    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
    SDL_RenderClear(renderer);

    // 绘制矩形
    SDL_Rect rect = {300, 200, 200, 200};
    SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
    SDL_RenderFillRect(renderer, &rect);

    // 绘制圆形
    int x = 400, y = 300, r = 100;
    SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
    for (int i = x - r; i <= x + r; i++) {
        for (int j = y - r; j <= y + r; j++) {
            int dx = i - x;
            int dy = j - y;
            if (dx * dx + dy * dy <= r * r) {
                SDL_RenderDrawPoint(renderer, i, j);
            }
        }
    }

    // 绘制线条
    SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
    SDL_RenderDrawLine(renderer, 100, 100, 700, 500);
    SDL_RenderPresent(renderer);

    // 事件循环
    SDL_Event event;
    int quit = 0;
    while (!quit) {
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                quit = 1;
            }
        }
    }

    // 清理资源
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

进入 3D 世界：OpenGL

OpenGL 管线化，需要上下文、着色器、VAO/VBO，学习曲线陡峭。先用 GLFW 管理窗口，GLEW 加载扩展，然后写顶点和片段着色器，渲染一个橙色三角形。

#include <stdio.h>
#include <stdlib.h>
#include <GL/glew.h>
#include <GLFW/glfw3.h>

const GLchar *vertexSource = "#version 330 core\n" "layout (location = 0) in vec3 position;\n" "void main() {\n" "gl_Position = vec4(position, 1.0);\n" "}\n";
const GLchar *fragmentSource = "#version 330 core\n" "out vec4 color;\n" "void main() {\n" "color = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n" "}\n";

int main() {
    // 初始化 GLFW
    if (!glfwInit()) {
        fprintf(stderr, "GLFW 初始化失败！\n");
        return 0;
    }

    // 配置 GLFW
    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

    // 创建窗口
    GLFWwindow *window = glfwCreateWindow(800, 600, "OpenGL 三角形绘制", NULL, NULL);
    if (window == NULL) {
        fprintf(stderr, "窗口创建失败！\n");
        glfwTerminate();
        return 0;
    }
    glfwMakeContextCurrent(window);

    // 初始化 GLEW
    if (glewInit() != GLEW_OK) {
        fprintf(stderr, "GLEW 初始化失败！\n");
        glfwTerminate();
        return 0;
    }

    // 设置视口
    int width, height;
    glfwGetFramebufferSize(window, &width, &height);
    glViewport(0, 0, width, height);

    // 顶点数据
    GLfloat vertices[] = {-0.5f, -0.5f, 0.0f, 0.5f, -0.5f, 0.0f, 0.0f, 0.5f, 0.0f};

    // 创建顶点缓冲对象
    GLuint VBO, VAO;
    glGenVertexArrays(1, &VAO);
    glGenBuffers(1, &VBO);
    glBindVertexArray(VAO);
    glBindBuffer(GL_ARRAY_BUFFER, VBO);
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

    // 编译顶点着色器
    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vertexShader, 1, &vertexSource, NULL);
    glCompileShader(vertexShader);
    GLint success;
    GLchar infoLog[512];
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
        fprintf(stderr, "顶点着色器编译失败：%s\n", infoLog);
    }

    // 编译片段着色器
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fragmentShader, 1, &fragmentSource, NULL);
    glCompileShader(fragmentShader);
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
        fprintf(stderr, "片段着色器编译失败：%s\n", infoLog);
    }

    // 链接着色器程序
    GLuint shaderProgram = glCreateProgram();
    glAttachShader(shaderProgram, vertexShader);
    glAttachShader(shaderProgram, fragmentShader);
    glLinkProgram(shaderProgram);
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success);
    if (!success) {
        glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog);
        fprintf(stderr, "着色器程序链接失败：%s\n", infoLog);
    }
    glDeleteShader(vertexShader);
    glDeleteShader(fragmentShader);

    // 配置顶点属性
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid *)0);
    glEnableVertexAttribArray(0);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindVertexArray(0);

    // 渲染循环
    while (!glfwWindowShouldClose(window)) {
        glfwPollEvents();

        // 清除颜色缓冲
        glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
        glClear(GL_COLOR_BUFFER_BIT);

        // 使用着色器程序
        glUseProgram(shaderProgram);

        // 绑定顶点数组对象
        glBindVertexArray(VAO);

        // 绘制三角形
        glDrawArrays(GL_TRIANGLES, 0, 3);
        glBindVertexArray(0);

        // 交换缓冲
        glfwSwapBuffers(window);
    }

    // 清理资源
    glDeleteVertexArrays(1, &VAO);
    glDeleteBuffers(1, &VBO);
    glDeleteProgram(shaderProgram);

    // 终止 GLFW
    glfwTerminate();
    return 0;
}

实战：用 SDL 写个贪吃蛇

最后，融合事件处理、渲染循环，实现一个贪吃蛇。网格逻辑，方向控制，食物生成，碰撞检测，帧率限制都有了，虽然简陋，但涵盖了游戏循环的基本骨架。

#include <SDL.h>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define SCREEN_WIDTH 800
#define SCREEN_HEIGHT 600
#define GRID_SIZE 20
#define GRID_WIDTH (SCREEN_WIDTH / GRID_SIZE)
#define GRID_HEIGHT (SCREEN_HEIGHT / GRID_SIZE)
#define INITIAL_SNAKE_LENGTH 3
#define SNAKE_SPEED 100

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point head;
    Point body[100];
    int length;
    int direction; // 0: up, 1: right, 2: down, 3: left
} Snake;

typedef struct {
    Point position;
    int active;
} Food;

void init_snake(Snake *snake) {
    snake->length = INITIAL_SNAKE_LENGTH;
    snake->direction = 1; // right
    snake->head.x = GRID_WIDTH / 2;
    snake->head.y = GRID_HEIGHT / 2;
    for (int i = 1; i < snake->length; i++) {
        snake->body[i - 1].x = snake->head.x - i;
        snake->body[i - 1].y = snake->head.y;
    }
}

void draw_snake(SDL_Renderer *renderer, Snake *snake) {
    SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255);
    SDL_Rect head_rect = {snake->head.x * GRID_SIZE, snake->head.y * GRID_SIZE, GRID_SIZE, GRID_SIZE};
    SDL_RenderFillRect(renderer, &head_rect);
    for (int i = 0; i < snake->length - 1; i++) {
        SDL_Rect body_rect = {snake->body[i].x * GRID_SIZE, snake->body[i].y * GRID_SIZE, GRID_SIZE, GRID_SIZE};
        SDL_RenderFillRect(renderer, &body_rect);
    }
}

void update_snake(Snake *snake, int *game_over) {
    for (int i = snake->length - 2; i >= 0; i--) {
        snake->body[i + 1] = snake->body[i];
    }
    snake->body[0] = snake->head;
    switch (snake->direction) {
        case 0: // up
            snake->head.y--;
            break;
        case 1: // right
            snake->head.x++;
            break;
        case 2: // down
            snake->head.y++;
            break;
        case 3: // left
            snake->head.x--;
            break;
    }
    if (snake->head.x < 0 || snake->head.x >= GRID_WIDTH || snake->head.y < 0 || snake->head.y >= GRID_HEIGHT) {
        *game_over = 1;
    }
    for (int i = 0; i < snake->length - 1; i++) {
        if (snake->head.x == snake->body[i].x && snake->head.y == snake->body[i].y) {
            *game_over = 1;
        }
    }
}

void generate_food(Food *food, Snake *snake) {
    int valid_position = 0;
    while (!valid_position) {
        food->position.x = rand() % GRID_WIDTH;
        food->position.y = rand() % GRID_HEIGHT;
        valid_position = 1;
        if (food->position.x == snake->head.x && food->position.y == snake->head.y) {
            valid_position = 0;
        }
        for (int i = 0; i < snake->length - 1; i++) {
            if (food->position.x == snake->body[i].x && food->position.y == snake->body[i].y) {
                valid_position = 0;
            }
        }
    }
    food->active = 1;
}

void draw_food(SDL_Renderer *renderer, Food *food) {
    if (food->active) {
        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
        SDL_Rect rect = {food->position.x * GRID_SIZE, food->position.y * GRID_SIZE, GRID_SIZE, GRID_SIZE};
        SDL_RenderFillRect(renderer, &rect);
    }
}

void check_collision(Snake *snake, Food *food) {
    if (snake->head.x == food->position.x && snake->head.y == food->position.y) {
        snake->length++;
        food->active = 0;
        generate_food(food, snake);
    }
}

int main(int argc, char *argv[]) {
    SDL_Window *window = NULL;
    SDL_Renderer *renderer = NULL;
    if (SDL_Init(SDL_INIT_VIDEO) < 0) {
        fprintf(stderr, "SDL 初始化失败：%s\n", SDL_GetError());
        return 0;
    }
    window = SDL_CreateWindow("贪吃蛇游戏", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN);
    if (window == NULL) {
        fprintf(stderr, "窗口创建失败：%s\n", SDL_GetError());
        SDL_Quit();
        return 0;
    }
    renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
    if (renderer == NULL) {
        fprintf(stderr, "渲染器创建失败：%s\n", SDL_GetError());
        SDL_DestroyWindow(window);
        SDL_Quit();
        return 0;
    }
    srand(time(NULL));
    Snake snake;
    init_snake(&snake);
    Food food;
    food.active = 0;
    generate_food(&food, &snake);
    int game_over = 0;
    int last_time = SDL_GetTicks();
    int frame_time = 0;
    SDL_Event event;
    while (!game_over) {
        int current_time = SDL_GetTicks();
        int delta_time = current_time - last_time;
        last_time = current_time;
        frame_time += delta_time;
        while (SDL_PollEvent(&event)) {
            if (event.type == SDL_QUIT) {
                game_over = 1;
            } else if (event.type == SDL_KEYDOWN) {
                switch (event.key.keysym.sym) {
                    case SDLK_UP:
                        if (snake.direction != 2) {
                            snake.direction = 0;
                        }
                        break;
                    case SDLK_RIGHT:
                        if (snake.direction != 3) {
                            snake.direction = 1;
                        }
                        break;
                    case SDLK_DOWN:
                        if (snake.direction != 0) {
                            snake.direction = 2;
                        }
                        break;
                    case SDLK_LEFT:
                        if (snake.direction != 1) {
                            snake.direction = 3;
                        }
                        break;
                }
            }
        }
        if (frame_time >= SNAKE_SPEED) {
            update_snake(&snake, &game_over);
            check_collision(&snake, &food);
            frame_time = 0;
        }
        SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
        SDL_RenderClear(renderer);
        draw_snake(renderer, &snake);
        draw_food(renderer, &food);
        SDL_RenderPresent(renderer);
        SDL_Delay(16); // 限制帧率在 60FPS
    }
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return 0;
}

练练手

纸上得来终觉浅。试试下面这些任务，把代码跑起来：

1. 使用 Pygame 创建窗口并绘制图形
2. 使用 Pygame 处理键盘和鼠标事件
3. 使用 Pygame 播放音频
4. 使用 SDL 创建窗口并绘制图形
5. 使用 SDL 处理键盘和鼠标事件
6. 使用 SDL 播放音频
7. 使用 OpenGL 绘制三角形
8. 使用 OpenGL 绘制矩形
9. 使用 OpenGL 加载并显示纹理
10. 使用 SDL 和 OpenGL 结合开发 3D 游戏

这些库各有各的舒适区：Pygame 适合快速原型，SDL 胜在跨平台和轻量，OpenGL 则打开了 3D 的大门。选哪个，看你想做什么。