OpenGL

一、OpenGL介绍

​OpenGL(Open Graphics Library)是一种跨语言、跨平台的应用程序编程接口(API)，用于渲染2D和3D矢量图形。​它提供了一组函数，允许开发者与图形处理单元(GPU)交互，实现硬件加速的图形渲染。

OpenGL详解：GPU接口规范与图形渲染管线：https://blog.csdn.net/weixin_45449806/article/details/130207607

二、OpenGL组件

①顶点(Vertex)
②坐标(Coordinates)
③颜色(Color)
④纹理(Texture)
⑤着色器(Shader)
⑥帧缓冲(Frame Buffer)

三、OpenGL代码

1.2D白色矩形

(1)C++代码

#include <GL/glut.h>

void myDisplay(void)

{
     glClear(GL_COLOR_BUFFER_BIT);

     glRectf(-0.5f, -0.5f, 0.5f, 0.5f);

     glFlush();
}

int main(int argc, char *argv[])

{
     glutInit(&argc, argv);

     glutInitDisplayMode(GLUT_RGB | GLUT_SINGLE);

     glutInitWindowPosition(100, 100);

     glutInitWindowSize(400, 400);

     glutCreateWindow("第一个OpenGL程序");

     glutDisplayFunc(&myDisplay);

     glutMainLoop();

     return 0;
}

(2)代码解释

该程序的作用是在一个黑色的窗口中央画一个白色的矩形。下面对各行语句进行说明。

首先，需要包含头文件#include <GL/glut.h>，这是GLUT的头文件，其已经包含了<GL/gl.h>和<GL/glu.h>

注意main函数中的各语句，除了最后的return之外，其余全部以glut开头。这种以glut开头的函数都是GLUT工具包所提供的函数，以下是这些函数的介绍：
①glutInit：
对GLUT进行初始化，这个函数必须在其它的GLUT使用之前调用一次。其格式比较死板，一般照抄这句glutInit(&argc, argv)就可以了。
②glutInitDisplayMode：
设置显示方式，其中GLUT_RGB表示使用RGB颜色，与之对应的还有GLUT_INDEX(表示使用索引颜色)。GLUT_SINGLE表示使用单缓冲，与之对应的还有GLUT_DOUBLE(使用双缓冲)
③glutInitWindowPosition：设置窗口在屏幕中的位置。
④glutInitWindowSize：设置窗口的大小
⑤glutCreateWindow：
根据前面设置的信息创建窗口。参数将被作为窗口的标题。
注意：窗口被创建后，并不立即显示到屏幕上。需要调用glutMainLoop才能看到窗口。
⑥glutDisplayFunc：
设置一个函数，当需要进行画图时，这个函数就会被调用
⑦glutMainLoop：
进行一个消息循环。（这个可能初学者也不太明白，现在只需要知道这个函数可以显示窗口，并且等待窗口关闭后才会返回，这就足够了。）

在glutDisplayFunc函数中，我们设置了“当需要画图时，请调用myDisplay函数”。于是myDisplay函数就用来画图。观察myDisplay中的三个函数调用，发现它们都以gl开头。这种以gl开头的函数都是OpenGL的标准函数，下面对用到的函数进行介绍。
①glClear：清除
GL_COLOR_BUFFER_BIT表示清除颜色，glClear函数还可以清除其它的东西，但这里不作介绍。
②glRectf：画一个矩形
四个参数分别表示了位于对角线上的两个点的横、纵坐标。
③glFlush：刷新屏幕
保证前面的OpenGL命令立即执行，而不是让它们在缓冲区中等待。作用类似 fflush stdout。

2.2D彩色三角形

(1)效果

(2)步骤

1.激活虚拟环境

conda activate pytorch_env1

2.安装pygame库

pip install pygame 
pip install PyOpenGL
pip install PyOpenGL_accelerate

①Pygame 是一个用于开发视频游戏的跨平台 Python 库。它提供了计算机图形（2D）和声音（音频）功能，使开发者能够轻松地创建游戏和多媒体应用。Pygame 提供了对图像、声音、事件处理、输入设备等方面的支持，适合用于制作简单到中等复杂度的游戏。
②PyOpenGL 是 Python 对 OpenGL 图形库的绑定，使 Python 程序能够使用 OpenGL 提供的功能进行高性能的 3D 图形渲染。OpenGL（Open Graphics Library）是一个跨语言、跨平台的图形渲染 API，广泛用于 3D 图形的开发。通过 PyOpenGL，开发者可以在 Python 中访问 OpenGL 的功能，进行复杂的 3D 图形处理。
③PyOpenGL_accelerate 是 PyOpenGL 的一个扩展模块，旨在通过使用 Cython 对关键部分进行编译优化，以提高性能。它提供了对 PyOpenGL 的加速，使得在进行大量图形计算时，能够获得更好的性能表现。需要注意，安装 PyOpenGL_accelerate 需要有一个正常工作的 Python 扩展编译环境。

