post

Primitivos de salida

primitivos diverse children learning biology on whiteboard
Photo by Katerina Holmes on Pexels.com

Los primitivos de salida proporcionan las bases para la creación y manipulación de gráficos en sistemas de gráficos por computadora. Se utilizan en conjunto con algoritmos de representación, transformación y renderización para generar imágenes visuales que pueden variar desde gráficos en 2D hasta entornos 3D más elaborados

Ejemplo en python

Para que este ejemplo funcione se requiere de la librería pyopengl este instalada, para ello se ejecuta el siguiente comando en la terminal:

pip install PyOpenGL
from OpenGL.GL import *
from OpenGL.GLUT import *

# Función para dibujar puntos
def draw_points():
    glClear(GL_COLOR_BUFFER_BIT)  # Borra el búfer de color

    glBegin(GL_POINTS)  # Inicia el modo de puntos
    glColor3f(1.0, 0.0, 0.0)  # Color rojo

    # Dibuja varios puntos
    glVertex2f(0.0, 0.0)
    glVertex2f(0.2, 0.2)
    glVertex2f(-0.2, -0.2)

    glEnd()  # Finaliza el modo de puntos

    glFlush()  # Procesa los comandos OpenGL

# Función principal
def main():
    glutInit(sys.argv)
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB)
    glutInitWindowSize(400, 400)
    glutInitWindowPosition(100, 100)
    glutCreateWindow(b'Ejemplo de Primitivos de Salida')

    glClearColor(0.0, 0.0, 0.0, 1.0)  # Color de fondo negro

    glutDisplayFunc(draw_points)
    glutMainLoop()

if __name__ == "__main__":
    main()

Este código utiliza la biblioteca PyOpenGL (OpenGL en Python) para crear una ventana gráfica y dibujar tres puntos de color rojo en ella. En el código se aprecia lo siguiente:

Importación de bibliotecas:

  • from OpenGL.GL import * y from OpenGL.GLUT import *: Importa las funciones y constantes de OpenGL y GLUT para Python.

Función draw_points:

  • Esta función se utiliza para dibujar puntos en la ventana de OpenGL.
  • glClear(GL_COLOR_BUFFER_BIT): Borra el búfer de color para preparar la ventana para el dibujo.
  • glBegin(GL_POINTS): Inicia el modo de puntos.
  • glColor3f(1.0, 0.0, 0.0): Establece el color en rojo (1.0 en rojo, 0.0 en verde y 0.0 en azul).
  • glVertex2f(0.0, 0.0): Dibuja un punto en las coordenadas (0.0, 0.0).
  • glVertex2f(0.2, 0.2): Dibuja otro punto en (0.2, 0.2).
  • glVertex2f(-0.2, -0.2): Dibuja un tercer punto en (-0.2, -0.2).
  • glEnd(): Finaliza el modo de puntos.
  • glFlush(): Procesa los comandos OpenGL para mostrar los puntos en la ventana.

Función main:

  • Esta es la función principal del programa.
  • glutInit(sys.argv): Inicializa GLUT y proporciona argumentos de línea de comandos.
  • glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB): Configura el modo de visualización con un solo búfer y el modelo de color RGB.
  • glutInitWindowSize(400, 400): Establece el tamaño de la ventana en 400×400 píxeles.
  • glutInitWindowPosition(100, 100): Establece la posición inicial de la ventana.
  • glutCreateWindow(b'Ejemplo de Primitivos de Salida'): Crea la ventana con un título.
  • glClearColor(0.0, 0.0, 0.0, 1.0): Establece el color de fondo de la ventana en negro.
  • glutDisplayFunc(draw_points): Configura la función draw_points como la función de visualización que se llama cuando se refresca la ventana.
  • glutMainLoop(): Inicia el bucle principal de GLUT, que maneja la interfaz de usuario y el procesamiento de eventos.
  1. if __name__ == "__main__":
    • Esta construcción verifica si el script se está ejecutando como el programa principal y, en ese caso, llama a la función main() para iniciar la aplicación.

Este código crea una ventana de OpenGL y dibuja tres puntos de color rojo en ella. Es un ejemplo simple de cómo utilizar primitivos de salida en OpenGL utilizando PyOpenGL y GLUT en Python.

Dejar una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *