ggrcursos.com

⚠️ Por se tratar de alguns código extensos, irei focar na compreensão do mesmo, evitando de digitar linha por linha, ao invés disso, irei montando o projeto por partes, mas explicando as partes essenciais.

• Part 1

  • Um pouco sobre mim 1
  • Objetivo do curso
  • Link do curso no youtube
  • Tecnologias utilizadas
  • Estrutura do projeto template
  • CMake na raiz do projeto
  • Criando um lib ou um executavel com CMake
  • Projeto no Visual Studio Code
  • Padroes do código ultilizado

• Part 2

  • Abstraindo a camada e render(grafico) e I/0(teclado, mouse e joystick)
  • Adicionando formas geometricas(ponto,circulo,linha,linha,vetor,retangulo)
  • Criando a classe responsavel por gui
  • Compreensão básica do algoritimo de colisão Sat
  • Implementando os exemplos N Tutorial

• Part 3

  • Compreensão básica de fisica e Cálculo aplicada
  • Analisando o core da Box2d Lite
  • Adicionando novas formas geometricas na nossa engine
  • Criando mais testes com as novas formulas
  • Implementando os exemplos N Tutorial

• Part 4

  • Atualizar cmke com nova versão, e atualizar do C++17 para o C++20
  • Refatorar a lib de RenderIO para adicionar textures(.png, e se possivel mapeamento de texture .spine)
  • Implementar a estrutura de um jogo com uma maquina de estados
  • Refatora o IO para controlar joystic , mouse e teclado de forma mais simples
  • Modelar um jogo simples de sinuca com apenas um jogador usando nossa engine e com textura(imagens)
  • Criar uma lib básica com Boost::Asio com o modelo client/servidor
  • Criar um server básico e permitir a conexão de 2 usuários simultaneos no jogo de sinuca

Me chamos Gelson Gomes Rodrigues, e sou desenvolvedor C/C++ a mais de 15 anos, e apaixonado por engines de jogos e criação de bibliotecas, buscando sempre aprender nas novas ferramentas, mas sem deixar o parte de programação raiz que o C/C++ sempre exigiu. Atualmente trabalhando com sistemas distribuidos e desenvolvendo arquitetura de novos produtos.

Aprender a modelar os exemplos que sempre permeiaram nossos livros de fisica e matematica, dando uma abordagem mais prática em como construir os exemplos, e não apenas em usar o conceito em um jogo/simulação final. A formula abaixo por exemplo, é facil de facil compreensão, mas como ela realmente é expressada de forma geometrica, e melhor ainda, como podemos a partir dela resolver problemas relacionados a rotacionar um frame(plano cartesiano(corrdenadas x, y )) em relação ao outro frame?

$\begin{Bmatrix} cosθ &-sinθ\ sin θ & cos θ \end{Bmatrix} \times \begin{Bmatrix} x \ y \end{Bmatrix}$

O gif abaixo demonstra o que iremos encontrar no decorrer desse curso que será fragmentado em várias partes, mas sempre com progressão. Nesse gif, ao invés de apensar visualizarmos e interagir com os exemplos, iremos construi-los, ou seja, vamos modelar e implementar um vetor de forma visual, criar um botão da forma mais manual, etc....

O proximo gif, já demonstra os conceitos aplicados na box2d lite, uma versão simplificada da engine box2D, mas com coneitos avançados para muitos desenvolvedores.

Será implementado um jogo muito básico de sinunca para demontrar os conceitos apreendidos com a engine e também será adicionado uma cadama importante, a de redes, usando o modelo client/server.