(3)python代码

import pygame                #导入Pygame库, 用于创建游戏窗口和处理事件
from pygame.locals import *  #导入Pygame的本地模块, 包含常用的变量和函数

from OpenGL.GL import *      #导入OpenGL的核心功能
from OpenGL.GLUT import *    #导入OpenGL的实用工具库
from OpenGL.GLU import *     #导入OpenGL的实用工具库

#triangle vertices
vertices = [
    [0, 1, 0],   #vertex0
    [-1, -1, 0], #vertex1
    [1, -1, 0]   #vertex2
]

#triangle colors
colors = [
    [1, 0, 0],  #red
    [0, 1, 0],  #green
    [0, 0, 1]   #blue
]

#绘制三角形
def Triangle():
    glBegin(GL_TRIANGLES)
    for i, vertex in enumerate(vertices):
        glColor3fv(colors[i]) #config color
        glVertex3fv(vertex)   #config vertex
    glEnd()

def main():
    pygame.init()
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF|OPENGL)     #创建窗口

    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0) #设置透视参数
    glTranslatef(0.0, 0.0, -5)                        #平移视图

    while True:  #主循环
        for event in pygame.event.get():   #处理事件
            if event.type == pygame.QUIT:  #如果是退出事件，则退出程序
                pygame.quit()
                quit()

        glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT)  #清除屏幕和深度缓冲

        Triangle()  #绘制三角形

        pygame.display.flip()  #刷新屏幕
        pygame.time.wait(10)   #稍微等待一下，减少CPU占用

main()  #调用主函数,启动程序

(4)代码解释

在这个例子中，我们首先定义了三角形的顶点和颜色。然后，我们定义了一个函数 Triangle，它使用 OpenGL 的函数 glBegin、glColor3fv 和 glVertex3fv 来绘制三角形。

在 main 函数中，我们初始化 Pygame，并创建一个 800x600 的窗口。

然后，我们设置 OpenGL 的视口和透视参数。

接着，我们进入一个无限循环，在这个循环中，我们处理事件(例如，检测到窗口关闭事件时退出程序)，清除屏幕和深度缓冲，然后调用 Triangle 函数绘制三角形，最后刷新屏幕。

pygame.display.set_mode(display, DOUBLEBUF|OPENGL) 在这行代码中，pygame.display.set_mode() 是 Pygame 的函数，用于创建游戏窗口。
参数 DOUBLEBUF|OPENGL 表示我们希望窗口支持双缓冲和 OpenGL。双缓冲可以防止画面闪烁，OpenGL 是我们要使用的图形库。

3.3D旋转球体

(1)效果

(2)python代码

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLUT import *
from OpenGL.GLU import *

# 初始化光照参数
def init_lighting():
    # 设置光源位置和亮度
    glLight(GL_LIGHT0, GL_POSITION, (1, 1, 1, 0))  # 设置光源位置
    glLight(GL_LIGHT0, GL_DIFFUSE, (1.0, 1.0, 1.0, 1))   # 增强光源的漫反射光强度
    glLight(GL_LIGHT0, GL_SPECULAR, (1.0, 1.0, 1.0, 1))  # 增强光源的高光反射光强度
    glEnable(GL_LIGHT0)  # 启用光源0
    glEnable(GL_LIGHTING)  # 启用光照

    # 启用阴影
    glEnable(GL_DEPTH_TEST)

    # 设置环境光（全局光照），使得球体的中间部分变亮
    glLightfv(GL_LIGHT0, GL_AMBIENT, (0.3, 0.3, 0.3, 1))  # 设置环境光，弱光源用于全局照亮

    # 设置材质反射率，适应多种光源
    glMaterial(GL_FRONT, GL_DIFFUSE, (1.0, 0.8, 0.2, 1))  # 设置物体的漫反射光反射率 (橙色)
    glMaterial(GL_FRONT, GL_SPECULAR, (1.0, 1.0, 1.0, 1))  # 设置物体的高光反射光反射率
    glMaterial(GL_FRONT, GL_SHININESS, 100)  # 设置高光反射光的强度 (强光)

    # 添加第二个光源
    glLight(GL_LIGHT1, GL_POSITION, (-1, -1, 1, 0))  # 第二个光源的位置
    glLight(GL_LIGHT1, GL_DIFFUSE, (1.0, 1.0, 1.0, 1))   # 增加光源的强度
    glLight(GL_LIGHT1, GL_SPECULAR, (1.0, 1.0, 1.0, 1))  # 第二个光源的反射强度
    glEnable(GL_LIGHT1)  # 启用第二个光源

