Fiquei 9 anos criando uma game engine e ao longo desse período, pude aprender muito e aprimorar minhas habilidades de programação e design. Neste tutorial, vou compartilhar com vocês a evolução da minha game engine ao longo desses anos e como você pode começar a desenvolver a sua própria.
1. Primeiros passos:
Quando decidi criar minha game engine, eu sabia que teria um longo caminho pela frente. Comecei estudando as bases da programação de jogos, como física, renderização gráfica, animação e áudio. Depois de dominar esses conceitos, comecei a projetar a arquitetura da minha engine.
2. Desenvolvimento inicial:
No início, minha game engine era bastante simples e rudimentar. Eu focava em criar sistemas básicos para funcionar corretamente, como o input de jogador, renderização básica e colisões simples. Conforme eu ganhava mais experiência, fui adicionando mais funcionalidades e otimizando o código.
3. Adição de recursos avançados:
Com o tempo, fui adicionando recursos mais avançados à minha engine, como shaders, iluminação avançada, inteligência artificial e física mais realista. Isso exigiu muito estudo e experimentação, mas foi gratificante ver minha engine evoluir.
4. Otimização e melhoria de desempenho:
Um dos maiores desafios ao criar uma game engine é otimizar o código para garantir um bom desempenho em diferentes plataformas. Eu passei muito tempo fazendo testes de desempenho e otimizando algoritmos para garantir que minha engine rodasse suavemente em diferentes dispositivos.
5. Suporte a diferentes plataformas:
Uma das coisas mais importantes ao criar uma game engine é garantir que ela seja compatível com diferentes plataformas, como PC, consoles e dispositivos móveis. Eu passei bastante tempo adaptando minha engine para funcionar em diferentes ambientes e otimizando o código para garantir uma boa performance em cada uma delas.
6. Comunidade e colaboração:
Durante o desenvolvimento da minha game engine, percebi a importância da comunidade e da colaboração com outros desenvolvedores. Participei de fóruns e grupos de discussão para trocar ideias, aprender com a experiência de outros e receber feedback sobre o meu trabalho.
7. Lançamento e feedback dos usuários:
Depois de 9 anos de desenvolvimento, finalmente lancei minha game engine para o público. Receber feedback dos usuários foi fundamental para melhorar a minha engine e corrigir possíveis bugs e problemas de desempenho. Sempre fui aberto a sugestões e críticas construtivas para aprimorar o meu trabalho.
8. Continuação do desenvolvimento:
Mesmo após o lançamento da minha game engine, continuo trabalhando para melhorar e adicionar novos recursos. Sempre busco aprender novas técnicas e tecnologias para manter minha engine atualizada e competitiva no mercado de jogos.
Espero que esse tutorial tenha sido útil para você que deseja criar sua própria game engine. O processo de desenvolvimento pode ser longo e desafiador, mas com dedicação e perseverança, você pode alcançar seus objetivos e criar uma engine poderosa e versátil. Boa sorte em sua jornada de desenvolvimento de jogos!
Por favor faz um livro sobre criação de engine básico por favooooor
Eu achei bem legal, mas eu sou bem novo na programação, NN sei se saberia programa algo na sua, precisaria de muito texte e muita coisa, só muito leigo pra aprender as coisas😢
eu acho incrível como algumas coisas na sua engine são superiores a godot, que é mantida por várias pessoas. impressionante uma pessoa sozinha fazer tanta coisa. só precisa de um tapa no design.
isso de mexer na cena com o jogo é execução é insano
Que maravilha, magina essa engine daqui uns 3 a 4 anos?
insano demais mano, parabéns
Isso é incrível. Ainda vou fazer a disciplina de computação gráfica na minha faculdade.
interesante dms (:
nem sabia q existia um brasileira com essa capacidade intelectual 😀
Mandei email querendo investir em sua engine, e nunca respondeu. Abraço
Vai virar opensource? Tem potencial pra ser uma puta Engine BR
engine está muito bonita, parabens…
para a emulação de performance você poderia implementá-lo com um controle de quota de memória e processos, definindo limites de uso de memória(por exemplo limite na quantidade de variaveis) e limite de processos(comparável ao limite de funções rodando), o controle de complexidade é mais complicado e geralmente as próprias IDEs já implementam, como controle da quantidade de laços sobrepostos(no python é uns 10), controle de profundidade de recursão(no python é 5000 niveis de instancias), e controle da quantidade geral de variaveis e funções, isso pode obrigar o usuário a ser mais eficiente, e é apenas um controle estético e também pra evitar overflow
sobre lidar com problemas em engine dos outros, sua ideia de criar a própria engine3D foi genial, pois realmente é um laberinto, e pra mostrar como isso pode ser complexo, olha apenas a documentação de debug do python https://docs.python.org/3/library/debug.html e local de teste https://pythontutor.com/python-compiler.html#mode=edit que é a linguagem mais simples hoje em dia,
porém com a ajuda do chatGPT e pyopengl (o próprio chatGPT quebra cabeça com as partes complexas), eu consegui fazer isso…(tinha pedido um minecraft mas o chatGPT não guentou o desafio)
#controles
#w,a,s,d,q,e, setas, para a câmera
#i,j,k,l,u,o, numeros para cubos
import pygame
from pygame.locals import *
from OpenGL.GL import *
from OpenGL.GLU import *
import numpy as np
# Função de inicialização
def init():
pygame.init()
pygame.display.set_mode((800, 600), DOUBLEBUF | OPENGL)
glEnable(GL_DEPTH_TEST)
glMatrixMode(GL_PROJECTION)
glLoadIdentity()
gluPerspective(45, (800 / 600), 0.1, 100.0)
glMatrixMode(GL_MODELVIEW)
# Função para desenhar a grade
def draw_grids():
glPushMatrix()
glBegin(GL_LINES)
for i in range(-10, 11):
glColor3f(0.5, 0.5, 0.5)
# Linhas XY
glVertex3f(i, -10, 0);glVertex3f(i, 10, 0)
glVertex3f(-10, i, 0);glVertex3f(10, i, 0)
# Linhas YZ
glVertex3f(0, -10, i); glVertex3f(0, 10, i)
glVertex3f(0, i, -10);glVertex3f(0, i, 10)
# Linhas XZ
glVertex3f(i, 0, -10);glVertex3f(i, 0, 10)
glVertex3f(i, -10, 0); glVertex3f(i, 10, 0)
# Linhas coloridas no eixo zero
glColor3f(1, 0, 0) # X0 – Vermelho
glVertex3f(0, -10, 0);glVertex3f(0, 10, 0)
glColor3f(0, 1, 0) # Y0 – Verde
glVertex3f(-10, 0, 0);glVertex3f(10, 0, 0)
glColor3f(0, 0, 1) # Z0 – Azul
glVertex3f(0, 0, -10);glVertex3f(0, 0, 10)
glEnd()
glPopMatrix()
# Função para desenhar um cubo multicolorido
def draw_multicolor_cube(position, rotation, size):
vertices = np.array([
[-size, -size, -size], [size, -size, -size], [size, size, -size], [-size, size, -size],
[-size, -size, size], [size, -size, size], [size, size, size], [-size, size, size]
])
edges = [
(0, 1), (1, 2), (2, 3), (3, 0),
(4, 5), (5, 6), (6, 7), (7, 4),
(0, 4), (1, 5), (2, 6), (3, 7)
]
faces = [
(0, 1, 2, 3), (4, 5, 6, 7), (0, 1, 5, 4),
(2, 3, 7, 6), (0, 3, 7, 4), (1, 2, 6, 5)
]
colors = [
[1, 0, 0], [0, 1, 0], [0, 0, 1], [1, 1, 0],
[1, 0, 1], [0, 1, 1], [1, 0.5, 0], [0.5, 0, 0.5]
]
glPushMatrix()
glTranslatef(*position)
glRotatef(rotation[0], 1, 0, 0)
glRotatef(rotation[1], 0, 1, 0)
glRotatef(rotation[2], 0, 0, 1)
glBegin(GL_QUADS)
for i, face in enumerate(faces):
glColor3fv(colors[i % len(colors)])
for vertex in face:
glVertex3fv(vertices[vertex])
glEnd()
glColor3f(0, 0, 0)
glBegin(GL_LINES)
for edge in edges:
for vertex in edge:
glVertex3fv(vertices[vertex])
glEnd()
glPopMatrix()
# Função para desenhar a bola
def draw_ball(position, radius):
slices = 16
stacks = 16
glPushMatrix()
glTranslatef(*position)
quadric = gluNewQuadric()
gluQuadricDrawStyle(quadric, GLU_FILL)
glColor3f(1, 1, 1)
gluSphere(quadric, radius, slices, stacks)
gluDeleteQuadric(quadric)
glPopMatrix()
# Função para exibir texto na tela
def draw_text(position, text):
font = pygame.font.Font(None, 36)
text_surface = font.render(text, True, (255, 255, 255))
text_data = pygame.image.tostring(text_surface, "RGB", True)
glRasterPos2f(*position)
glDrawPixels(text_surface.get_width(), text_surface.get_height(), GL_RGB, GL_UNSIGNED_BYTE, text_data)
# Função para controle da câmera
def control_camera(camera_pos, camera_rot, keys, delta_time):
speed = 5 * delta_time
rot_speed = 60 * delta_time
if keys[K_w]:camera_pos[2] -= speed
if keys[K_s]:camera_pos[2] += speed
if keys[K_a]:camera_pos[0] -= speed
if keys[K_d]:camera_pos[0] += speed
if keys[K_q]:camera_pos[1] -= speed
if keys[K_e]:camera_pos[1] += speed
if keys[K_UP]:camera_rot[0] += rot_speed
if keys[K_DOWN]:camera_rot[0] -= rot_speed
if keys[K_LEFT]:camera_rot[1] -= rot_speed
if keys[K_RIGHT]:camera_rot[1] += rot_speed
if keys[K_z]:camera_rot[2] -= rot_speed
if keys[K_x]:camera_rot[2] += rot_speed
# Função para controle dos cubos
def control_cube(cube_pos, cube_rot, keys, delta_time):
speed = 5 * delta_time
rot_speed = 60 * delta_time
if keys[K_i]:cube_pos[1] += speed
if keys[K_k]:cube_pos[1] -= speed
if keys[K_l]:cube_pos[0] -= speed
if keys[K_j]:cube_pos[0] += speed
if keys[K_u]:cube_pos[2] += speed
if keys[K_o]:cube_pos[2] -= speed
if keys[K_8]:cube_rot[0] -= rot_speed
if keys[K_2]:cube_rot[0] += rot_speed
if keys[K_6]:cube_rot[1] -= rot_speed
if keys[K_4]:cube_rot[1] += rot_speed
if keys[K_5]:cube_rot[2] -= rot_speed
if keys[K_0]:cube_rot[2] += rot_speed
# Função para verificar a colisão entre a esfera e um cubo
def check_collision(ball_pos, ball_radius, cube_pos, cube_size):
# Determinar as coordenadas mínimas e máximas do cubo
cube_min = np.array(cube_pos) – np.array([cube_size, cube_size, cube_size])
cube_max = np.array(cube_pos) + np.array([cube_size, cube_size, cube_size])
# Verificar a colisão no eixo X, Y e Z
closest_point = np.maximum(cube_min, np.minimum(ball_pos, cube_max))
distance = np.linalg.norm(ball_pos – closest_point)
return distance < ball_radius
# Função para atualizar a posição dos cubos ao atravessar as bordas
def wrap_around(position, size, bounds):
for i in range(3):
if position[i] > bounds[i] + size:position[i] -= (2 * (size + bounds[i]))
elif position[i] < -bounds[i] – size:position[i] += (2 * (size + bounds[i]))
return position
# Função principal
def main():
init()
clock = pygame.time.Clock()
# Posição e rotação da câmera
camera_pos = [0, 0, 10]
camera_rot = [0, 0, 0]
# Posições, rotações e tamanhos dos cubos
cube1_pos = [-5, 0, 0]
cube1_rot = [0, 0, 0]
cube2_pos = [5, 0, 0]
cube2_rot = [0, 0, 0]
cube_size = 1.0
# Posição, velocidade e raio da bola
ball_pos = [0, 0, 0]
ball_vel = [0.05, 0.03, 0.02]
ball_radius = 0.5
# Limites do cenário
bounds = [10, 10, 10]
while True:
delta_time = clock.tick(60) / 1000.0
keys = pygame.key.get_pressed()
for event in pygame.event.get():
if event.type == QUIT:pygame.quit();quit()
# Atualização da posição da bola
ball_pos[0] += ball_vel[0];ball_pos[1] += ball_vel[1];ball_pos[2] += ball_vel[2] #xyz
# Verificação de colisão com as bordas
if ball_pos[1] > bounds[1] – ball_radius or ball_pos[1] < -bounds[1] + ball_radius:ball_vel[1] = -ball_vel[1]
if ball_pos[0] > bounds[0] – ball_radius or ball_pos[0] < -bounds[0] + ball_radius:ball_vel[0] = -ball_vel[0]
if ball_pos[2] > bounds[2] – ball_radius or ball_pos[2] < -bounds[2] + ball_radius:ball_vel[2] = -ball_vel[2]
# Atualizar a posição dos cubos para atravessar as bordas
cube1_pos = wrap_around(cube1_pos, cube_size, bounds)
cube2_pos = wrap_around(cube2_pos, cube_size, bounds)
# Verificação de colisão com os cubos
if check_collision(ball_pos, ball_radius, cube1_pos, cube_size):ball_vel[0] = -ball_vel[0];ball_vel[1] = -ball_vel[1];ball_vel[2] = -ball_vel[2]
if check_collision(ball_pos, ball_radius, cube2_pos, cube_size):ball_vel[0] = -ball_vel[0];ball_vel[1] = -ball_vel[1];ball_vel[2] = -ball_vel[2]
# Atualização da câmera e dos cubos
control_camera(camera_pos, camera_rot, keys, delta_time)
control_cube(cube1_pos, cube1_rot, keys, delta_time)
control_cube(cube2_pos, cube2_rot, keys, delta_time)
# Desenho do cenário
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
glLoadIdentity()
glTranslatef(-camera_pos[0], -camera_pos[1], -camera_pos[2])
glRotatef(camera_rot[0], 1, 0, 0)
glRotatef(camera_rot[1], 0, 1, 0)
glRotatef(camera_rot[2], 0, 0, 1)
draw_grids()
draw_multicolor_cube(cube1_pos, cube1_rot, cube_size)
draw_multicolor_cube(cube2_pos, cube2_rot, cube_size)
draw_ball(ball_pos, ball_radius)
draw_text([-9, 8], "Pong Game")
pygame.display.flip()
if _name_ == "__main__":
main()
#seria interessante se você mantesse esse poder do python acessar o OpenGL ou uma forma indireta para codificar scripts na sua engine para acessar o OpenGL, provavelmente já existe
Cara, sua engine é muito boa! vai ter muita gente babadora de outras engines falando que era pra tu ter usado e tals.
Mas é uma boa ter uma engine sua, tanto pra estudo, quanto pra criar seus modelos sem pagar nada por fora.
Isso melhora muito seu currículo. Ficou muito bom.
top demais👏👏
Massa. Tô estudando webdev pela internet, e gosto de ver progresso dos outros. Não tô focado em jogos mas cada um tem a sua jornada. Sucesso!
essa sua engine é open source?
Como dizem por ai "brasileiro é um bicho a ser estudado"… é realmente incrível o tipo de tech que a gente produz por aqui… já faz um tempo que acompanho esse trampo de vcs, e acredito que essa engine vai muito longe ainda.. a dedicação empregada nesse rolê todo vai ser bem satisfatória. Desejo sucesso aos devs e toda equipe envolvida no projeto. Eu to fazendo um game (q ta no meu canal) e já to ficando maluco, imagina montar uma coisa pra montar games! Sensacional!!! Vcs merecem toda divulgação possível e ainda quero ver num futuro próximo, vídeos de programadores na udemy e afins com o título "Criando jogos na cave engine, do zero ao completo". Abraços
Sensacional cara. Como desenvolvedor eu sei o quao complexo e o quanto de empenho foi necessário pra atingir esse resultado. Parabéns!
Comei criar jogos em 2012 com essa game engine do Blender
Que top Guilherme 👏👏