Projeto pessoal / Arquitetura de engine

Tessera Engine

Uma game engine C++20/Direct3D 12 em que cada fronteira tem uma forma de verificação e cada decisão é acompanhada por evidência.

Tessera é a game engine e o editor para Windows que estou desenvolvendo como projeto pessoal. Escrevo o ECS, o job system, o pipeline de assets e o renderizador. Para tech leads e líderes de projeto, esta página apresenta as responsabilidades de cada sistema, os compromissos que escolhi e os critérios que uso para aceitar uma implementação.

O levantamento documentado em 12 de outubro de 2026 registra 819 arquivos C++, cerca de 270 mil linhas fora de ThirdParty e 47 shaders. Duas soluções em quatro configurações totalizam oito builds locais com avisos tratados como erro. Esses números delimitam a escala do projeto; as medições abaixo pertencem aos cenários registrados, nesta máquina e nos builds documentados. O repositório é privado.

  • C++20
  • Windows
  • Direct3D 12
  • ECS
  • DXR
  • Dear ImGui
  • Sharpmake
Visão geral do editor com docking, viewport, hierarquia, inspector e Content Browser; esta captura mostra uma cena sem malhas cozidas carregadas.

Visão geral

Peças pequenas, fronteiras verificáveis

Tessera é o nome de uma peça de mosaico. Cada camada tem uma responsabilidade e uma direção de dependência definida. A simulação não depende da renderização; o renderizador constrói um plano; o backend gráfico traduz esse plano em trabalho na GPU. O editor usa a mesma engine que inspeciona.

O motor é uma biblioteca estática; o executável exporta D3D12SDKVersion e D3D12SDKPath do Agility SDK. A separação entre simulação, planejamento e execução tem três verificações complementares: um único handoff do ECS para RenderScene, um render graph testável sem GPU e uma solução inteira sem D3D12. Assim, as fronteiras não dependem apenas de convenções entre pastas.

Contratos de arquitetura

Padrões, alternativas e evidências

Os padrões abaixo conectam uma decisão ao lugar onde ela vive e à verificação que pode contradizê-la. Cada nome leva à seção de detalhe; os resultados descrevem os testes documentados, não garantias para qualquer cena ou hardware.

A mesma política orienta simulação, GPU e autoria: declarar o acesso, concentrar a produção de dados derivados e tornar o ciclo de vida explícito. Prefiro uma dependência que o compilador pode verificar a uma regra que exige lembrar de todos os seus consumidores.

PadrãoOnde viveAlternativa evitadaEvidência no cenário medido
O renderizador planeja; o backend executaRender/RenderGraph / RHI/D3D12/DxRenderGraphExecutorGrafo que grava comandos242 verificações do plano sem device.
Um único handoff ECS/renderRenderExtractionSystem para RenderSceneRenderizador lendo o World vivoAdicionar 100.000 entidades sem mesh mantém as mesmas instâncias e os mesmos bytes de upload.
Backend nulo como solução de buildTessera.NoD3D12.slnIsolamento sustentado apenas por #ifdef ou busca textualZero Dx*.obj nas quatro configurações da solução sem D3D12.
Handles com geraçãoRHI/Handles.hPonteiro ou ComPtr em componenteNove tags de handle; PSO aposentado no hot reload resulta em draw pulado, sem referência pendurada.
Acesso declarado e DAG de hazardsSystemDescriptor, AccessAuditorLocks dentro do ECSZero mutex em ECS/; 32 sistemas: 0,68 µs com 10 mil entidades e 0,86 µs com 1 milhão.
Mudança estrutural diferidaCommandBuffer, PlaybackCommandsMutar componentes durante a iteraçãoNo teste, 1.000 entidades geram uma transição de archetype.
Versões para sujeira; hash para restauraçãoTransformState, WorldSnapshotFlags booleanas como única fonte de validadeNo quadro parado medido, a GPU Scene recebe 0 bytes de upload.
Um produtor por valor derivadoCanonicalCookedKey, ComputeSceneRectRecalcular identidade ou retângulo em cada consumidorChave canônica compartilhada; uma chave recalculada causou uma cena magenta no diagnóstico registrado.
Composição com contextos explícitosDxFramePassContextGod class ou extensão por herança85/85 funções virtual preservadas nas 12 extrações de módulos verificadas.
Defaults preservam o comportamentoQualitySettings, EffectToggleAplicar um perfil de qualidade sem pedidoSem flag, a comparação de aceitação tem 0 de 1.440.000 pixels diferentes.
Proveniência e identidade no próprio dadoPROV, IDNTManifesto externo ou identidade por caminhoVarredura de 102 ms contra 316 s de recook no projeto medido; UUID preservado em IDNT.
Instrumentar antes de aceitar--*-probeConfiar apenas em build verdeVerificador pós-build confere DLLs de runtime e shaders; probes exercitam os recursos.
Fluxo atual da simulação ao backend: extração única, plano sem GPU e execução Direct3D 12. Diagrama conceitual em inglês, sem contagens de passes de uma cena.