# 绘制球体
def draw_sphere():
    # 使用OpenGL的GLU库绘制一个球体
    quadric = gluNewQuadric()  # 创建一个四面体对象
    gluSphere(quadric, 1, 32, 32)  # 绘制球体，半径为1，细分为32x32

def main():
    pygame.init()
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)
    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)  # 设置透视视角
    glTranslatef(0.0, 0.0, -5)  # 平移视图

    # 启用光照
    init_lighting()

    # 主循环
    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:  # 退出事件
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)  # 旋转球体
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # 清除颜色缓冲和深度缓冲
        draw_sphere()  # 绘制球体
        pygame.display.flip()  # 刷新屏幕
        pygame.time.wait(10)  # 稍微等待一下，减少CPU占用

if __name__ == "__main__":
    main()

(3)效果2：彩色2.5D球体

颜色随时改变

(4)python代码2

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import math

def Sphere():
    slices = 50  # 经度细分数
    stacks = 50  # 纬度细分数
    radius = 1.0 # 球体半径

    # 遍历每个纬度层
    for i in range(stacks):
        # 计算当前纬度和下一纬度的角度
        theta1 = i * math.pi / stacks          # 当前层纬度
        theta2 = (i + 1) * math.pi / stacks    # 下一层纬度

        glBegin(GL_TRIANGLE_STRIP)  # 使用三角形条带构建球面
        # 遍历每个经度点
        for j in range(slices + 1):
            phi = j * 2 * math.pi / slices  # 经度角
            # 为当前纬度层和下一纬度层生成顶点
            for theta in [theta1, theta2]:
                # 球面坐标转换为笛卡尔坐标
                x = radius * math.sin(theta) * math.cos(phi)
                y = radius * math.sin(theta) * math.sin(phi)
                z = radius * math.cos(theta)

                # 根据坐标位置计算颜色（映射到0-1范围）
                r = (x + 1) / 2  # X轴方向颜色分量
                g = (y + 1) / 2  # Y轴方向颜色分量
                b = (z + 1) / 2  # Z轴方向颜色分量

                glColor3f(r, g, b)    # 设置顶点颜色
                glVertex3f(x, y, z)   # 添加顶点坐标
        glEnd()

def main():
    pygame.init()
    display = (800, 600)
    # 创建OpenGL显示窗口
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)

    # 设置透视投影
    gluPerspective(45, (display[0]/display[1]), 0.1, 50.0)
    glTranslatef(0.0, 0.0, -5)  # 将视点向后移动5个单位

    glEnable(GL_DEPTH_TEST)  # 启用深度测试

    while True:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)  # 绕(3,1,1)轴旋转，每次1度
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)  # 清除缓冲
        Sphere()                # 绘制球体
        pygame.display.flip()   # 刷新显示
        pygame.time.wait(10)    # 控制渲染速度

if __name__ == "__main__":
    main()

4.3D彩色旋转立方体

(1)效果

(2)python代码

import pygame                #导入Pygame库,用于创建游戏窗口和处理事件
from pygame.locals import *  #导入Pygame的本地模块，包含常用的变量和函数
from OpenGL.GL import *      #导入OpenGL的核心功能
from OpenGL.GLUT import *    #导入OpenGL的实用工具库
from OpenGL.GLU import *     #导入OpenGL的实用工具库

#Cube vertices
vertices = (
    (1, -1, -1), (1, 1, -1),   #前面的两个顶点
    (-1, 1, -1), (-1, -1, -1), #左面的两个顶点
    (1, -1, 1), (1, 1, 1),     #后面的两个顶点
    (-1, -1, 1), (-1, 1, 1)    #右面的两个顶点
)

