PyOpenGL如何通过glGenBuffers实现它的神奇之处？

Question

我试图回避PyOpenGL的缓慢且高开销的后端前端,并特别使用原始后端实现......

我遇到的问题是我似乎无法弄清楚前端如何将后端功能glGenBuffers( n, buffers )转化为buffers = glGenBuffers( n ).

我想知道的是我将什么传递给buffers后端函数的参数？

Answer 1

以下是使用创建一个或多个缓冲区的一些示例glGenBuffers。如果必须使用像 那样的函数调用glGenBuffers(n, buffers)，则可以直接使用 ctypes 或使用 PyOpenGL 的GLint，它包装了 ctypes 数据类型。

import ctypes
import numpy as np
from OpenGL.GL import *
import pygame

pygame.init()
screen = pygame.display.set_mode((800,600), pygame.OPENGL | pygame.DOUBLEBUF) #initialize OpenGL

py_id = glGenBuffers(1) #typical way to generate a single index
c_id = ctypes.c_int() #using ctypes to generate a second index
glGenBuffers(1, c_id)
gl_id = GLint() #using GL wrapper to generate a third index
glGenBuffers(1, gl_id)
print py_id, c_id.value, gl_id.value #should print 1 2 3

n = 10
py_list = glGenBuffers(n) #typical way to generate multiple indices
c_list = (ctypes.c_int * n)() #using ctypes to generate multiple indices
glGenBuffers(n, c_list)
gl_list = (GLint * n)() #using GL wrapper to generate multiple indices
glGenBuffers(n, gl_list)
print py_list, list(py_list) #note the default is a numpy array!
print np.array(c_list), list(c_list)
print np.array(gl_list), list(gl_list)

顺便说一句，我不确定这样做有什么好处。我怀疑方便的包装器glGenBuffers真的太慢了​​，以至于buffers = glGenBuffers(n)应该避免像这样的典型方法。我真的很想知道这是否是您的性能瓶颈。希望这可以帮助！

更新： 在您对 的开销发表评论后__call__，我想我会及时测试它。这是我的代码，每个定时块旁边都包含以秒为单位的结果：

import ctypes
import numpy as np
from OpenGL.GL import *
import pygame
import timeit

pygame.init()
screen = pygame.display.set_mode((800,600), pygame.OPENGL | pygame.DOUBLEBUF) #initialize OpenGL

def test(func, repeats):
    start_time = timeit.default_timer()
    for i in range(repeats):
        func()
    elapsed = timeit.default_timer() - start_time
    print elapsed

def func1():
    py_id = glGenBuffers(1)

def func2():
    c_id = ctypes.c_int()
    glGenBuffers(1, c_id)

def func3():
    gl_id = GLint()
    glGenBuffers(1, gl_id)

def func4():
    n = 1
    py_list = glGenBuffers(n)

def func5():
    n = 1
    c_list = (ctypes.c_int * n)()
    glGenBuffers(n, c_list)

def func6():
    n = 1
    gl_list = (GLint * n)()
    glGenBuffers(n, gl_list)

def func7():
    n = 100
    py_list = glGenBuffers(n)

def func8():
    n = 100
    c_list = (ctypes.c_int * n)()
    glGenBuffers(n, c_list)

def func9():
    n = 100
    gl_list = (GLint * n)()
    glGenBuffers(n, gl_list)

test(func1, 1000000)#4.12597930903
test(func2, 1000000)#5.2951610055
test(func3, 1000000)#5.17853478658
test(func4, 1000000)#4.06362866711
test(func5, 1000000)#3.45259988251
test(func6, 1000000)#3.43240155354
test(func7, 1000000)#4.128162421
test(func8, 1000000)#3.57384911559
test(func9, 1000000)#3.52125689729

从这些结果来看，您生成的缓冲区数量似乎不会产生太大影响，因此即使 n=1，也应始终将其视为列表。不太确定为什么会出现这种情况，也许在这种情况下幕后正在进行某种转换。奇怪的是，看起来 GLint() 的性能比直接使用 ctypes 更好，这对我来说也毫无意义。不管怎样，纯Python版本确实执行最慢，我想对于其他更复杂的OpenGL函数，差异可能会更大！