C 语言游戏开发：Pygame、SDL、OpenGL 深度解析

C 语言游戏开发：Pygame、SDL、OpenGL 深度解析 | 极客日志

import pygame
import sys

# 初始化 Pygame
pygame.init()

# 设置窗口大小和标题
screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Pygame 窗口创建")

# 设置背景颜色
background_color = (255, 255, 255)

# 游戏循环
running = True
while running:
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    
    # 填充背景颜色
    screen.fill(background_color)
    
    # 更新显示
    pygame.display.flip()

# 退出 Pygame
pygame.quit()
sys.exit()

import pygame
import sys

# 初始化 Pygame
pygame.init()

# 设置窗口大小和标题
screen_width = 800
screen_height = 600
screen = pygame.display.set_mode((screen_width, screen_height))
pygame.display.set_caption("Pygame 绘制图形")

# 设置颜色
white = (255, 255, 255)
red = (255, 0, 0)
blue = (0, 0, 255)
green = (0, 255, 0)

# 游戏循环
running = True
while running:
    # 事件处理
    for event in pygame.event.get():
        if event.type == pygame.QUIT:
            running = False
    
    # 填充背景颜色
    screen.fill(white)
    
    # 绘制矩形
    rect = pygame.Rect(300, 200, 200, 200)
    pygame.draw.rect(screen, red, rect)
    
    # 绘制圆形
    pygame.draw.circle(screen, blue, (400, 300), 100)
    
    # 绘制线条
    pygame.draw.line(screen, green, (100, 100), (700, 500), 5)
    
    # 更新显示
    pygame.display.flip()

# 退出 Pygame
pygame.quit()
sys.exit()

#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;
}

#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;
}

#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;
}

#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;
}

C 语言游戏开发：Pygame、SDL、OpenGL 深度解析

C 语言游戏开发：Pygame、SDL、OpenGL 深度解析

一、前言：为什么游戏开发是 C 语言开发的重要技能？

学习目标

二、模块 1：Pygame 游戏开发基础

2.1 学习目标

2.2 Pygame 的核心架构

2.3 Pygame 的开发方法

三、模块 2：SDL 游戏开发基础

3.1 学习目标

3.2 SDL 的核心架构

3.3 SDL 的开发方法

四、模块 3：OpenGL 游戏开发基础

4.1 学习目标

4.2 OpenGL 的核心架构

4.3 OpenGL 的开发方法

五、模块 4：实战案例分析——使用 SDL 实现简单的游戏

5.1 学习目标

5.2 使用 SDL 实现简单的游戏

六、本章总结与课后练习

6.1 总结

6.2 课后练习

更多推荐文章

相关免费在线工具

C 语言游戏开发：Pygame、SDL、OpenGL 深度解析

C 语言游戏开发：Pygame、SDL、OpenGL 深度解析

一、前言：为什么游戏开发是 C 语言开发的重要技能？

学习目标

二、模块 1：Pygame 游戏开发基础

2.1 学习目标

2.2 Pygame 的核心架构

2.3 Pygame 的开发方法

三、模块 2：SDL 游戏开发基础

3.1 学习目标

3.2 SDL 的核心架构

3.3 SDL 的开发方法

四、模块 3：OpenGL 游戏开发基础

4.1 学习目标

4.2 OpenGL 的核心架构

4.3 OpenGL 的开发方法

五、模块 4：实战案例分析——使用 SDL 实现简单的游戏

5.1 学习目标

5.2 使用 SDL 实现简单的游戏

六、本章总结与课后练习

6.1 总结

6.2 课后练习

微信扫一扫，关注极客日志

更多推荐文章

相关免费在线工具