"""Hello World 2D — o mínimo para uma janela OpenGL com projeção ortográfica.

Ponto de partida para o exercício prático. É a versão enxuta do
``pygl/viewer2d`` (sem câmera, pan/zoom nem interação): apenas o esqueleto de
um ``QOpenGLWidget`` que abre uma janela, define a projeção **ortográfica 2D**
com ``gluOrtho2D`` e desenha uma forma no pipeline *fixed-function*.

Execute com:

    python helloworld2d.py

Os três métodos que todo widget OpenGL implementa:
  * ``initializeGL`` — chamado uma vez, configura o estado inicial.
  * ``resizeGL``     — chamado a cada redimensionamento, define o viewport.
  * ``paintGL``      — chamado a cada quadro, desenha a cena.

Ideias para o exercício: mude as cores, adicione mais primitivas
(``GL_TRIANGLES``, ``GL_QUADS``, ``GL_LINE_LOOP``), altere os limites do
``gluOrtho2D`` ou desenhe um polígono a partir de um laço.
"""

from __future__ import annotations

import sys

from PySide6.QtGui import QSurfaceFormat
from PySide6.QtWidgets import QApplication
from PySide6.QtOpenGLWidgets import QOpenGLWidget

from OpenGL.GL import *
from OpenGL.GLU import gluOrtho2D


class HelloWorld2D(QOpenGLWidget):
    """Viewport 2D ortográfico com uma cena estática."""

    def initializeGL(self) -> None:
        # Cor de fundo (RGBA). Repare: NÃO habilitamos GL_DEPTH_TEST —
        # a cena 2D não precisa; a ordem de desenho define a sobreposição.
        glClearColor(0.10, 0.11, 0.13, 1.0)

    def resizeGL(self, w: int, h: int) -> None:
        # O viewport mapeia a cena para toda a área da janela (em pixels).
        glViewport(0, 0, w, max(1, h))

    def paintGL(self) -> None:
        # Limpa apenas o buffer de cor (sem GL_DEPTH_BUFFER_BIT).
        glClear(GL_COLOR_BUFFER_BIT)

        # Projeção ortográfica 2D: define o retângulo do mundo visível
        # (left, right, bottom, top) que preenche a janela.
        glMatrixMode(GL_PROJECTION)
        glLoadIdentity()
        gluOrtho2D(-1.0, 1.0, -1.0, 1.0)

        glMatrixMode(GL_MODELVIEW)
        glLoadIdentity()

        # Um triângulo com um vértice de cada cor (a cor é interpolada).
        glBegin(GL_TRIANGLES)
        glColor3f(0.95, 0.30, 0.30); glVertex2f(-0.6, -0.5)
        glColor3f(0.30, 0.95, 0.30); glVertex2f( 0.6, -0.5)
        glColor3f(0.30, 0.30, 0.95); glVertex2f( 0.0,  0.6)
        glEnd()


def main() -> int:
    # O contexto 2D não precisa de buffer de profundidade (0 bits).
    fmt = QSurfaceFormat()
    fmt.setVersion(2, 1)                       # OpenGL 2.1 (fixed-function)
    # NoProfile é o perfil de compatibilidade, que mantém o fixed-function.
    fmt.setProfile(QSurfaceFormat.OpenGLContextProfile.NoProfile)
    fmt.setDepthBufferSize(0)
    QSurfaceFormat.setDefaultFormat(fmt)

    app = QApplication(sys.argv)
    window = HelloWorld2D()
    window.setWindowTitle("Hello World 2D — gluOrtho2D")
    window.resize(640, 640)
    window.show()
    return app.exec()


if __name__ == "__main__":
    raise SystemExit(main())