Python 小行星程序使用间接绘制、glMultiDrawArraysIndirect不渲染和绘制空白

我正在移植一个程序来学习Superbible OpenGL第7版中的间接绘制。这个程序应该每秒渲染近10亿个顶点，并且不会因为使用现代OpenGL技术

glMultiDrawArraysIndirect

而导致绘制命令提交速度出现瓶颈。任何帮助都将是无效的谢谢。多谢各位

这是预期输出：

更新：我非常感谢拉比76的回答给了我极大的帮助。代码非常好，关于为什么这样做的见解令人耳目一新。非常感谢你！程序正在按预期显示小行星场

使用间接绘图时，程序似乎运行得更快

我同意，在python中似乎没有将enum用作类。另外，最好不要这样做

依赖文件：zip中有一个更新的sbmloader

Asternos.py的源代码

#!/usr/bin/python3

import sys
import time
import ctypes

fullscreen = True

sys.path.append("./shared")

from sbmloader import SBMObject    # location of sbm file format loader

from sbmath import m3dDegToRad, m3dRadToDeg, m3dTranslateMatrix44, m3dRotationMatrix44, m3dMultiply, m3dOrtho, m3dPerspective, rotation_matrix, translate, m3dScaleMatrix44, \
    scale, m3dLookAt, normalize

try:
    from OpenGL.GLUT import *
    from OpenGL.GL import *
    from OpenGL.GLU import *
    from OpenGL.raw.GL.ARB.vertex_array_object import glGenVertexArrays, glBindVertexArray
except:
    print ('''
    ERROR: PyOpenGL not installed properly.
        ''')
    sys.exit()

from array import array
from enum import Enum

import numpy as np 
from math import cos, sin 
identityMatrix = [1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1]


render_program = GLuint(0)

myobject = SBMObject()

indirect_draw_buffer = GLuint(0)
draw_index_buffer = GLuint(0)

class uniforms():
    time = GLint(0)
    view_matrix  = GLint(0)
    proj_matrix = GLint(0)
    viewproj_matrix  = GLint(0)

uniform = uniforms()


mode = 1
MODE_MULTIDRAW = 1
MODE_SEPARATE_DRAWS = 2


paused = False
vsync = False

NUM_DRAWS           = 50000


class DrawArraysIndirectCommand:
    count = GLuint(0)
    primCount = GLuint(0)
    first = GLuint(0)
    baseInstance = GLuint(0)




def shader_load(filename, shader_type):

    result = GLuint(0)

    with open ( filename, "rb") as data:

        result = glCreateShader(shader_type)

        glShaderSource(result, data.read() )

    glCompileShader(result)

    return result


def link_from_shaders(shaders, shader_count, delete_shaders, check_errors=False):

    program = GLuint(0)

    program = glCreateProgram()

    for i in range(0, shader_count):
        glAttachShader(program, shaders[i]);

    glLinkProgram(program);

    if (delete_shaders):

        for i in range(0, shader_count):
            glDeleteShader(shaders[i]);

    return program



def load_shaders():

    global render_program
    global uniform

    shaders = [GLuint(0), GLuint(0)]

    shaders[0] = shader_load("render.vs.glsl", GL_VERTEX_SHADER)
    shaders[1] = shader_load("render.fs.glsl", GL_FRAGMENT_SHADER)

    if (render_program):
        glDeleteProgram(render_program)

    render_program = link_from_shaders(shaders, 2, True)

    uniform.time            = glGetUniformLocation(render_program, "time")
    uniform.view_matrix     = glGetUniformLocation(render_program, "view_matrix")
    uniform.proj_matrix     = glGetUniformLocation(render_program, "proj_matrix")
    uniform.viewproj_matrix = glGetUniformLocation(render_program, "viewproj_matrix")




