Turma: UNN0790104NNA

Alunos: Vinicios Gabriel Gomes da Silva – 03115877, Ulisses Franco Silva Texeira –
03207644

IMAGENS ARTIFICIAIS DAS APLICAÇÕES RAY TRACING E TEXTURAS

Introdução

Este trabalho apresenta um código que utiliza as bibliotecas Pygame e OpenGL para
criar uma aplicação gráfica interativa. O objetivo é renderizar uma textura em um
quadrado na tela. A textura é gerada a partir de um padrão xadrez, onde os pixels
alternam entre preto e branco.
A implementação faz uso de recursos gráficos avançados proporcionados pela
biblioteca OpenGL, incluindo o uso de shaders para manipular a aparência da textura.
Além disso, o Pygame é utilizado para gerenciar a janela de exibição e lidar com
eventos do usuário.
O código é organizado em funções que inicializam o ambiente gráfico, geram a textura
e realizam a renderização na tela. A atualização contínua da exibição é garantida por
meio de um loop principal.
Por meio dessa implementação, é possível explorar os conceitos de geração de
texturas e renderização em tempo real, proporcionando uma experiência visual
interativa. O trabalho serve como base para a compreensão e experimentação com
técnicas gráficas mais avançadas, além de oferecer uma introdução prática aos
conceitos do OpenGL e Pygame.
Nesse contexto, a citação de Eric Lengyel, autor do livro "Mathematics for 3D Game
Programming and Computer Graphics", é relevante. Ele afirma que "a programação
gráfica é uma combinação poderosa de matemática, arte e programação que permite
criar mundos virtuais ricos em detalhes e realistas". O trabalho apresentado
demonstra a aplicação desses conceitos em um contexto prático e acessível.

Ray Tracing

A imagem apresentada é um exemplo básico de implementação de Ray Tracing

utilizando as bibliotecas Pygame e OpenGL. O código que gera essa imagem cria
uma janela de exibição e renderiza uma cena simulando o comportamento da luz ao
interagir com os objetos. Cada pixel da janela é tratado como um raio que é traçado
a partir da câmera e intersecta com os objetos, calculando a cor com base na
iluminação da cena. Essa técnica proporciona imagens realistas em tempo real.
Segundo Kenneth Hoff, autor do livro "Ray Tracing from the Ground Up", o ray tracing
é "uma técnica de renderização que simula o comportamento da luz de forma física e
pode produzir imagens altamente realistas".

Código

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np

# Configuração da janela do pygame

width = 800
height = 600

# Configuração da cena
camera = np.array([0, 0, 0])
objects = [
{"center": np.array([0, 0, -3]), "radius": 1, "color": (1, 0, 0)},
{"center": np.array([2, 0, -4]), "radius": 0.5, "color": (0, 1, 0)},
{"center": np.array([-2, 0, -4]), "radius": 0.5, "color": (0, 0, 1)}
]
lights = [np.array([5, 5, 5]), np.array([-5, 5, 5])]
# Função para calcular a cor de um pixel utilizando ray tracing
def ray_trace(ray):
color = np.zeros(3)
min_distance = np.inf
nearest_object = None

for obj in objects:

center = obj["center"]
radius = obj["radius"]
color_obj = obj["color"]

oc = ray.origin - center
a = np.dot(ray.direction, ray.direction)
b = 2 * np.dot(oc, ray.direction)
c = np.dot(oc, oc) - radius ** 2
discriminant = b ** 2 - 4 * a * c

if discriminant >= 0:
t1 = (-b + np.sqrt(discriminant)) / (2 * a)
t2 = (-b - np.sqrt(discriminant)) / (2 * a)
if t1 >= 0 and t1 < min_distance:
min_distance = t1
nearest_object = obj
elif t2 >= 0 and t2 < min_distance:
min_distance = t2
nearest_object = obj

if nearest_object is not None:

intersection_point = ray.origin + min_distance * ray.direction
normal = (intersection_point - nearest_object["center"]) /
nearest_object["radius"]

for light in lights:

light_direction = normalize(light - intersection_point)
light_intensity = max(0, np.dot(normal, light_direction))
color += light_intensity * np.array(color_obj)

return color
# Classe para representar um raio
class Ray:
def __init__(self, origin, direction):
self.origin = origin
self.direction = direction / np.linalg.norm(direction)

# Função para normalizar um vetor

def normalize(v):
norm = np.linalg.norm(v)
if norm == 0:
return v
return v / norm

# Função para converter coordenadas de tela para coordenadas de viewport

def screen_to_viewport(x, y):
viewport_x = (2 * x - width) / width
viewport_y = -(2 * y - height) / height
return np.array([viewport_x, viewport_y, -1])

# Função para renderizar a cena de ray tracing