#定义立方体的面
faces = (
    (0, 1, 2, 3),  #前面的四个顶点
    (3, 2, 7, 6),  #左面的四个顶点
    (6, 7, 5, 4),  #后面的四个顶点
    (4, 5, 1, 0),  #右面的四个顶点
    (1, 5, 7, 2),  #上面的四个顶点
    (4, 0, 3, 6)   #下面的四个顶点
)

#定义面的颜色
colors = (
    (1, 0, 0),  #红色
    (0, 1, 0),  #绿色
    (0, 0, 1),  #蓝色
    (1, 1, 0),  #黄色
    (1, 0, 1),  #紫色
    (0, 1, 1),  #青色
    (1, 1, 1),  #白色
    (0, 0, 0)   #黑色
)
#绘制立方体
def Cube():
    glBegin(GL_QUADS)   #开始绘制四边形
    for face in faces:
        x = 0
        for vertex in face:
            x += 1
            glColor3fv(colors[x])          #设置顶点颜色
            glVertex3fv(vertices[vertex])  #设置顶点坐标
    glEnd()             #结束绘制四边形

def main():
    pygame.init()          #初始化Pygame
    display = (800, 600)
    pygame.display.set_mode(display, DOUBLEBUF | OPENGL)      #创建窗口
    gluPerspective(45, (display[0] / display[1]), 0.1, 50.0)  #设置透视参数
    glTranslatef(0.0, 0.0, -5)                           #平移视图

    # Enable depth testing
    glEnable(GL_DEPTH_TEST)  #启用深度测试

    #主循环(无限循环)
    while True:
        for event in pygame.event.get():   #处理事件
            if event.type == pygame.QUIT:  #如果是退出事件,则退出程序
                pygame.quit()
                quit()

        glRotatef(1, 3, 1, 1)                 #旋转立方体
        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) #清除屏幕和深度缓冲
        Cube()                 #绘制立方体
        pygame.display.flip()  #刷新屏幕
        pygame.time.wait(10)   #稍微等待一下,减少 CPU 占用

main()  #调用主函数,启动程序

(3)代码解释

这段代码使用了许多图形编程和计算机图形学的技术和概念，包括OpenGL，深度缓冲，顶点数组，颜色数组，透视变换，模型视图变换，渲染循环等。

①Pygame:
Pygame 是一个 Python 编写的跨平台的视频游戏开发库。它包括计算机图形学和声音库，设计用于创建视频游戏。在这个程序中，Pygame 主要用于创建显示窗口和处理用户输入（如点击关闭按钮）。
②OpenGL:
OpenGL（Open Graphics Library）是一个跨语言、跨平台的应用程序编程接口（API），用于渲染2D、3D矢量图形。在这段代码中，OpenGL 负责实际的立方体绘制工作。
③GL_QUADS:
GL_QUADS是OpenGL中的一个绘制模式，表示每四个顶点构成一个独立的四边形。在glBegin和glEnd之间定义的顶点会被组织成四边形进行渲染。
④glColor3fv 和 glVertex3fv:
这两个函数分别用于设置顶点的颜色和坐标。3fv表示这个函数接受一个包含三个浮点数的数组，f表示浮点数，v表示向量（在这里指的是数组）。
⑤深度缓冲(Depth Buffer):
深度缓冲是3D渲染中的一个技术，用于判断一个像素是否应该被绘制到屏幕上。当有多个物体在同一个位置渲染时，深度缓冲可以帮助我们判断哪一个物体在前面，哪一个物体在后面。这个程序中通过调用glEnable(GL_DEPTH_TEST)来启用深度测试，然后在每一帧的开始时清除深度缓冲。
⑥透视变换(Perspective Projection):
透视变换是3D计算机图形中的一种技术，用于将3D世界转换成2D图像。在这个程序中，通过gluPerspective函数设置透视变换的参数。
⑦模型视图变换(Model View Transformation): 模型视图变换是3D计算机图形中的一种技术，用于设置和改变物体在3D世界中的位置和方向。在这个程序中，通过glTranslatef和glRotatef函数来移动和旋转立方体。
⑧渲染循环(Rendering Loop): 渲染循环是所有图形应用程序的核心，它控制图形的更新和渲染。在这个程序中，渲染循环是主循环，包含事件处理，立方体旋转，绘制和缓冲区交换等操作。

5.小球在旋转的正六边形中，受重力影响。键盘按←→键控制旋转速度

(1)效果

(2)python代码

import pygame
import math

# Initialize Pygame
pygame.init()