class Scene:

    def __init__(self, width, height):

        global myobject
        global indirect_draw_buffer
        global draw_index_buffer

        i=0

        load_shaders()



        myobject.load("asteroids.sbm")

        sizeOfDrawIndCmd = ctypes.sizeof(GLuint*4)

        glGenBuffers(1, indirect_draw_buffer)
        glBindBuffer(GL_DRAW_INDIRECT_BUFFER, indirect_draw_buffer)
        glBufferData(GL_DRAW_INDIRECT_BUFFER,
                        NUM_DRAWS * sizeOfDrawIndCmd,
                        None,
                        GL_STATIC_DRAW)


        cmd_memory = glMapBufferRange(GL_DRAW_INDIRECT_BUFFER,
                                0,
                                NUM_DRAWS * sizeOfDrawIndCmd,
                                GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_BUFFER_BIT)


        cmd_buffer = ((GLuint * 4) * NUM_DRAWS).from_address(cmd_memory) 

        for i in range(0, NUM_DRAWS):
            first, count = myobject.get_sub_object_info(i % myobject.get_sub_object_count())
            cmd_buffer[i][0] = count
            cmd_buffer[i][1] = 1
            cmd_buffer[i][2] = first
            cmd_buffer[i][3] = i

        glUnmapBuffer(GL_DRAW_INDIRECT_BUFFER)

        glBindVertexArray(myobject.get_vao())

        glGenBuffers(1, draw_index_buffer)
        glBindBuffer(GL_ARRAY_BUFFER, draw_index_buffer)
        glBufferData(GL_ARRAY_BUFFER,
                        NUM_DRAWS * ctypes.sizeof(GLuint),
                        None,
                        GL_STATIC_DRAW)

        draw_index = glMapBufferRange(GL_ARRAY_BUFFER,
                                        0,
                                        NUM_DRAWS * ctypes.sizeof(GLuint),
                                        GL_MAP_WRITE_BIT |
                                        GL_MAP_INVALIDATE_BUFFER_BIT)


        int_array = (GLuint * NUM_DRAWS).from_address(draw_index) 

        for i in range(0, NUM_DRAWS):
            int_array[i] = i

        glUnmapBuffer(GL_ARRAY_BUFFER)

        glVertexAttribIPointer(10, 1, GL_UNSIGNED_INT, 0, None)
        glVertexAttribDivisor(10, 1)
        glEnableVertexAttribArray(10)

        glEnable(GL_DEPTH_TEST)
        glDepthFunc(GL_LEQUAL)

        glEnable(GL_CULL_FACE)




    def display(self):

        global myobject

        currentTime = time.time()

        j=0
        one = 1.0;
        black = [ 0.0, 0.0, 0.0, 0.0 ]


        last_time = 0.0;
        total_time = 0.0;

        if (paused == False):
            total_time += (currentTime - last_time)
        last_time = currentTime

        t = float(total_time)
        i = int(total_time * 3.0)

        glViewport(0, 0, self.width, self.height)
        glClearBufferfv(GL_COLOR, 0, black)
        glClearBufferfv(GL_DEPTH, 0, one)

        view_matrix = (GLfloat * 16)(*identityMatrix)
        view_matrix = m3dLookAt([100.0 * cos(t * 0.023), 100.0 * cos(t * 0.023), 300.0 * sin(t * 0.037) - 600.0],
                                [0.0, 0.0, 260.0], 
                                normalize([0.1 - cos(t * 0.1) * 0.3, 1.0, 0.0]))

        proj_matrix = (GLfloat * 16)(*identityMatrix)
        proj_matrix = m3dPerspective(m3dDegToRad(50.0), float(self.width) / float(self.height), 1.0, 2000.0)

        glUseProgram(render_program)

        glUniform1f(uniform.time, t)
        glUniformMatrix4fv(uniform.view_matrix, 1, GL_FALSE, view_matrix)
        glUniformMatrix4fv(uniform.proj_matrix, 1, GL_FALSE, proj_matrix)
        glUniformMatrix4fv(uniform.viewproj_matrix, 1, GL_FALSE, m3dMultiply(proj_matrix , view_matrix))

        glBindVertexArray(myobject.get_vao());


        if (mode == MODE_MULTIDRAW):

            glMultiDrawArraysIndirect(GL_TRIANGLES, None, NUM_DRAWS, 0);

        elif (mode == MODE_SEPARATE_DRAWS):

            for j in range(0, NUM_DRAWS):

                first, count = myobject.get_sub_object_info(j % myobject.get_sub_object_count())
                glDrawArraysInstancedBaseInstance(GL_TRIANGLES,
                                                  first,
                                                  count,
                                                  1, j)

        glutSwapBuffers()

    def reshape(self, width, height):
        self.width = width
        self.height = height

    def keyboard(self, key, x, y ):
        global fullscreen
        global paused
        global mode
        global vsync

        print ('key:' , key)
        if key == b'\x1b': # ESC
            sys.exit()

        elif key == b'f' or key == b'F': #fullscreen toggle

            if (fullscreen == True):
                glutReshapeWindow(512, 512)
                glutPositionWindow(int((1360/2)-(512/2)), int((768/2)-(512/2)))
                fullscreen = False
            else:
                glutFullScreen()
                fullscreen = True

        elif key == b'p' or key == b'P': #fullscreen toggle
            paused = not paused   # a toggle technique

        elif key == b'v' or key == b'V': #fullscreen toggle
            vsync = not vsync  # a toggle technique
            #setVsync(vsync)


        elif key == b'd' or key == b'D': #fullscreen toggle

                mode += 1
                if (mode  > 2):
                    mode = 1


        print('done')

    def init(self):
        pass

    def timer(self, blah):

        glutPostRedisplay()
        glutTimerFunc( int(1/60), self.timer, 0)
        time.sleep(1/60.0)




