Python 在opengl中是否有任何方法可以循环旋转二维线

我想对这些二维线条进行循环旋转，这样当鼠标滚动时，线条会向上或向下移动。例如：-如果鼠标滚轮向上滚动，则顶部的线条将移动到底部，所有线条将向上移动。 我可以通过改变数据来做到这一点，但这是一个缓慢的过程。 有没有办法在OpenGl中使用着色器来实现这一点

代码：-

import OpenGL.GL as gl
import OpenGL.arrays.vbo as glvbo
from PyQt5.Qt import *
import numpy as np
import sys
import copy


VS1 = '''
#version 450

layout(location = 0) in vec2 position;

uniform float right;
uniform float bottom;
uniform float left;
uniform float top;

void main() {
    const float far = 1.0;
    const float near = -1.0;

    mat4 testmat = mat4(
            vec4(2.0 / (right - left), 0, 0, 0),
            vec4(0, 2.0 / (top - bottom), 0, 0),
            vec4(0, 0, -2.0 / (far - near), 0),
            vec4(-(right + left) / (right - left), -(top + bottom) / (top - bottom), -(far + near) / (far - near), 1)
    );

    gl_Position = testmat * vec4(position.x, position.y, 0., 1.);

}
'''

FS1 = '''
#version 450
// Output variable of the fragment shader, which is a 4D vector containing the
// RGBA components of the pixel color.

uniform vec3 triangleColor;
out vec4 outColor;

void main()
{   

    outColor = vec4(triangleColor, 1.0);

}


'''


def compile_vertex_shader(source):
    """Compile a vertex shader from source."""
    vertex_shader = gl.glCreateShader(gl.GL_VERTEX_SHADER)
    gl.glShaderSource(vertex_shader, source)
    gl.glCompileShader(vertex_shader)
    # check compilation error
    result = gl.glGetShaderiv(vertex_shader, gl.GL_COMPILE_STATUS)
    if not (result):
        raise RuntimeError(gl.glGetShaderInfoLog(vertex_shader))
    return vertex_shader


def compile_fragment_shader(source):
    """Compile a fragment shader from source."""
    fragment_shader = gl.glCreateShader(gl.GL_FRAGMENT_SHADER)
    gl.glShaderSource(fragment_shader, source)
    gl.glCompileShader(fragment_shader)

    result = gl.glGetShaderiv(fragment_shader, gl.GL_COMPILE_STATUS)
    if not (result):
        raise RuntimeError(gl.glGetShaderInfoLog(fragment_shader))
    return fragment_shader


def link_shader_program(vertex_shader, fragment_shader):
    """Create a shader program with from compiled shaders."""
    program = gl.glCreateProgram()
    gl.glAttachShader(program, vertex_shader)
    gl.glAttachShader(program, fragment_shader)
    gl.glLinkProgram(program)

    result = gl.glGetProgramiv(program, gl.GL_LINK_STATUS)
    if not (result):
        raise RuntimeError(gl.glGetProgramInfoLog(program))
    return program