# Constants
WIDTH, HEIGHT = 800, 600
CENTER = (WIDTH // 2, HEIGHT // 2)
HEX_RADIUS = 250
BALL_RADIUS = 15
GRAVITY = 0.5
FRICTION = 0.995
RESTITUTION = 0.8
ROTATION_SPEED = 0.02  #控制正六边体的旋转速度

# Set up display
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Bouncing Ball in Spinning Hexagon")
clock = pygame.time.Clock()

# Generate base hexagon vertices
base_hexagon = []
for i in range(6):
    angle = math.pi/3 * i
    x = HEX_RADIUS * math.cos(angle)
    y = HEX_RADIUS * math.sin(angle)
    base_hexagon.append((x, y))

# Initialize ball
ball_pos = [CENTER[0], CENTER[1] - HEX_RADIUS + 50]
ball_vel = [2, 0]

def main():
    global ROTATION_SPEED
    current_angle = 0
    running = True

    while running:
        for event in pygame.event.get():
            if event.type == pygame.QUIT:
                running = False

        #键盘按← →键控制正六边体的旋转速度
        keys = pygame.key.get_pressed()
        if keys[pygame.K_LEFT]:
            ROTATION_SPEED = max(0, ROTATION_SPEED - 0.001)   #限制最小值
        if keys[pygame.K_RIGHT]:
            ROTATION_SPEED += 0.001  #右方向键加速旋转

        # Update rotation angle
        current_angle = (current_angle + ROTATION_SPEED) % (2 * math.pi)

        # Apply physics
        ball_vel[1] += GRAVITY
        ball_vel[0] *= FRICTION
        ball_vel[1] *= FRICTION
        ball_pos[0] += ball_vel[0]
        ball_pos[1] += ball_vel[1]

        # Generate rotated hexagon
        current_hex = []
        for x, y in base_hexagon:
            rot_x = x * math.cos(current_angle) - y * math.sin(current_angle)
            rot_y = x * math.sin(current_angle) + y * math.cos(current_angle)
            current_hex.append((rot_x + CENTER[0], rot_y + CENTER[1]))

        # Collision detection
        for i in range(6):
            a = current_hex[i]
            b = current_hex[(i+1) % 6]

            # Calculate wall midpoint and normal
            mid = ((a[0]+b[0])/2, (a[1]+b[1])/2)
            norm = (CENTER[0] - mid[0], CENTER[1] - mid[1])
            length = math.hypot(*norm)
            if length == 0:
                continue
            norm = (norm[0]/length, norm[1]/length)

            # Find closest point on wall to ball
            ap = (ball_pos[0]-a[0], ball_pos[1]-a[1])
            ab = (b[0]-a[0], b[1]-a[1])
            t = max(0, min(1, (ap[0]*ab[0] + ap[1]*ab[1])/(ab[0]**2 + ab[1]**2 + 1e-8)))
            closest = (a[0] + t*ab[0], a[1] + t*ab[1])

            # Check collision
            dx = ball_pos[0] - closest[0]
            dy = ball_pos[1] - closest[1]
            distance = math.hypot(dx, dy)

            if distance < BALL_RADIUS:
                # Calculate wall point velocity
                wall_vel = (-ROTATION_SPEED*(closest[1]-CENTER[1]),
                            ROTATION_SPEED*(closest[0]-CENTER[0]))

                # Calculate relative velocity
                rel_vel = (ball_vel[0]-wall_vel[0], ball_vel[1]-wall_vel[1])
                v_dot_n = rel_vel[0]*norm[0] + rel_vel[1]*norm[1]

                if v_dot_n < 0:
                    # Reflect velocity
                    rel_vel = (rel_vel[0] - 2*v_dot_n*norm[0],
                               rel_vel[1] - 2*v_dot_n*norm[1])

                    # Apply restitution and update velocity
                    ball_vel[0] = rel_vel[0]*RESTITUTION + wall_vel[0]
                    ball_vel[1] = rel_vel[1]*RESTITUTION + wall_vel[1]

                    # Reposition ball
                    overlap = BALL_RADIUS - distance
                    ball_pos[0] += norm[0] * overlap
                    ball_pos[1] += norm[1] * overlap

        # Draw everything
        screen.fill((0, 0, 0))
        pygame.draw.lines(screen, (255, 255, 255), True, current_hex, 2)
        pygame.draw.circle(screen, (255, 0, 0),
                           (int(ball_pos[0]), int(ball_pos[1])), BALL_RADIUS)
        pygame.display.flip()
        clock.tick(60)

    pygame.quit()

if __name__ == "__main__":
    main()