def render_ray_tracing_scene():
glClear(GL_COLOR_BUFFER_BIT)

for y in range(height):
for x in range(width):
screen_point = screen_to_viewport(x, y)
ray_direction = normalize(screen_point - camera)

ray = Ray(camera, ray_direction)

color = ray_trace(ray)

set_pixel(x, y, color)

pygame.display.flip()

# Função para definir a cor de um pixel

def set_pixel(x, y, color):
glBegin(GL_POINTS)
glColor3f(color[0], color[1], color[2])
glVertex2f(x + 0.5, y + 0.5)
 glEnd()

# Função principal
def main():
pygame.init()
pygame.display.set_mode((width, height), OPENGL | DOUBLEBUF)
pygame.display.set_caption("Ray Tracing")

gluOrtho2D(0, width, height, 0)

while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
quit()

render_ray_tracing_scene()

if __name__ == '__main__':
main()

Texturas

O código apresentado utiliza as bibliotecas Pygame e OpenGL para criar uma janela
de exibição e renderizar uma textura em um quadrado. A textura é gerada com base
em um padrão xadrez, onde os pixels alternam entre preto e branco. A função init()
inicializa o ambiente de exibição, e a função render() é responsável por desenhar o
quadrado com a textura. O programa entra em um loop principal na função main(),
onde a função render() é chamada repetidamente para atualizar a exibição.

Como citação, podemos mencionar Wolfgang Engel, autor do livro "OpenGL 4

Shading Language Cookbook", que aborda técnicas avançadas de programação em
shaders com OpenGL.

Código

import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GL import shaders
import numpy as np

# Tamanho da textura
texture_width = 256
texture_height = 256

# Função para gerar a textura

def generate_texture():
texture_data = np.zeros((texture_width, texture_height), dtype=np.uint8)

for i in range(texture_width):
for j in range(texture_height):
if (i // 32) % 2 == (j // 32) % 2:
texture_data[i, j] = 255

texture_id = glGenTextures(1)
glBindTexture(GL_TEXTURE_2D, texture_id)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, texture_width, texture_height,
0, GL_LUMINANCE, GL_UNSIGNED_BYTE, texture_data)

return texture_id

# Função de inicialização
def init():
pygame.init()
pygame.display.set_mode((800, 600), DOUBLEBUF | OPENGL)

global texture_id
texture_id = generate_texture()

glClearColor(0.0, 0.0, 0.0, 1.0)

# Função de renderização
def render():
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
 glEnable(GL_TEXTURE_2D)
glBindTexture(GL_TEXTURE_2D, texture_id)

glBegin(GL_QUADS)
glTexCoord2f(0, 0)
glVertex2f(-1, -1)
glTexCoord2f(1, 0)
glVertex2f(1, -1)
glTexCoord2f(1, 1)
glVertex2f(1, 1)
glTexCoord2f(0, 1)
glVertex2f(-1, 1)
glEnd()

glDisable(GL_TEXTURE_2D)

pygame.display.flip()

# Função principal
def main():
init()

while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
return

render()

# Executar o programa
if __name__ == "__main__":
main()

Imagem
Conclusões

Em conclusão, o trabalho apresentou um exemplo prático de utilização das bibliotecas

Pygame e OpenGL para criar uma aplicação gráfica interativa. O código desenvolvido
permitiu renderizar uma textura em um quadrado na tela, utilizando recursos
avançados fornecidos pela biblioteca OpenGL, como shaders e manipulação de
texturas.

Através desse trabalho, foi possível compreender os conceitos básicos de

renderização gráfica em tempo real, incluindo a geração e aplicação de texturas, bem
como a configuração do ambiente de exibição com o Pygame.

Além disso, o trabalho serviu como uma introdução prática ao uso do OpenGL e
Pygame, oferecendo uma base sólida para exploração de técnicas gráficas mais
avançadas. Os conhecimentos adquiridos podem ser estendidos para a criação de
aplicações mais complexas, como jogos, simulações ou visualizações interativas.

É importante ressaltar que a área de programação gráfica é vasta e envolve uma

combinação de matemática, arte e programação. O trabalho apresentado
proporcionou um vislumbre desse campo, mostrando como é possível criar mundos
virtuais detalhados e realistas por meio da manipulação de pixels e shaders.

Em suma, o trabalho permitiu uma imersão prática no desenvolvimento de aplicações

gráficas utilizando Pygame e OpenGL, proporcionando uma base sólida para a
exploração de técnicas avançadas nesse campo fascinante.
Referências

Hoff, K. (2000). Ray Tracing from the Ground Up. Packt Publishing. AK Peters
Engel, W. (2013). OpenGL 4 Shading Language Cookbook. Packt Publishing.