Dependências

Arquitetura em camadas

As fronteiras são definidas por responsabilidades, interfaces e dependências verificáveis. SDL3 aparece somente sob Platform/ e UI/; os headers Direct3D ficam em RHI/D3D12/. Render/ decide o que desenhar e produz o plano, sem gravar comandos na GPU. ECS e Jobs não incluem Render/ nem RHI/: as buscas no código registram zero includes dessas camadas. Scene registra componentes de renderização e inclui seus headers; essa camada não recebe a mesma alegação de isolamento.

Bibliotecas de importação e compressão pertencem exclusivamente a Tools/TesseraCooker. O runtime consome dados cozidos sem carregar dependências de autoria. A solução Tessera.NoD3D12.sln compila motor e editor com backend nulo e interface SDL_Renderer. Um tipo D3D12 que atravesse a fronteira quebra esse build; Debug, Development, Profile e Shipping produzem zero objetos Dx*.obj no levantamento documentado.

Camadas de dependência do motor e a fronteira isolada do Direct3D 12.

Simulação

ECS próprio para escalonamento

Estudei EnTT e Flecs e construí um ECS em torno de três requisitos: acesso de leitura/escrita declarado, mudanças estruturais diferidas e determinísticas e snapshots do mundo. Uma Entity é um índice e uma geração em oito bytes; a geração detecta referências obsoletas. A persistência usa um UUID, StableEntityId, em vez do handle de runtime.

Entidades com o mesmo conjunto de componentes ficam em archetypes, com colunas SoA contíguas em chunks de 64 KiB. Com dois milhões de entidades, 64 KiB exigiu 1.482 páginas contra 5.955 a 16 KiB, com a mesma largura de banda. Sparse sets guardam componentes raros sem multiplicar archetypes. Tabelas de componentes compartilhados mantêm um valor por configuração distinta, referenciado pelo chunk.

Cada SystemDescriptor declara leituras e escritas. O scheduler deriva um DAG de dependências e executa juntos os sistemas sem conflitos. Com 32 sistemas, o custo medido foi de 0,68 µs por quadro sobre 10.000 entidades e 0,86 µs sobre 1.000.000: esse custo acompanha os sistemas, não a contagem de entidades.

Fases fixas definem quando ocorrem input, simulação, física, eventos, playback estrutural, transforms e extração para render. Criar, destruir ou mudar componentes passa pelo CommandBuffer, aplicado em um único ponto determinístico. Um auditor de acesso detecta escritas não declaradas em desenvolvimento e é compilado fora em Shipping. Eventos tipados, observers e um store próprio de hierarquia completam o modelo; a propagação por versões evita recalcular nós parados.

O handoff para renderização é RenderExtractionSystem para RenderScene: o renderizador consome os dados extraídos, sem consultar o World vivo a cada draw. Na sonda registrada, adicionar 100.000 entidades sem mesh mantém o número de instâncias e os bytes enviados. Mudanças estruturais também são agrupadas: 1.000 entidades produzem uma transição de archetype no teste de playback. Um quadro parado envia 0 bytes à GPU Scene; versões de TransformState acompanham mudanças e o hash de WorldSnapshot verifica a restauração.

O replay de snapshot reproduziu 120 registros de auditoria idênticos ao longo de 120 quadros na mesma máquina e build. Esse é o escopo verificado de determinismo e a base do Play/Stop do editor; não há promessa de determinismo entre plataformas.

struct Entity
{
    uint32_t Index = InvalidEntityIndex;
    uint32_t Generation = 0;
};
static_assert(sizeof(Entity) == 8,
    "Entity is a chunk column; its size is layout.");