class GLPlotWidget(QGLWidget):

    def __init__(self, *args):
        super(GLPlotWidget, self).__init__()
        self.width, self.height = 100, 100
        self.we = np.load('two.npy', mmap_mode='r')
        self.e = copy.deepcopy(self.we[:, :, :])
        self.w = copy.deepcopy(self.we[:, :, :])
        for i in range(0, 24):
            self.w[i, :, 1] = self.e[i, :, 1] - np.array(9999 * i)
        # self.e[:, :, 1] = np.interp(self.e[:, :, 1], (self.e[:, :, 1].min(), self.e[:, :, 1].max()),
        #                                                                           (-1, 1))
        #
        # self.e[:, :, 0] = np.interp(self.e[:, :, 0], (self.e[:, :, 0].min(), self.e[:, :, 0].max()),
        #                                                                           (-1, +1))
        self.right, self.left, self.top, self.bottom = self.e[0, -1, 0], self.e[
            0, 0, 0], self.e[0, :, 1].max(), self.e[-1, :, 1].min()
        self.vbo = glvbo.VBO(self.e)
        self.count = self.vbo.shape[1]
        self.scroll = 0
        self.number_of_arm = 24
        self.sensor_list_const = np.array(range(0, self.number_of_arm))
        self.sensor_list_roll = copy.deepcopy(self.sensor_list_const)
        self.showMaximized()

    def initializeGL(self):

        vs = compile_vertex_shader(VS1)
        fs = compile_fragment_shader(FS1)
        self.shaders_program_plot = link_shader_program(vs, fs)

    def ortho_view(self, i):

        right = gl.glGetUniformLocation(i, "right")
        gl.glUniform1f(right, self.right)

        left = gl.glGetUniformLocation(i, "left")
        gl.glUniform1f(left, self.left)

        top = gl.glGetUniformLocation(i, "top")
        gl.glUniform1f(top, self.top)

        bottom = gl.glGetUniformLocation(i, "bottom")
        gl.glUniform1f(bottom, self.bottom)

    def paintGL(self):
        self.resizeGL(self.width, self.height)
        gl.glClearColor(0.75, 0.75, 0.75, 0)
        gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
        gl.glEnable(gl.GL_DEPTH_TEST)

        self.vbo.bind()
        gl.glEnableVertexAttribArray(0)
        gl.glVertexAttribPointer(0, 2, gl.GL_FLOAT, gl.GL_FALSE, 0, None)
        gl.glUseProgram(self.shaders_program_plot)
        self.ortho_view(self.shaders_program_plot)
        uni_color = gl.glGetUniformLocation(self.shaders_program_plot, "triangleColor")

        for i in range(0, self.vbo.data.shape[0]):
            gl.glUniform3f(uni_color, 0, 0, 0)
            gl.glLineWidth(1)
            gl.glDrawArrays(gl.GL_LINE_STRIP, i * self.count, self.count)
        self.vbo.unbind()
        # self.greyscale()
        # gl.glUseProgram(0)

    def reset_vbo(self):
        self.wex = copy.deepcopy(self.w)

        for i, j in zip(self.sensor_list_roll, self.sensor_list_const):
            self.wex[j, :, 1] = self.w[j, :, 1] + np.array(9999 * (self.number_of_arm - i))

        self.vbo.set_array(self.wex)
        self.right, self.left, self.top, self.bottom = self.wex[0, -1, 0], self.wex[
            0, 0, 0], self.wex[:, :, 1].max(), self.wex[:, :, 1].min()
        self.update()

    def resizeGL(self, width, height):
        self.width, self.height = width, height
        gl.glViewport(0, 0, width, height)

    def wheelEvent(self, *args, **kwargs):
        event = args[0]
        # print(event.angleDelta().y())
        if event.angleDelta().y() > 0:

            self.scroll = self.scroll - 1

        else:
            self.scroll = self.scroll + 1

        if self.scroll > self.number_of_arm - 1 or self.scroll < -(self.number_of_arm - 1):
            self.scroll = 0
        self.sensor_list_roll = np.roll(self.sensor_list_const, self.scroll)
        # self.patch_move(event)
        self.reset_vbo()


def main():
    app = QApplication(sys.argv)
    editor = GLPlotWidget()
    editor.show()
    sys.exit(app.exec_())


if __name__ == '__main__':
    main()

