Skip to content
TheChatArchiveThe Chat Archive
DeepSeekdeepseek-r1-0528· DeepSeekHugging Face LMArena Human Preference 140K

请增加优化以下功能: 使用PyOpenGL实现更真实的光照 添加滑块控制光照方向 实现动态旋转动画 添加纹理贴图功能

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Coherecommand-a-03-2025’s answer.
  1. User

    请增加优化以下功能: 使用PyOpenGL实现更真实的光照 添加滑块控制光照方向 实现动态旋转动画 添加纹理贴图功能

  2. DeepSeek Assistant

    以下是一个使用PyOpenGL实现的增强版立方体程序,包含真实光照、滑块控制、动态旋转和纹理贴图功能:

    import sys
    import numpy as np
    from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget, QVBoxLayout, QSlider, QLabel
    from PyQt5.QtCore import Qt, QTimer
    from PyQt5.QtGui import QImage, QPixmap
    from OpenGL.GL import *
    from OpenGL.GLU import *
    from OpenGL.GLUT import *
    from PIL import Image
    
    class GLWidget(QWidget):
        def __init__(self, parent=None):
            super(GLWidget, self).__init__(parent)
            self.setMinimumSize(600, 600)
            
            # 立方体旋转角度
            self.x_rot = 30
            self.y_rot = 45
            self.z_rot = 0
            
            # 光照方向 (归一化向量)
            self.light_direction = np.array([1.0, 1.0, 1.0])
            self.light_direction /= np.linalg.norm(self.light_direction)
            
            # 纹理ID
            self.texture_id = None
            
            # 初始化定时器用于自动旋转
            self.timer = QTimer(self)
            self.timer.timeout.connect(self.auto_rotate)
            self.timer.start(30)  # 约30fps
            
            # 加载纹理
            self.load_texture()
        
        def load_texture(self):
            """加载纹理图片"""
            # 创建一个棋盘格纹理
            image = Image.new('RGB', (256, 256))
            pixels = image.load()
            for i in range(image.size[0]):
                for j in range(image.size[1]):
                    # 创建棋盘格图案
                    if (i // 32 + j // 32) % 2 == 0:
                        pixels[i, j] = (255, 0, 0)  # 红色
                    else:
                        pixels[i, j] = (255, 255, 0)  # 黄色
            
            # 转换为OpenGL纹理格式
            img_data = np.array(image).astype(np.uint8)
            
            # 生成纹理
            self.texture_id = glGenTextures(1)
            glBindTexture(GL_TEXTURE_2D, self.texture_id)
            
            # 设置纹理参数
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
            
            # 加载纹理数据
            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, image.size[0], image.size[1], 
                         0, GL_RGB, GL_UNSIGNED_BYTE, img_data)
        
        def initializeGL(self):
            """初始化OpenGL"""
            # 设置背景色
            glClearColor(0.1, 0.1, 0.2, 1.0)
            
            # 启用深度测试
            glEnable(GL_DEPTH_TEST)
            
            # 启用光照
            glEnable(GL_LIGHTING)
            glEnable(GL_LIGHT0)
            
            # 设置光源属性
            glLightfv(GL_LIGHT0, GL_AMBIENT, [0.2, 0.2, 0.2, 1.0])
            glLightfv(GL_LIGHT0, GL_DIFFUSE, [1.0, 1.0, 1.0, 1.0])
            glLightfv(GL_LIGHT0, GL_SPECULAR, [1.0, 1.0, 1.0, 1.0])
            
            # 设置材质属性
            glMaterialfv(GL_FRONT, GL_AMBIENT, [0.1, 0.1, 0.1, 1.0])
            glMaterialfv(GL_FRONT, GL_DIFFUSE, [0.8, 0.8, 0.8, 1.0])
            glMaterialfv(GL_FRONT, GL_SPECULAR, [0.5, 0.5, 0.5, 1.0])
            glMaterialf(GL_FRONT, GL_SHININESS, 50.0)
            
            # 启用纹理
            glEnable(GL_TEXTURE_2D)
        
        def paintGL(self):
            """渲染场景"""
            # 清除缓冲
            glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
            
            # 设置投影矩阵
            glMatrixMode(GL_PROJECTION)
            glLoadIdentity()
            gluPerspective(45, self.width() / self.height(), 0.1, 100.0)
            
            # 设置模型视图矩阵
            glMatrixMode(GL_MODELVIEW)
            glLoadIdentity()
            gluLookAt(0, 0, 8, 0, 0, 0, 0, 1, 0)
            
            # 应用旋转
            glRotatef(self.x_rot, 1, 0, 0)
            glRotatef(self.y_rot, 0, 1, 0)
            glRotatef(self.z_rot, 0, 0, 1)
            
            # 更新光源位置
            light_position = [self.light_direction[0], self.light_direction[1], 
                              self.light_direction[2], 0.0]  # 方向光 (w=0)
            glLightfv(GL_LIGHT0, GL_POSITION, light_position)
            
            # 绘制立方体
            self.draw_cube()
        
        def draw_cube(self):
            """绘制带纹理的立方体"""
            size = 1.0  # 立方体大小
            
            # 定义立方体的顶点
            vertices = [
                [-size, -size, -size],  # 0
                [ size, -size, -size],  # 1
                [ size,  size, -size],  # 2
                [-size,  size, -size],  # 3
                [-size, -size,  size],  # 4
                [ size, -size,  size],  # 5
                [ size,  size,  size],  # 6
                [-size,  size,  size]   # 7
            ]
            
            # 定义立方体的面(顶点索引)
            faces = [
                [0, 1, 2, 3],  # 前面
                [1, 5, 6, 2],  # 右面
                [5, 4, 7, 6],  # 后面
                [4, 0, 3, 7],  # 左面
                [3, 2, 6, 7],  # 上面
                [4, 5, 1, 0]   # 下面
            ]
            
            # 定义每个面的法线
            normals = [
                [0, 0, -1],  # 前面
                [1, 0, 0],   # 右面
                [0, 0, 1],   # 后面
                [-1, 0, 0],  # 左面
                [0, 1, 0],   # 上面
                [0, -1, 0]   # 下面
            ]
            
            # 定义纹理坐标
            tex_coords = [
                [0.0, 0.0],
                [1.0, 0.0],
                [1.0, 1.0],
                [0.0, 1.0]
            ]
            
            # 绑定纹理
            glBindTexture(GL_TEXTURE_2D, self.texture_id)
            
            # 绘制每个面
            for i, face in enumerate(faces):
                glBegin(GL_QUADS)
                glNormal3fv(normals[i])
                for j, vertex_idx in enumerate(face):
                    glTexCoord2fv(tex_coords[j])
                    glVertex3fv(vertices[vertex_idx])
                glEnd()
        
        def resizeGL(self, w, h):
            """处理窗口大小变化"""
            glViewport(0, 0, w, h)
        
        def auto_rotate(self):
            """自动旋转立方体"""
            self.y_rot = (self.y_rot + 0.5) % 360
            self.x_rot = (self.x_rot + 0.2) % 360
            self.update()
        
        def set_light_direction(self, dx, dy, dz):
            """设置光照方向"""
            self.light_direction = np.array([dx, dy, dz])
            norm = np.linalg.norm(self.light_direction)
            if norm > 0:
                self.light_direction /= norm
            self.update()
    
    class MainWindow(QMainWindow):
        def __init__(self):
            super().__init__()
            
            self.setWindowTitle("PyOpenGL 3D立方体 - 带光照、纹理和交互")
            self.setGeometry(100, 100, 800, 800)
            
            # 创建OpenGL部件
            self.gl_widget = GLWidget()
            
            # 创建滑块和标签
            self.slider_x = self.create_slider("X方向", -1.0, 1.0, 0.01, 1.0)
            self.slider_y = self.create_slider("Y方向", -1.0, 1.0, 0.01, 1.0)
            self.slider_z = self.create_slider("Z方向", -1.0, 1.0, 0.01, 1.0)
            
            # 创建布局
            central_widget = QWidget()
            layout = QVBoxLayout()
            layout.addWidget(self.gl_widget)
            layout.addWidget(QLabel("光照方向控制:"))
            layout.addWidget(self.slider_x)
            layout.addWidget(self.slider_y)
            layout.addWidget(self.slider_z)
            central_widget.setLayout(layout)
            
            self.setCentralWidget(central_widget)
            
            # 连接滑块信号
            self.slider_x.valueChanged.connect(self.update_light_direction)
            self.slider_y.valueChanged.connect(self.update_light_direction)
            self.slider_z.valueChanged.connect(self.update_light_direction)
        
        def create_slider(self, label, min_val, max_val, step, init_val):
            """创建带标签的滑块"""
            slider = QSlider(Qt.Horizontal)
            slider.setRange(int(min_val * 100), int(max_val * 100))
            slider.setSingleStep(int(step * 100))
            slider.setValue(int(init_val * 100))
            slider.setTickPosition(QSlider.TicksBelow)
            slider.setTickInterval(20)
            slider.setProperty("label", label)
            return slider
        
        def update_light_direction(self):
            """更新光照方向"""
            dx = self.slider_x.value() / 100.0
            dy = self.slider_y.value() / 100.0
            dz = self.slider_z.value() / 100.0
            self.gl_widget.set_light_direction(dx, dy, dz)
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        window = MainWindow()
        window.show()
        sys.exit(app.exec_())
    

    程序功能说明:

    1. 真实光照效果:

      • 使用OpenGL的固定管线光照系统
      • 包含环境光、漫反射和高光效果
      • 可调节光源方向(方向光)
    2. 交互控制:

      • 三个滑块分别控制X、Y、Z方向的光照
      • 立方体自动旋转展示
      • 支持窗口大小调整
    3. 纹理贴图:

      • 使用PIL动态生成红黄棋盘格纹理
      • 纹理坐标映射到立方体每个面
      • 启用纹理过滤和重复模式
    4. 动态旋转:

      • 使用QTimer实现自动旋转动画
      • 绕X轴和Y轴同时旋转
      • 可调节旋转速度

    使用说明:

    1. 运行程序后,会出现一个带纹理的立方体,并自动旋转
    2. 使用底部的三个滑块控制光照方向:
      • X滑块:控制光源左右方向
      • Y滑块:控制光源上下方向
      • Z滑块:控制光源前后方向
    3. 观察不同光照方向下的立方体表面明暗变化和高光效果
    4. 可以调整窗口大小,立方体会自适应

    技术亮点:

    1. 真实光照模型:

      • 使用OpenGL的光照系统
      • 包含环境光(ambient)、漫反射(diffuse)和镜面反射(specular)
      • 材质属性设置(shininess)
    2. 动态纹理生成:

      • 使用PIL库动态创建棋盘格纹理
      • 避免依赖外部图片文件
    3. 交互控制:

      • 滑块实时控制光照方向
      • 归一化处理确保方向向量有效
    4. 动画系统:

      • QTimer定时器实现平滑动画
      • 双轴旋转增强视觉效果

    扩展建议:

    1. 添加更多光源(如点光源、聚光灯)
    2. 实现鼠标交互控制立方体旋转
    3. 添加更多几何体(球体、圆柱体等)
    4. 实现阴影效果
    5. 添加材质选择功能(金属、塑料等)

    这个程序展示了PyOpenGL在3D渲染方面的强大能力,结合PyQt5的GUI功能,创建了一个功能丰富的3D立方体展示程序。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.