Armazenamento de archetypes dividido em chunks com colunas contíguas de componentes.
Estrutura de dados do ECS: handles de entidades, archetypes e armazenamento SoA.
Painel ECS Diagnostics expondo dados do mundo e do escalonamento.

Concorrência

Work stealing sem bloquear o quadro

Cada worker possui um deque Chase-Lev: empilha e desempilha sem lock, enquanto workers ociosos roubam da outra ponta. Um worker que espera um job executa outros trabalhos na própria pilha. O teste com um único worker verifica que as dependências continuam progredindo. Threads externas ao pool esperam passivamente; deixá-las ajudar criaria dois produtores para um deque que admite apenas um.

Jobs têm afinidade AnyWorker, LongRunning ou MainThread. Contadores separados acompanham trabalho do quadro e de longa duração, para a compilação de shader não prolongar a espera do quadro. Na comparação registrada, o quadro mais lento durante uma recompilação caiu de 803 ms para 18,75 ms. FrameArena por worker oferece alocação temporária; ParallelFor sobre 1.048.576 elementos produziu o resultado serial com zero alocações de heap.

Um watchdog nomeia o estágio travado, inclusive durante execuções com a janela do editor visível. O roubo por elemento transfere o custo de encontrar trabalho para a thread ociosa. No grafo largo de trabalho real registrado, a ocupação dos workers foi de 94,7%; a timeline permite relacionar essa medição às dependências e ao trabalho efetivamente executado.

O cooker usa o mesmo sistema: comprimir uma textura 2048² levou 311,8 s com uma thread e 9,7 s com 24. Tracy e uma timeline no editor expõem atividade de CPU/GPU e trabalho por worker. São medições específicas do projeto, não garantias gerais de throughput.

Timeline de profiling com jobs por worker.
Profiling do editor com informações de quadro e tempos.

Persistência

Um contêiner, muitos chunks

Importar um modelo significa cozinhá-lo. Um projeto Tessera guarda formatos do motor e referencia o original por uma raiz de origem nomeada; nunca copia o original para o projeto e rejeita caminhos absolutos de origem. Assim, os dados portáveis do projeto ficam separados dos arquivos de autoria necessários à reimportação.

Os formatos binários compartilham um cabeçalho de 64 bytes com magic, versão, hash XXH3-128 e localização da tabela de chunks. Entradas FourCC localizam chunks alinhados a 256 bytes. O runtime lê apenas o mip ou LOD necessário. PROV registra caminho e hash de origem, versão do cooker e opções; varrer um projeto inalterado levou 102 ms contra 316 s para recozinhar. IDNT preserva o UUID nas reimportações.

Um .tmesh contém um asset completo com submeshes internos: o buggy transforma 109 malhas em um arquivo com 236 submeshes. SXFM guarda transforms por peça, permitindo armazenar uma roda uma vez e posicioná-la quatro vezes. No acervo medido, o armazenamento caiu de 39,9 MB para 31,0 MB e os draws de 342 para 229.

Chunks opcionais têm ausência bem definida: sem SXFM, o transform é identidade. A política de compatibilidade permite acrescentar PROV sem mudar a versão do contêiner; SXFM exige uma versão de malha que mantém arquivos antigos abrindo e renderizando. Evoluir o formato implica decidir explicitamente quais leitores e dados precisam continuar compatíveis.

O ciclo de vida dos assets inclui sua liberação na GPU. CookedAssetLibrary::Clear chama DestroyMesh enquanto os handles ainda identificam as malhas e depois ReleaseCookedTextures, antes de limpar as tabelas locais. CanonicalCookedKey concentra a identidade derivada do asset; os consumidores reutilizam essa chave, em vez de produzir variantes que deixam de encontrar o mesmo material.

FormatoResponsabilidade
.tmeshAsset de malha, submeshes e LODs
.ttexTexturas e mips com compressão BC; BC6H para HDRI
.tmatMaterial OpenPBR
.tscn / .tpfb / .tcellNível, prefab e célula de streaming
.tprojDescritor de projeto em JSON, fora do contêiner binário
Layout da malha cozida e a extensão planejada para meshlets.
Contêiner de asset cozido: cabeçalho, tabela de chunks e dados.
Asset Properties mostrando um asset cozido e sua estrutura de chunks.
Interface de importação de assets com indicação de progresso.
Content Browser para assets nos formatos do motor.

Extensão planejada

Preparando o caminho para mesh shaders