if __name__ == '__main__':
    start = time.time()

    glutInit()


    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH)

    glutInitWindowSize(512, 512)

    w1 = glutCreateWindow('OpenGL SuperBible - Asteroids')
    glutInitWindowPosition(int((1360/2)-(512/2)), int((768/2)-(512/2)))

    fullscreen = False
    many_cubes = False
    #glutFullScreen()

    scene = Scene(512,512)
    glutReshapeFunc(scene.reshape)
    glutDisplayFunc(scene.display)
    glutKeyboardFunc(scene.keyboard)

    glutIdleFunc(scene.display)
    #glutTimerFunc( int(1/60), scene.timer, 0)

    scene.init()

    glutMainLoop()

---

移植程序的来源：

python函数和方法的参数不是in-out参数，它们只是输入。但是您可以从函数返回元组。更改方法

。在类
SBMObject
中获取子对象\u info（）

：

类SBMObject:
def获取子对象信息（自身、索引）：
如果（索引>=len（子对象））：
返回0，0
返回子对象[index]。首先，子对象[index]。计数

这样称呼它：

首先，count=myobject.get\u sub\u object\u info（j%myobject.get\u sub\u object\u count（））

如果要创建一个16字节结构，像下面的C++结构< /p>

typedef结构{
单位计数；
单位瞬时计数；
uint优先；
uint基本实例；
}DrawArraysIndirectCommand；

这样的python类就做不到这一点

类DrawArraySindirect命令：
计数=GLuint（0）
primCount=GLuint（0）
first=GLuint（0）
baseInstance=GLuint（0）

“DrawArraysIndirectCommand”的16字节元素可由

GLuint*4

生成，其大小为：

sizeOfDrawIndCmd=ctypes.sizeof（GLuint*4）

返回指向已分配内存区域的指针，使用函数“包装”二维数组。
看

sizeOfDrawIndCmd=ctypes.sizeof（GLuint*4）
glGenBuffers（1，间接提取缓冲区）
glBindBuffer（GL\U DRAW\U间接\U缓冲区，间接\U DRAW\U缓冲区）
glBufferData（GL\U DRAW\U间接\U缓冲区，
NUM_DRAWS*sizeOfDrawIndCmd，
没有一个
总帐（静态图）
cmd\u memory=glMapBufferRange（GL\u DRAW\u INDIRECT\u BUFFER，
0,
NUM_DRAWS*sizeOfDrawIndCmd，
GL_映射_写入_位| GL_映射_无效_缓冲_位）
cmd_buffer=（（GLuint*4）*NUM_DRAWS）。从_地址（cmd_内存）
对于范围内的i（0，NUM_绘制）：
首先，count=myobject.get\u sub\u object\u info（i%myobject.get\u sub\u object\u count（））
cmd_缓冲区[i][0]=计数
cmd_缓冲区[i][1]=1
cmd_buffer[i][2]=第一个
cmd_缓冲区[i][3]=i
glUnmapBuffer（GL_绘制_间接_缓冲区）

这些属性具有整数数据类型（

GL\u UNSIGNED\u INT

）。您必须创建具有正确格式的缓冲区。类型必须是

GLuint

（或

ctypes.c_uint

），而不是

ctypes.c_float

：

int\u数组=（（ctypes.c\u float）*NUM\u DRAWS）。from\u地址（draw\u索引）

int\u数组=（GLuint*NUM\u绘制）。从地址（绘制索引）

并使用

ctypes.sizeof（GLuint）

而不是

sys.getsizeof（GLuint）

：

glGenBuffers（1，draw\u index\u buffer）
glBindBuffer（GL\u数组\u缓冲区、draw\u索引\u缓冲区）
glBufferData（GL_数组_缓冲区，
NUM_绘制*ctypes.sizeof（GLuint），
没有一个
总帐（静态图）
绘制索引=glMapBufferRange（GL\U数组\U缓冲区，
0,
NUM_绘制*ctypes.sizeof（GLuint），
GL\U映射\U写入\U位|
GL\U映射\U无效\U缓冲\U位）
int_数组=（GLuint*NUM_DRAWS）。from_地址（draw_索引）
对于范围内的i（0，NUM_绘制）：
int_数组[i]=i
glUnmapBuffer（GL_数组_缓冲区）

---

---

精彩的代码，非常感谢！！！是的，我知道哪里出错了，从现在起我将使用ctypes.sizeof（）。对SBMObject的修复非常好。非常感谢。我会马上更新源代码。

This is something completely different in the internal structure and memory layout.  
Further note, that [`sys.getsizeof()`](https://docs.python.org/3/library/sys.html) is not the same as [`ctypes.sizeof()`](https://docs.python.org/3/library/ctypes.html). You can vereify this with ease by:

```py
print(sys.getsizeof(GLuint))
print(ctypes.sizeof(GLuint))