Ошибка OpenGL 1286, когда окно свернуто - PullRequest
0 голосов
/ 21 октября 2018

Некоторая информация о том, что я использую:

  • Встроенный графический процессор Ancient Potato (семейство HD-графики Intel)
  • Windows 7
  • OpenGL <= 3.1 </li>
  • Python 3.7.0

Ошибка, которую я получаю мгновенно в тот момент, когда просто сворачиваю окно:

$ python main.py
Traceback (most recent call last):
  File "main.py", line 71, in <module>
    main()
  File "main.py", line 60, in main
    renderer.render(mesh)
  File "...\myproject\renderer.py", line 22, in render
    glDrawElements(GL_TRIANGLES, mesh.indices, GL_UNSIGNED_INT, ctypes.c_void_p(0))
  File "...\OpenGL\latebind.py", line 41, in __call__
    return self._finalCall( *args, **named )
  File "...\OpenGL\wrapper.py", line 854, in wrapperCall
    raise err
  File "...\OpenGL\wrapper.py", line 847, in wrapperCall
    result = wrappedOperation( *cArguments )
  File "...\OpenGL\error.py", line 232, in glCheckError
    baseOperation = baseOperation,
OpenGL.error.GLError: GLError(
        err = 1286,
        baseOperation = glDrawElements,
        pyArgs = (
                GL_TRIANGLES,
                6,
                GL_UNSIGNED_INT,
                c_void_p(None),
        ),
        cArgs = (
                GL_TRIANGLES,
                6,
                GL_UNSIGNED_INT,
                c_void_p(None),
        ),
        cArguments = (
                GL_TRIANGLES,
                6,
                GL_UNSIGNED_INT,
                c_void_p(None),
        )
)

Когда я гуглю OpenGL errorcode 1286 Iобнаружил, что это происходит в контексте OpenGL, когда что-то не так с Framebuffer.Это действительно ничего не говорит мне ...

# renderer.py
class Renderer:
    def __init__(self, colour=(0.0, 0.0, 0.0)):
        self.colour = colour

    @property
    def colour(self):
        return self._colour

    @colour.setter
    def colour(self, new_colour):
        glClearColor(*new_colour, 1.0)
        self._colour = new_colour

    def render(self, mesh):
        glBindVertexArray(mesh.vao_id)
        glBindTexture(GL_TEXTURE_2D, mesh.texture)
        glDrawElements(GL_TRIANGLES, mesh.indices, GL_UNSIGNED_INT, ctypes.c_void_p(0))

    def clear(self):
        glClear(GL_COLOR_BUFFER_BIT)

Поскольку я использую Framebuffers, я МОЖЕТ сделать что-то не так, но у меня все работает так, как я хотел (рендеринг в текстурузатем использую текстуру в качестве источника для рендеринга на квадроцикле, а также в качестве источника для текстуры, которая будет отображаться в следующем кадре, в основном используя графический процессор для манипулирования сетками произвольных данных), я делаю это путем замены FBO вместо замены текстур, если это не ясно изкод:

# bufferedtexture.py (The place where I use Frame Buffer)
class BufferedTexture:
    def __init__(self, width, height):
        self._width = width
        self._height = height
        self._textures = glGenTextures(2)
        self._buffers = glGenFramebuffers(2)
        self._previous_buffer = 0
        self._current_buffer = 1

        self.init_buffer(0)
        self.init_buffer(1)

    @property
    def width(self):
        return self._width

    @property
    def height(self):
        return self._height

    @property
    def buffer(self):
        return self._buffers[self._current_buffer]

    @property
    def texture(self):
        return self._textures[self._previous_buffer]

    def init_buffer(self, index):
        glBindFramebuffer(GL_FRAMEBUFFER, self._buffers[index])
        glBindTexture(GL_TEXTURE_2D, self._textures[index])
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, ctypes.c_void_p(0))
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, self._textures[index], 0)

    def set_texture_data(self, image_data):
        glBindTexture(GL_TEXTURE_2D, self.texture)
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, self.width, self.height, 0, GL_RGBA, GL_UNSIGNED_BYTE, image_data)

    def swap_buffers(self):
        self._previous_buffer = self._current_buffer
        self._current_buffer = (self._current_buffer + 1) % 2

    def enable(self):
        glBindFramebuffer(GL_FRAMEBUFFER, self.buffer)

    def disable(self):
        glBindFramebuffer(GL_FRAMEBUFFER, 0)

    def destroy(self):
        glDeleteFramebuffers(self._buffers)
        glDeleteTextures(self._textures)