Mesh shaders não estão implementados no renderizador. O pipeline existente mantém esse caminho aberto: slots da root signature canônica são visíveis a todos os estágios, pipelines usam pipeline state stream, DXC reconhece ms e as no Shader Model 6.5 ou posterior e a detecção de capacidades consulta o suporte da GPU.

Um teste criou com sucesso um pipeline de mesh shader contra a root signature canônica. Isso verifica compatibilidade, não um caminho de renderização entregue. meshoptimizer está escolhido, mas não integrado. O plano é o cooker gerar meshlets em um novo chunk do .tmesh; arquivos antigos manterão o caminho tradicional de vértices quando o chunk estiver ausente. Os contratos do contêiner e do pipeline viabilizam essa extensão.

Fronteira da GPU

O renderizador planeja; o backend executa

IRenderBackend não expõe tipos Direct3D. Recursos usam handles com geração, como Handle<TextureTag> e Handle<MeshTag>, para detectar referências a objetos liberados. Render/ constrói um plano independente da GPU; RHI/D3D12/ o executa. O planejamento pode ser testado sem device.

Nove tags de handle separam categorias de recursos e a geração valida seu tempo de vida. Quando o hot reload aposenta um PSO, um draw que ainda o referencia é pulado. O componente não precisa carregar um ponteiro ou ComPtr para um objeto do backend; a identidade do recurso continua distinta de sua representação Direct3D.

O backend usa Enhanced Barriers por padrão, com fallback legacy, e bindless Shader Model 6.6 com fallback para tabelas de descritores. A root signature ocupa 13 de 64 DWORDs. Uma fila de cópia separada cuida dos uploads; streaming com orçamento de VRAM recua para mips menores sob pressão em vez de remover a cena. O hot reload de shaders reconstrói os pipelines afetados.

A gravação multithread é escolhida quando o volume de trabalho a justifica. Com 23.099 draws, o tempo de CPU do quadro caiu de 207–229 ms para 82–91 ms, ganho de 2,3–2,8×. O quadro comum e pequeno mantém uma única lista de comandos deliberadamente. O custo extra de escalonamento e gravação precisa se justificar.

O plano de render cruza uma interface abstrata antes de ser executado pelo backend D3D12.

Compilação do quadro

Um render graph que produz um plano

Um passe declara leituras e escritas de recursos, tipos de acesso e estágios da GPU. O grafo vê todo o quadro e deriva ordem e barreiras dessas declarações. Nunca grava comandos. O executor D3D12 lê a ordem de execução e as barreiras por passe e então grava o trabalho correspondente.

A compilação monta dependências contra o último escritor anterior, rejeita ciclos com um plano vazio, remove produtores sem uso, seleciona filas, calcula vidas de transitórios e gera barreiras quando o papel do recurso muda. Recursos exportados e efeitos colaterais declarados preservam trabalho necessário; apenas importar um recurso não protege seu produtor da remoção.

Ordem de uso e tempo de vida diferem com compute opcional: posições no plano não descrevem execuções sobrepostas. O grafo fornece intervalos de vida; o dono dos heaps decide aliasing e pede suas barreiras. Meu alocador empacota por vida, requisito que levou à recusa da abordagem por tamanho do D3D12 Memory Allocator avaliado. Oito recursos deliberadamente escalonados usaram 2.688 KB em vez de 10.752 KB, redução de 4,00× e o mínimo para esse teste.

O grafo forward fornecido foi exportado do Sample.tscn em 6 de outubro de 2026. Nessa configuração registrada, 20 passes produzem 15 barreiras. Seis passes desligados de oclusão/ray tracing só abrem escopos vazios: um passe sem escritas não é um produtor sem uso e não é removido automaticamente. A transição destacada de SceneColor antes de ToneMapPass é deduzida da mudança de render target para leitura de shader. As contagens variam com o caminho de shading e os efeitos ativos.

Reset() limpa os dados do quadro preservando a capacidade dos vetores; os handles de recursos do grafo expiram com ele. A exportação Graphviz e o painel do editor expõem o plano; --rendergraph-self-test executa 242 verificações sem GPU.

  1. Declarar

    Importe recursos existentes com seu estado de entrada; crie transitórios indefinidos; use AddPass para declarar Read, Write ou ReadWrite.

  2. Compilar

    Exporte os estados finais necessários, incluindo present para o backbuffer. Compile() deriva ordem de dependências, vidas de recursos e sincronização.

  3. Executar

    O backend consome GetExecutionOrder() e GetBarriers() e emite trabalho na GPU. O planejamento permanece independente de Direct3D 12.