• C++17
• Cmake 3.20
• Vs Code 1.78.2 (Com tasks e launch.js)
• Apple clang version 14.0.3 (clang-1403.0.22.14.1)
• GoogleTest(https://github.com/google/googletest)
• Render (Glew,Glad,ImgGui)
• Html5 com javascript Vanilla(mesmo código de C++ porém aplicado em um canvas)

├── cpp_project
    ├── libGelEngine (Lib responsavel por toda a parte da fisica e matematica aplicada)
        └── src
        └── test
    ├── libGelRenderIO ( Criação de um render generico, podendo adicionar outros frameworks, como Sdl2, glut...)
        └── src
        └── test
    ├── projGelCollision2D ( Executavel contendo toda a lógica para Colisão 2D)
        └── src
          └── main.cpp
        └── test
    ├── README.md
├── html5_project  ( Replica do projeto apenas para exemplificar em outra linguagem)
      ├── libGelEngine 
      ├── libGelRenderIO
      ├── projGelCollision2D
          ├── main.js
    ├──index.html

1 - Define uma versão

     cmake_minimum_required(VERSION 3.0)

2 - Setar o nome do projeto

     project("projectName")

3 - Adicionar opção para DESABILITAR/HABILITAR funcionalidades como Test, Boost::, ....

    option(NOME_VARIABEL "Enable/Disable tests" OFF)

Para usar

   if(${NOME_VARIABEL}){...}

4 - Setar variaveis globais como paths(libs, bin,..) e flags para o compilador

    set(CMAKE_CXX_STANDARD 17)
    set(CMAKE_CXX_STANDARD_REQUIRED ON)
    set(CMAKE_CXX_EXTENSIONS OFF)
    set(CMAKE_BUILD_TYPE Debug)
    SET(INSTALLATION_PATH ${CMAKE_BINARY_DIR}/Debug)

    set(LIBRARIES_INCLUDE_PATH "usr/local/include")
    set(LIBRARIES_PATH "/usr/loca/lib64")
    set(LIBRARIES_LIB_PATH "/usr/local/lib")

4 - Para facilitar é possivel baixar e compilar uma lib

   include(FetchContent)
   FetchContent_Declare(
   googletest
   URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
   ) 
   set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
   FetchContent_MakeAvailable(googletest)

   add_subdirectory(test)

5 - Adicionar todos os subdiretórios que possuem seus próprios CMakeLists.txt

     add_subdirectory(diretorio)

1 - Percorrer diretório buscando do .cpp e .hppp

file(GLOB_RECURSE projectName_SOURCES "${CMAKE_CURRENT_SOURCE_DIR}/*.cpp") 
file(GLOB_RECURSE projectName_HEADERS "${CMAKE_CURRENT_SOURCE_DIR}/*.hpp") 

 
set (projectName_INCLUDE_DIRS "")
foreach (_headerFile ${lprojectName_HEADERS})
    get_filename_component(_dir ${_headerFile} PATH)
    list (APPEND projectName_INCLUDE_DIRS ${_dir})
endforeach()
 
list(REMOVE_DUPLICATES projectName_INCLUDE_DIRS)

2 - Criando uma library ou executavel

add_library(Nome ${projectName_SOURCES} ${projectName_HEADERS}  ${outras_libs}    )
#ou
add_executable(Nome ${projectName_SOURCES} ${projectName_HEADERS}  ${outras_libs}    )

3 - Configuração para a lib/executavel

target_include_directories(Nome PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/")
set_target_properties(Nome PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${INSTALLATION_PATH})
install(TARGETS Nome DESTINATION ${INSTALLATION_PATH})

4 - Linkando com uma biblioteca

set(projectName_TARGET_LIBRARIES
    ${CMAKE_THREAD_LIBS_INIT} #pthread 
    )
target_link_libraries(Nome ${libGelEngine_TARGET_LIBRARIES} ${OPENGL_LIBRARIES})

Obs: Tanto o tasks.json quanto o launch.json , devem ficar dentro da vasta .vscode

1 - Criando uma tasks.json

{
   "version": "2.0.0",
   "tasks": [
   	{
   	  "type": "shell",
   	  "label": "nomeTask",
   	  "command": "comand_1, comand_2,...",//exemplo: cmake ../, ls, cd folder,etc.....
   	  "group": "build",
   	  "problemMatcher": []
   	}
 ]
}

2 - Criando um launch.json

{ 
   "version": "0.2.0",
   "configurations": [
     {
       "name": "Nome",
       "type": "cppdbg",
       "request": "launch",
       "cwd": "${workspaceRoot}/",
       "program": "${workspaceFolder}/pastProjeto/build/Debug ou Release/Nome",
       "stopAtEntry": false, 
       "preLaunchTask": "nomeTask",
       "launchCompleteCommand": "exec-run",
       "MIMode": "lldb",//Para Windows possivelmente gdb
       "targetArchitecture": "arm64" // Arquitetura Risc
     }
   ]
}

O padrão não precisa ser rígido, mas em códigos extensos, é importante defini-los.