И я использую все так:

# main loop
while not window.should_close: # glfwWindowShouldClose(self.hwnd)
    shader.enable() # glUseProgram(self._program)

    buff.enable() # BufferedTexture object, source above
    renderer.clear() # Renderer object, source above
    renderer.render(mesh) # By the way, mesh is just a Quad, nothing fancy
    buff.disable() # Tells driver that we will be drawing to screen again

    buff.swap_buffers()
    mesh.texture = buff.texture # give quad the texture that was rendered off-screen
    renderer.clear()
    renderer.render(mesh)

    window.swap_buffers() # glfwSwapBuffers(self.hwnd)
    window.poll_events() # glfwPollEvents()

Я даже не знаю, что может быть не так, опять же, это происходит только тогда, когда я сверну окно, иначеЯ могу оставить его работать часами, и все нормально, но как только я его уменьшу, он умирает ...

Я даже попытался добавить

assert (glCheckFramebufferStatus (GL_FRAMEBUFFER) == GL_FRAMEBUFFER_COMPLETE) assert(glGetError () == GL_NO_ERROR)

в конце BufferedTexture.init_buffer, чтобы быстро проверить, является ли это проблемой с самим FBO, но ...

$ python main.py
<no assertion errors to be found>
<same error once I minimise>

TL; DR

  1. Все отображается правильно, как задумано;
  2. не заметил никаких проблем с производительностью, никаких ошибок не выдается или проглатывается, пока я инициализирую glfw иЧто-то с openGL, я вызываю RuntimeError самостоятельно, когда PyOpenGL просто будет в порядке с чем-то, что идет не так (по какой-то причине), даже не замечая этого;
  3. Сбои программы с OpenGL: 1286, когда я минимизирую окно, теряется фокусничего, только когда я его минимизирую ...

Отправить справку.

РЕДАКТИРОВАТЬ:

mesh = Mesh(indices, vertices, uvs)

buff = BufferedTexture(800, 600)

with Image.open("cat.jpg") as image:
    w, h = image.size # the image is 800x600
    img_data = np.asarray(image.convert("RGBA"), np.uint8)
    buff.set_texture_data(img_data[::-1])
    buff.swap_buffers()
    buff.set_texture_data(img_data[::-1])

mesh.texture = buff.texture # this is just GL_TEXTURE_2D object ID
buff.disable()
while not window.should_close:
    shader.enable()

    #buff.enable()
    #renderer.clear()
    #renderer.render(mesh)
    #buff.disable()

    #buff.swap_buffers()
    #mesh.texture = buff.texture
    renderer.clear()
    renderer.render(mesh)

    window.swap_buffers()
    window.poll_events()

Как только я полностью перестаю использовать буферы, он работает как задумано,Надеюсь, что-то не так с моим кодом.

1 Ответ

0 голосов
/ 21 октября 2018

Кто-то указал (но удалил свои ответы / комментарии по любой причине), что размер окна становится 0, 0, когда свернут, и это действительно так, чтобы предотвратить сбой и трату ресурсов, когда окно свернуто, я сделал это:

Создание и регистрация обратного вызова для изменения размера окна, это было очень легко, так как я использую только одно окно, и я уже настроил его как одноэлементное, обратный вызов просто сообщает окну, должно ли оно спать илинет.

def callback(window, width, height):
    Window.instance.sleeping = width == 0 or height == 0

(очевидно) зарегистрировал обратный вызов для моего собственного окна:

glfwSetFramebufferSizeCallback(self.handle, callback)

Я ничего не делаю, кроме событий опроса, когда окно "спит":

while not window.should_close:
    window.poll_events()
    if window.sleeping:
        time.sleep(0.01)
        continue

    shader.enable()

    buff.enable()
    renderer.clear()
    renderer.render(mesh)
    buff.disable()

    buff.swap_buffers()
    mesh.texture = buff.texture
    renderer.clear()
    renderer.render(mesh)

    window.swap_buffers()
...