Grafo forward exportado do Sample.tscn em 6 de outubro de 2026; a transição destacada de SceneColor é deduzida pelo grafo.
Painel Render Graph com passes e conexões entre recursos.

Renderização

Iluminação com referência para comparação

O renderizador implementa coat, anisotropia e fuzz do OpenPBR, verificados por furnace test; iluminação baseada em imagem, céu procedural e HDRI; sombras em cascata e clustered light culling. No teste registrado de culling, 125× mais luzes custaram 1,39×. Forward e deferred são intercambiáveis, com SSAO, bloom, autoexposição por histograma e transparência.

DXR inline com RayQuery fornece sombras suaves, oclusão ambiente e reflexos traçados, estes limitados ao deferred. Um denoiser espaço-temporal e orçamentos adaptativos Low/High/Ultra controlam os efeitos em tempo real. Um path tracer de referência mede seu erro. As capturas mostram a cena de amostra e os diagnósticos; os contadores visíveis descrevem essas capturas, não um benchmark para toda cena.

Motion vectors, jitter e reprojeção em Render/TemporalReprojection.* já fornecem o substrato temporal; TAA, motion blur e upscaling temporal ainda são extensões planejadas. QualitySettings e EffectToggle preservam o comportamento padrão sem aplicar um perfil implicitamente. Na comparação de aceitação sem flag, 0 dos 1.440.000 pixels diferem. Async compute está implementado e fica desligado por padrão: o ganho de cerca de 2% no cenário registrado fica abaixo do limiar de 5% escolhido para ativá-lo.

Cena de amostra Sponza renderizada no editor Tessera.
Cena de amostra com o perfil Ultra de ray tracing visível no painel de iluminação.
Visualização de debug de ray tracing no editor.
Controles de iluminação e diagnósticos na configuração capturada.

Autoria

O editor usa os sistemas que expõe

Dear ImGui docking mantém o editor em C++, no processo do motor. A Lobby abre um projeto sem iniciar outro aplicativo. O Content Browser tem miniaturas renderizadas, cache em disco com invalidação automática e imports em segundo plano. Janelas de malha/prefab oferecem previews na GPU; o editor de textura isola canais e empacota ORM. As propriedades dos assets mostram diretamente os chunks binários.

Hierarchy, Inspector, transforms com ImGuizmo, undo/redo, prefabs, tags e cores por asset apoiam a edição de cenas. O Material Graph é uma visualização de leitura derivada do .tmat; sua fiação não é editável. Os widgets dos grafos vêm do GraphEditor do ImGuizmo.

Play, Pause, Stop e Simulate compartilham o mecanismo de snapshot: Stop restaura o mundo capturado e verifica seu hash idêntico. Cenas de autoria usam JSON para diffs legíveis no Git e são cozidas em binário para runtime. Profiling, Render Graph, ECS Diagnostics e Console permitem inspecionar os sistemas em execução no editor.

Editor de asset com preview 3D renderizado na GPU.
Lobby de projetos na entrada do editor.
Outra visão do Content Browser no fluxo de assets.
Material Graph de leitura derivado dos dados do material.
Texture Editor com controles de inspeção de canais.

Escolhas

Dependências com papéis definidos

Escrevo as políticas específicas da engine e uso bibliotecas para problemas delimitados. SDL3 tem seu acesso restrito a Platform/ e UI/; IPlatformBackend delimita os serviços de plataforma. DirectXMath oferece matemática SIMD em todo o motor; DXC compila HLSL Shader Model 6.x. Dear ImGui e ImGuizmo fornecem primitivas de interface, sem uma segunda stack de editor gerenciado.

cgltf, ufbx e meu importador OBJ ficam no cooker. Escolhi ufbx, open source, em vez do FBX SDK por sua triangulação; mikktspace segue as convenções de tangentes das ferramentas de arte. Entre os compressores avaliados, AMD Compressonator ofereceu a qualidade BC7 preferida. stb_image e tinyexr decodificam imagens/HDRI; xxHash identifica conteúdo cozido; nlohmann/json preserva a ordem das chaves para diffs estáveis.