将OpenGL.GL导入为GL
将OpenGL.arrays.vbo作为glvbo导入
从PyQt5.Qt导入*
将numpy作为np导入
导入系统
导入副本
VS1=''
#版本450
vec2位置的布局（位置=0）；
统一浮动权；
均匀浮底；
均匀浮动左；
均匀浮顶；
void main（）{
常数浮点远=1.0；
常数浮动近=-1.0；
mat4测试MAT=mat4(
vec4（2.0/（右-左），0,0,0），
vec4（0,2.0/（顶部-底部），0,0），
vec4（0,0，-2.0/（远-近），0），
vec4（-（右+左）/（右-左），-（上+下）/（上-下），-（远+近）/（远-近），1）
);
gl_位置=testmat*vec4（位置x，位置y，0,1.）；
}
'''
FS1=“”
#版本450
//片段着色器的输出变量，它是包含
//像素颜色的RGBA组件。
均匀vec3三角色；
外显vec4外显色；
void main（）
{   
outColor=vec4（三角形颜色，1.0）；
}
'''
def编译_顶点_着色器（源）：
“”“从源代码编译顶点着色器。”“”
顶点着色器=gl.glCreateShader（gl.gl\u顶点着色器）
gl.glShaderSource（顶点着色器，源）
gl.glCompileShader（顶点着色器）
#检查编译错误
结果=gl.glGetShaderiv（顶点着色器，gl.gl编译状态）
若否（结果）：
引发运行时错误（gl.glGetShaderInfoLog（顶点着色器））
返回顶点着色器
def compile_fragment_着色器（源代码）：
“”“从源代码编译片段着色器。”“”
片段\u着色器=gl.glCreateShader（gl.gl\u片段\u着色器）
gl.glShaderSource（片段着色器，源）
gl.glCompileShader（片段着色器）
结果=gl.glGetShaderiv（片段着色器，gl.gl编译状态）
若否（结果）：
引发运行时错误（gl.glGetShaderInfoLog（片段着色器））
返回片段着色器
def link_着色器_程序（顶点着色器、片段着色器）：
“”“使用已编译的着色器创建着色器程序。”“”
program=gl.glCreateProgram（）
gl.glAttachShader（程序，顶点着色器）
gl.glAttachShader（程序，片段着色器）
gl.GLLINK程序（程序）
结果=gl.glGetProgramiv（程序，gl.gl链接状态）
若否（结果）：
引发运行时错误（gl.glGetProgramInfoLog（程序））
返回程序
类GLPlotWidget（QGLWidget）：
定义初始化（self，*args）：
超级（GLPlotWidget，self）。\uu初始化
自宽、自高=100100
self.we=np.load（'two.npy'，mmap_mode='r'）
self.e=copy.deepcopy（self.we[：，：，：]）
self.w=copy.deepcopy（self.we[：，：，：]）
对于范围（0,24）内的i：
self.w[i，：，1]=self.e[i，：，1]-np.array（9999*i）
#self.e[：，：，1]=np.interp（self.e[：，：，1]，（self.e[：，：，1].min（），self.e[：，：，1].max（），
#                                                                           (-1, 1))
#
#self.e[：，：，0]=np.interp（self.e[：，：，0]，（self.e[：，：，0].min（），self.e[：，：，0].max（），
#                                                                           (-1, +1))
self.right，self.left，self.top，self.bottom=self.e[0，-1,0]，self.e[
0,0,0]，self.e[0，：，1].max（），self.e[-1，：，1].min（）
self.vbo=glvbo.vbo（self.e）
self.count=self.vbo.shape[1]
self.scroll=0
臂的自身数量=24
self.sensor\u list\u const=np.array（范围（0，self.number\u手臂））
self.sensor\u list\u roll=copy.deepcopy（self.sensor\u list\u const）
self.showmized（）
def初始化EGL（自身）：
vs=编译顶点着色器（VS1）
fs=编译片段着色器（FS1）
self.shaders\u program\u plot=link\u shader\u program（vs，fs）
def正交视图（自我，i）：
右=gl.glGetUniformLocation（i，“右”）
glUniform1f总帐（右，self.right）
左=gl.glGetUniformLocation（i，“左”）
glUniform1f总图（左，自左）
top=gl.glGetUniformLocation（i，“top”）
gl.glUniform1f（顶部，自顶部）
底部=gl.glGetUniformLocation（i，“底部”）
gl.glUniform1f（底部，自底部）
def paintGL（自我）：
self.resizeGL（self.width、self.height）
gl.glClearColor（0.75,0.75,0.75,0）
gl.glClear（gl.gl_颜色_缓冲_位| gl.gl_深度_缓冲_位）
glEnable总包（总包深度测试）
self.vbo.bind（）
gl.GlenableVertexAttributeArray（0）
gl.glVertexAttribute指针（0，2，gl.gl\u浮点，gl.gl\u假，0，无）
gl.glUseProgram（self.shaders\u program\u plot）
self.ortho_视图（self.shaders_程序_绘图）
uni_color=gl.glGetUniformLocation（self.shaders\u program\u plot，“三角形颜色”）
对于范围内的i（0，self.vbo.data.shape[0]）：
gl.glUniform3f（单色，0,0,0）
总帐.总帐线宽（1）
gl.glDrawArray（gl.gl\u LINE\u STRIP，i*self.count，self.count）
self.vbo.unbind（）文件
#self.greyscale（）
#gl.glUseProgram（0）
def重置_vbo（自身）：
self.wex=copy.deepcopy（self.w）
对于拉链中的i，j（self.sensor\u list\u roll，self.sensor\u list\u const）：
self.wex[j，：，1]=self.w[j，：，1]+np.array（9999*（self.number_of_arm-i））
self.vbo.set_数组（self.wex）
self.right，self.left，self.top，self.bottom=self.wex[0，-1,0]，self.wex[
0,0,0]，self.wex[：，：，1].max（），self.wex[：，：，1].min（）
self.update（）
def resizeGL（自身、宽度、高度）：
self.width，self.height=宽度，高度
gl.glViewport（0，0，宽度，高度）
def wheelEvent（自身、*args、**kwargs）：
事件=args[0]
#印刷品