Tracy fornece timelines de CPU/GPU e WinPixEventRuntime nomeia os passes da GPU no PIX. vcpkg fixa versões por baseline de manifesto. Antes de adicionar uma dependência, reviso a licença de cada componente na fonte oficial, com preferência por open source.

Organização do backend

Módulos com ciclo de vida explícito

As features do backend são compostas por três partes: recursos que duram a vida do device, um agregado FrameState reinicializado por uma única declaração e funções livres que recebem (Feature, FrameState, Context). O estado persistente e os dados transitórios têm donos distintos; a reinicialização do quadro não depende de uma lista de flags espalhada pelo backend.

Os contextos de inicialização são específicos da feature. Para gravar os passes, DxFramePassContext fornece os recursos emprestados do quadro. As funções livres não nomeiam DxRenderBackend: alcançam somente o que seus argumentos oferecem. ComputeSceneRect concentra o cálculo do retângulo, distinguindo saída e rasterização; cada passe usa o valor resolvido para manter viewport, picking e composição coerentes.

O critério de aceite combina interface preservada, auto-testes e comparação visual. O registro de 12 extrações de módulos mantém as 85 funções virtual da interface, os resultados dos auto-testes e 0 pixels diferentes na cena de comparação. O levantamento documentado registra 11.116 linhas em DxRenderBackend.cpp. Esses resultados sustentam o método de isolamento; não são uma alegação de ausência de defeitos em todas as execuções.

  1. Device

    A feature mantém recursos persistentes e recebe um contexto de inicialização próprio.

  2. Quadro

    FrameState agrega o estado transitório e é reinicializado de uma vez.

  3. Execução

    Funções livres recebem feature, estado e contexto; a assinatura delimita seu acesso.

Composição de uma feature do backend: recursos com vida do device, estado de quadro e funções livres com acesso delimitado pelo contexto. Diagrama conceitual em inglês.

Validação

Builds e comparações como critérios de design

Sharpmake define os builds da IDE e da linha de comando a partir do mesmo gerador. Com o baseline de manifesto do vcpkg, produz duas soluções em Debug, Development, Profile e Shipping: oito builds locais, todos com avisos tratados como erros. Verificadores pós-build conferem DLLs de runtime e árvores de shaders espelhadas, pois compilar e linkar não provam que os recursos necessários estão presentes na execução.

Testes por subsistema sem janela incluem 4.883 verificações do ECS, 242 do render graph e 837 do cooker. Sondas de linha de comando exercitam recursos individuais; um harness compara tempos e contadores com uma baseline. Os diffs de imagem contra a versão anterior exigem zero pixels diferentes na cena para os critérios de aceitação das refatorações descritos aqui.

Os números vêm dos registros do projeto usados neste estudo. Documentam o método de validação e os cenários medidos, sem representar uma nova execução do repositório privado por este site. O build alternativo, as auditorias de replay e as comparações de imagem verificam falhas diferentes que apenas um build normal bem-sucedido não revelaria.

Próximos passos

Direção de implementação e limites atuais

Meshlets e mesh shaders são os próximos passos da renderização. O plano é gerar meshlets no cooker e armazená-los em um chunk opcional do .tmesh, preservando o caminho tradicional para assets sem esse chunk. O teste de compatibilidade do pipeline já existe; o caminho de renderização por mesh shaders ainda não está implementado.

Quero usar os motion vectors, o jitter e a reprojeção existentes como base para TAA, motion blur e upscaling temporal. Iluminação global permanece planejada. Async compute já é um recurso opcional, com ativação condicionada a ganho medido; a configuração padrão permanece desligada.

Jolt Physics, miniaudio, GameNetworkingSockets e Recast & Detour são dependências escolhidas, ainda não integradas. Um servidor autoritativo para 16 jogadores é um objetivo; snapshots com escopo de replicação e a medição de precisão para mundos de até 200 km² são bases de projeto, sem demonstrar uma rede em funcionamento. Windows é a única plataforma suportada. Determinismo foi verificado na mesma máquina e build; CI e determinismo entre plataformas permanecem fora do escopo validado.

Contato

Cidade de Québec, QC, Canadá / Disponível para oportunidades

Estou aberto a oportunidades em desenvolvimento de software, programação de ferramentas e gameplay, além de vagas de artista 3D júnior. Se minha experiência fizer sentido para sua equipe, será um prazer conversar pelos meus perfis nas redes sociais.