Ponto V!

Home C/C++ GS2 GS2D e C++: 2D da nova geração em alto nível
André Santee
GS2D e C++: 2D da nova geração em alto nívelImprimir
Escrito por André Santee

Nos últimos 5 anos muito do que mudou no mundo dos jogos está um pouco além do óbvio. Alguns ficaram mais realistas, num nível que impressiona até mesmo o mais experiente dos programadores, e outros tem se expandido através dos consoles e plataformas: consoles portáteis, tablets e smartphones. O que chama a atenção nessa expansão é que, de alguma forma, ao mesmo tempo em que nos PCs e consoles mais poderosos os jogos tendem a alcançar um nível de realismo, especialmente visual, incrível, muitas das técnicas de programação que foram utilizadas nos consoles clássicos, como o SNES e o Mega Drive têm voltado com toda a força em outras plataformas, isso sem ainda citar os numerosos remakes e relançamentos de clássicos de gerações passadas nos consoles atuais.

Qual o motivo e como esse aparente "regresso" acontece? Para responder a essa pergunta dentro do óbvio, temos como exemplo os smartphones e computadores de bolso, cuja capacidade de processamento é, por motivos óbvios, bem inferior ao dos computadores e consoles caseiros. Neles, os jogos precisam ser bem mais "leves", o que não significa que precisam ser simples; e sim que não podem se dar ao luxo de apostar em alto realismo para serem aceitos no mercado. Isso acontece também, em alguns casos, com o próprio computador pessoal, por onde circulam muitos adver-games. Estas e outras categorias de jogos eletrônicos "desenterram" técnicas que poderiam ser consideradas obsoletas, como a programação de jogos 2D, apesar de que nunca esteve realmente morta, voltou com muita força nos consoles portáteis, smartphones, computadores pessoais e até mesmo consoles caseiros.

Além do óbvio, é necessário refletir se o momento de volta dos jogos 2D estaria relacionado a aspectos de nostalgia ou estética. Relançamentos de clássicos da Nintendo como o Super Mario Bros. 3 e The Legend of Zelda - a Link to the Past obtiveram boas vendas e boas críticas no Wii, Castlevania: Harmony of Despair não chega a ser um relançamento mas reaproveita toda a arte e o estilo dos jogos anteriores. Isso é nostalgia. Kirby's Epic Yarn, World of Goo, Braid, Limbo e dezenas de outros títulos fazem uso de ideias e tecnologia novas mas conservam padrões de uso, e leituras do espaço dos clássicos 2D. Isso é estética. Demorou um pouco, mas a indústria já sabe que 2D não é uma limitação técnica dos jogos antigos, mas sim um estilo de game.

O estilo 2D não é necessariamente uma limitação técnica, pois da mesma forma que o hardware evoluiu e transformou a experiência do jogo 3D, essas técnicas podem muito bem ser aplicadas nas duas dimensões. Como neste caso a prioridade não é o realismo, podemos utilizar os shaders e toda a aceleração da GPU para criar efeitos visuais de luz, sombra, água, partículas e o que mais pudermos inventar.

Neste artigo eu não irei explicar conceitos básicos da programação de jogos como o laço principal do jogo, conceitos gerais de sprites e double buffering, além do mais, assumo à partir deste ponto que o leitor já tenha um conhecimento intermediário em C++ e saiba utilizar as funcionalidades básicas de sua IDE, pois aqui mesmo no Ponto V temos diversos artigos que cobrem o assunto. Aqui estaremos focados em como colocar a GS2D para funcionar e como realizar operações básicas.

Para acompanhar este artigo será necessário um PC com Windows XP/Vista/7 e o compilador Visual C++ Express 2008 ou superior.

Usando a GPU para o 2D

O avanço da GPU moderna possibilita que tarefas "caríssimas" como rasterização e blending (transparência) sejam processadas nesta unidade dedicada, deixando a CPU livre para outras tarefas como física e IA. Mas os benefícios para o desenvolvimento de jogos vão muito além dessas operações do pipeline fixo. A GPU avançou a passos bem largos desde que os shaders tornaram-se populares, na época do DirectX 8/8.1. Os shaders e seus avanços subsequentes possibilitam que os programadores literalmente reprogramem alguns pontos específicos do processo de renderização, e isso é processado pela GPU, que ainda tem a possibilidade de utilizar vários núcleos, computando, por exemplo, 16 pixeis ao mesmo tempo com cálculos definidos pelo próprio desenvolvedor, e não fixos, como costumava ser. Isso favoreceu muito o realismo da renderização 3D em tempo real. Para o 2D são muito úteis duas etapas deste processo: cálculo de vértices e de pixeis (os famosos vertex- e pixel shaders).

Enquanto o alto escalão da indústria investiu (e investe) bilhões de dólares focando o uso desses recursos na criação de gráficos 3D mais realistas, onde sem dúvida está obtendo resultados magníficos (basta olhar como anda a CryEngine para se ter uma noção), estúdios menores e outros independentes veem a possibilidade de aplicar esses recursos onde o alto escalão da indústria ainda não sente necessidade de investir: no 2D.

Podemos enumerar alguns pontos onde a GPU moderna pode ajudar muito a vida dos programadores de jogos 2D:

  • A GPU moderna pode processar vértices e aplicar texturas rapidamente, e sprites podem consistir simplesmente de dois triângulos texturizados formando um retângulo.
    • Isso permite o desenho mais rápido de sprites.
    • É possível rotacionar, esticar e realizar qualquer tipo de deformação em sprites com custos de processamento baixíssimos e qualidade muito alta.
    • Também permite o uso de entidades baseadas em vetores dinâmicos e esqueletos, como em World of Goo:
      3_world_of_goo_09
  • Realiza cálculos de alpha blending (transparência) muito rapidamente
    • Isso permite usar e abusar de belos efeitos de luz, sombra, água, fumaça (partículas) etc.:
      alpha
  • Sprites podem ser pré-renderizados à partir de modelos 3D
    • Ferramentas de modelagem podem renderizar normalmaps automaticamente, elas podem ser utilizadas para iluminação de sprites 2D.
    • Materiais diferentes podem pré-renderizar personagens no estilo cel-shading, pixel art, etc. não sendo mais necessário desenhar sprites à mão ou em pixel art, e mesmo assim, com efeitos de pré-renderização, os jogos atuais podem conservar esses estilos clássicos.
  • As cenas podem ter Ordenamento de profundidade calculado pela GPU com depth/z-test.
    • Assim a CPU não precisa se ocupar ordenando as entidades da cena antes de desenhá-las:
      depth_test
  • Como estamos trabalhando com polígonos e texturas, shaders podem ser utilizados da mesma forma que são utilizados no 3D, trazendo uma infinidade de possibilidades nunca antes vistas:
    • Efeitos de luz e sombra com muito detalhe
    • Refração e reflexo na água e outras superfícies
    • Efeitos de distorção e ondas em superfícies
    • Decals mais realistas e complexos
    • Nuvens mais realistas
    • Bloom, glow, HDR...
    • Etc. etc. etc...
      chronno_trigger

Agora que já conhecemos as possibilidades, vamos conhecer uma ferramenta que coloque isso em prática.

Introdução

Desenvolver jogos 2D em plataformas que utilizam o hardware atual requer um excelente conhecimento de computação gráfica em 3D e o domínio de alguma API gráfica moderna, como OpenGL ou Direct3D. É com o intuito de fornecer uma camada de abstração entre o universo dos sprites 2D e a computação gráfica avançada que foi criada a GS2D.

GS2D é a versão 2.0 de um trabalho meu que começou a vários anos atrás, a GameSpaceLib, surgindo com a ideia de criar, a fins de estudo, uma biblioteca em C++ que fosse o mais fácil possível de se utilizar e fornecesse uma coletânea completa de funcionalidades multimídia para a criação de jogos sem que haja necessidade de uso de nenhuma biblioteca adicional para os gráficos, áudio, entrada de dados e reprodução de vídeo. Além do mais, a intenção foi criar um sistema que utilizasse a GPU moderna para renderização de sprites, e que possibilitasse facilmente o uso de shaders, render-targets e outros recursos tipicamente utilizados nos gráficos 3D, como z-test, scissors, entre outros.

A GameSpaceLib não foi um trabalho pioneiro pois já existiam outras bibliotecas excelentes, gratuitas e open-source dedicadas ao 2D, como a ClanLib (existem outras, por favor escrevam-me informando quais são para que eu possa colocar aqui), mas obteve uma aceitação legal apesar de alguns problemas de design do ponto de vista da programação orientada a objetos. No entanto suas peculiaridades permitiram que ela não fosse considerada irrelevante, o que acontece com muitas implementações em software de problemas já resolvidos.

Foi para resolver problemas de design da GameSpaceLib e melhor aproveitar o poder de multiplataformidade (permitam-me o neologismo) da linguagem C++ que decidi criar a GS2D, como uma versão 2.0 da GameSpaceLib. Os mecanismos que facilitam a programação e poupam centenas de linhas de código estão presentes, o que muda é a forma com que o código se apresenta. Ainda há uma enorme lista de tarefas a serem concluídas, mas este é um projeto aberto, gratuito e que recebe de braços abertos colaborações da comunidade.

A GS2D é utilizada pelo motor, também em desenvolvimento por mim, Ethanon Engine, nele é possível ter uma ideia do que a GS2D pode fazer, e tudo com muita facilidade, como ilustra o pequeno trecho de código a seguir:

VideoPtr video;

// cria a janela
if ((video = CreateVideo(1024, 768, L"Ethanon Engine", true, true, L"fonts/", GSPF_UNKNOWN, true)))
{
    // Prepara gerenciadores de áudio e entrada de dados
    InputPtr input;
    AudioPtr audio;
    input = CreateInput(0, false);
    audio = CreateAudio(0);

    // Carrega sprite
    SpritePtr nave = video->CreateSprite("nave.png");
    ...
    ...
    nave->Draw(Vector2(x,y)); // desenha sprite
}

O exemplo acima cria a janela para renderização e já prepara os gerenciadores de áudio e entrada de dados para uso, carrega e cria um sprite a partir da figura "nave.png" e, mais adiante desenha-a nas posições x e y.

Download

O projeto atualmente está disponível na página do motor Ethanon, hospedado no SourceForge.net. No repositório encontra-se também uma solução standalone da fonte, permitindo que a biblioteca seja utilizada em outros projetos independentemente do motor.

Para fazer download da GS2D basta acessar o diretório /trunk/toolkit/Source/src/gs2d/ no repositório do motor Ethanon e clicar no link Download GNU tarball, baixando toda a pasta gs2d do repositório, o que totaliza aproximadamente 10 MB. Para descompactar o aquivo recomendo o 7-zip.

Na pasta gs2d/ encontra-se o arquivo gs2d.sln, solução do Visual C++ que compila a biblioteca.

Iniciando o projeto

Aqui veremos um breve passo-a-passo de como compilar e utilizar a GS2D. A IDE utilizada foi o Visual Studio Express 2008, pois a versão 2010 encontra-se razoavelmente instável no momento em que este artigo é escrito, mas quem preferir utilizar a versão mais recente não terá muitas dificuldades.

Importante: o projeto utiliza cabeçalhos e binários de terceiros, como do NVIDIA Cg, Direct3D e Boost. No entanto, não é necessário adquirir estes pacotes separadamente, eles encontram-se compactados dentro do próprio repositório. Para instalá-los é necessário executar o arquivo gs2d/vendors/unpack_vendors.bat. Este BAT instala automaticamente todos os arquivos necessários para compilar o projeto, isso inclui arquivos de cabeçalho e bibliotecas estáticas assim como as bibliotecas dinâmicas (DLL). Lembre-se de que todas as DLLs necessárias para rodar o programa depois de compilado encontram-se nos diretórios vendors/CgSDK/bin e /vendors/DX9SDK/bin.

Abra a solução gs2d.sln. Você verá ao lado esquerdo da tela, no Solution Explorer, três projetos: gs2d, Platform e Testbed. Clique com o botão direito do mouse em Testbed e selecione Set as StartUp Project para que a IDE inicie este executável durante os testes.

IDE01

Abra o separador Source Files e abra o arquivo main.cpp:

IDE02

Pressione F5 ou clique no botão RUN para compilar e executar a aplicação de teste. Se tudo correu bem, você verá uma janela semelhante à da imagem seguinte:

WINDOW

Nota: a compilação poderá exibir algumas mensagens de alerta relativas ao uso do padrão UTF8. Isso ocorre pois o projeto está em processo de implantação do modelo I18N que possibilita a utilização de fontes nos padrões internacionais (ex.: russo, japonês, etc.). Por enquanto essas mensagens podem ser ignoradas pois são de uso interno, mas mantenha a versão da GS2D sempre atualizada até que o modelo seja totalmente implantado com segurança.

Se tudo funcionou como deveria, podemos prosseguir.

Primeira janela

As poucas linhas de código contidas no arquivo main.cpp cuidam de inicializar a janela e rodar o laço principal. Vamos ver a versão comentada deste programa introdutório:

#include "../gs2d.h"

//  Todos os componentes da GS2D encontram-se no namespace
// gs2d. Essa linha é opcional, mas torna a leitura do código mais fácil
using namespace gs2d;
using namespace math;
int main()
{
    // O objeto Video (VideoPtr é um smart-pointer de Video) cuida de toda a parte
    // gráfica da aplicação. Ela que for
    VideoPtr video;

    if ((video = CreateVideo
            (
                800, // largura do back buffer
                600, // altura do back buffer
                L"Primeira janela", // título da janela
                true, // true para modo janela e false para fullscreen
                true, // true para habilitar a sincronização vertical
                L"fonts/" // sub-diretório onde a aplicação deve buscar as fontes
            )))
    {
        Video::APP_STATUS status;

        // Repete o laço enquanto ::HandleEvents não retorna APP_QUIT
        while ((status = video->HandleEvents()) != Video::APP_QUIT)
        {
            // Isso faz com que nada seja desenhado se o sistema operacional assim ordenar
            if (status == Video::APP_SKIP)
                continue;

            // Entre Begin e End devem ficar todas as operações de desenho
            video->BeginSpriteScene();
            // desenha tudo aqui...
            video->EndSpriteScene();
        }
    }
    return 0;
}

A classe gs2d::Video (VideoPtr é um smart-pointer de Video) cuida de toda a parte gráfica da aplicação. Ela é a responsável por fornecer a camada de abstração entre o 2D e a API gráfica. Por ser uma interface, Video não pode ser instanciada pelo usuário, por isso é necessário utilizar a função CreateVideo(...) que cria a instância de VideoPtr ao mesmo tempo em que inicializa o thread da aplicação e a janela gráfica.

Fácil, não? Agora que tal colocar alguns sprites na tela?

Desenhando sprites

O objeto gs2d::Sprite cuida de carregar e armazenar instâncias de sprites 2D. Elas podem estar no formato PNG, DDS, BMP, JPEG ou TGA. É possível especificar qual será a cor de fundo (máscara/recorte) manualmente especificando o valor RGB do pixel, ou utilizar a camada de transparência do próprio arquivo, se ele for PNG ou DDS.

A GS2D pode carregar sprites de arquivos armazenados no disco rígido ou de arquivos armazenados na memória virtual, o que é útil quando se trabalha com pacotes. Aqui veremos a maneira mais comum e simples, que é criando sprites à partir de arquivos avulsos.

Escolha uma pasta onde serão colocados os sprites do nosso programa, clique novamente com o botão direito sobre Testbed, selecione a opção Debugging e entre em Working Directory com o caminho completo (isso inclui "C:/...") para o diretório que foi escolhido para armazenar os sprites e demais recursos que vamos utilizar neste artigo e nos próximos que virão:

IDE03

Agora faça o download da imagem a seguir e coloque na pasta escolhida:

nave

Agora vamos ao código:

#include "../gs2d.h"

using namespace gs2d;
using namespace math;
int main() { VideoPtr video; if ((video = CreateVideo(800, 600, L"Primeira janela", true, true, L"fonts/"))) { // Cria uma instância de SpritePtr e armazena nela um sprite SpritePtr nave = video->CreateSprite(L"nave.png"); assert(nave); // verifica se a nave foi instanciada com sucesso Video::APP_STATUS status; while ((status = video->HandleEvents()) != Video::APP_QUIT) { if (status == Video::APP_SKIP) continue; video->BeginSpriteScene(); // Desenha o sprite no ponto 300,200 da tela nave->Draw(Vector2(300, 200)); video->EndSpriteScene(); } } return 0; }

O método Video::CreateSprite também pode receber um parâmetro de cor de máscara, caso o sprite possua uma cor de fundo que deverá ser recortada:

nave_verde

// o primeiro valor em GS_COLOR equivale ao alpha do pixel
SpritePtr nave = video->CreateSprite(L"nave_verde.png", GS_COLOR(255,0,255,0));

O método Draw também possui alguns parâmetros adicionais:

bool Sprite::Draw(
  const Vector2 &pos,   // posição do sprite
  const GS_COLOR color, // valor de cor que será modulado à superfície do sprite (o valor padrão é o branco)
  const float angle,    // ângulo de rotação (em graus) do sprite
  const Vector2 &scale  // escala do sprite (o padrão é Vector2(1,1))
)

Uma instância de Sprite pode ser utilizada para renderizar o sprite várias vezes no quadro:

video->BeginSpriteScene();
nave->Draw(Vector2(300, 200), GS_COLOR(255,255,0,0));
nave->Draw(Vector2(400, 100), GS_COLOR(255,0,255,0), 45.0f);
nave->Draw(Vector2(100, 300), GS_COLOR(255,0,0,255), -90, Vector2(3.0f, 3.0f));
video->EndSpriteScene();

Este trecho desenha o mesmo sprite três vezes por quadro, aplicando cor, escala e ângulo diferentes:

WINDOW_2

Os objetos da GS2D foram planejados para ser autoexplicativos, basta uma olhada no código para compreender como funcionam os métodos. Por esse motivo é recomendável uma olhada no arquivo gs2d.h para conhecer outros métodos e objetos da biblioteca.

Conclusão

O objetivo deste artigo foi mostrar ao programador como configurar a solução e utilizar a GS2D, além de apresentar algumas das características básicas de suas interfaces. Aqui vimos apenas uma pequena parte dela. Nos próximos artigos pretendo mostrar como funcionam os sistemas de recorte de sprites, entrada de dados, efeitos sonoros e áudio. A ordem desses artigos vai depender apenas dos comentários e do interesse dos leitores do Ponto V, portanto, manifestem-se!

Um bom código para vocês!


Comentários (44)
  • Marcos Koga  - Muito bom e muito claro.
    avatar

    Cara, gostei muito. O artigo está excelente e tudo ficou bem claro.

    Pretendo dar uma estudada na GS2D para usar na Game Jam =D Parece ser muito prática.

  • Carlos  - Muito bom
    avatar

    :woohoo: :woohoo: :woohoo: Nossa que da hora :3~~ muito bom André ja baixei e tava mexendo supera algumas enginners que testei :D...

    Você pretende colocar algum sistema de física na lib? Poderia fazer um exemplo de angulo no próximo tutorial rs é estou tendo dificuldade em girar a sprite aqui ^^"""


  • Anônimo  - re: Muito bom
    avatar
    Carlos Escreveu:
    :woohoo: :woohoo: :woohoo: Nossa que da hora :3~~ muito bom André ja baixei e tava mexendo supera algumas enginners que testei :D...

    Você pretende colocar algum sistema de física na lib? Poderia fazer um exemplo de angulo no próximo tutorial rs é estou tendo dificuldade em girar a sprite aqui ^^"""

    Ah esquece ja consegui mexer no angulo XD... Sabe como é na ansiá de aprender a mexer nem lê o manual kkkkk. Poxa André novo GameSPaceLib ? Mal peguei o GS e tu me aparece com o GS2 rs vai ter muita diferença? :cheer: desde ja obrigado

  • André Santee
    avatar

    Oi Carlos,
    que bom que você já conseguiu rotacionar o sprite :)
    Bom, não sei se fico claro no artigo, mas a GS2D é a nova gamespaceLib, mas não se preocupe pois não haverá grande mudanças exceto as de estilo como já deu para ver por este artigo.

  • SHIKAKUU
    avatar

    gostaria de uma resposta sincera, sei que isso depende de marketing e etc, mas estou pensando em fazer um game 2d plataforma e gostaria de saber, se vc ganhou algum dinheiro no ramo dos game e se sim quanto ??

  • Anônimo
    avatar

    Excelente,biblioteca e motor gráfico muito promissores, só falta sair um bom jogo que faça uso dela.

  • André Santee
    avatar

    Olá, já existe sim, é o Penumbra: http://www.youtube.com/watch?v=tcAZAgychRw
    Ele foi feito por mim para participar do concurso e-games do Senac. Ele utiliza o motor Ethanon, que por sua vez é inteiramente baseado na Gs2D, em tudo.

  • Vinícius Godoy de Mendonça
    avatar

    Nossa, esse jogo nem eu conhecia. Sensacional André. :)

  • André Santee
    avatar

    Obrigado! Esse aí eu divulguei pouco, quase ninguém conhece.

  • Marcos Koga
    avatar

    Bah!, muito bonito o efeito visual! O bom que com isso dá para se ter uma idéia da capacidade da engine que a propósito, achei fantástica =3

  • Adriano
    avatar

    :D Esse penumbra parece ser muito bom.

    O engraçado é que eu me inscrevi na unidev para baixar coisas desse tipo, mas até hoje...

  • PotHix  - IDE
    avatar

    Æ!!

    Bem legal essa engine
    Os pequenos tutoriais poderiam ser feitos sem IDE.
    Nesse caso nem precisa de tanta coisa, e deixar preso a "menus" da IDE é um pouco chato, até por que, cada um gosta de uma IDE/Editor diferente.

    Pelo menos eu prefiro não usar IDEs na maior parte do tempo :)

    Mas é só uma sugestão. Eu nem sou do mundo Windows :P

    Há braços

  • Mauricio  - Show
    avatar

    Cara, lindo o teu jogo, vou comessar a testar a engine e tudo mais =]
    Sou novo nesse mundo de desenvolvimento de jogos, mas gostaria muito de saber fazer algo como o seu jogo sauhuhassuha


    Abraço :woohoo:

  • Lucas
    avatar

    Parabéns André!
    Sempre ví tópicos e artigos sobre a GameSpace na Unidev mas nunca parei para olhar, mas depois de ler esse artigo me sinto no dever de te parabenizar pelo seu trabalho.
    Quando vejo pessoas esforçadas e com tanto conhecimento nessa área me sinto até envergonhado e chega até a ser desanimador pensar que tenho tanta preguiça no pouco tempo livre que tenho para progredir nos estudos.
    Mas depois de ler seu artigo senti que ainda não é tarde pra correr atrás disso, mesmo sabendo o quão maçante é estudar e progredir nessa área de jogos.
    Posso te perguntar uma coisa? Você trabalha na área de jogos ou é só um hobby?
    É que eu 'brinco' com isso há vários anos, mas nos últimos dois anos comecei a trabalhar e estudar e não sobrou tempo pra praticar, estudar, pra nada relacionado a jogos.
    To pensando em parar de trabalhar aonde estou atualmente esse ano para me dedicar a isso, que é o que eu realmente gosto, mas não sei se compensaria e me traria algum retorno, ainda mais no Brasil.
    Desculpe pelo texto gigante, espero que leia, mas se não ler tudo bem, não te culpo haha
    Parabéns novamente

  • André Santee
    avatar

    Oi Lucas,
    obrigado pelos parabéns, mas não acho que mereço tantos e nem acho que você deva ficar desanimado. Quando você é programador, principalmente de softwares que envolvem tantas categorias como os jogos, você vê que esse é um constante exercício de admitir o quão pouco se sabe ainda sobre isso ou aquilo. Então eu recomendo nem ficar refletindo sobre o tanto que já se sabe e o tanto que não se sabe, apenas trace algumas metas e comece a desenvolver, e o aprendizado vem conforme você se depara com os problemas e na hora de encontrar uma melhor solução para o objeto. Também recomendo estudar bastante a orientação a objetos em C++ assim como suas aplicações e técnicas mais recentes, isso é um desafio para todo programador, principalmente para mim.
    Ah! E sobre a profissão, no momento estou trabalhando em meu motor e tenho algumas metas traçadas para ele, mas estou à procura de um empresa legal onde eu possa desenvolver outros projetos ou mesmo que eu possa continuar desenvolvendo um meu já com um olhar mais comercial.

  • Alan de Oliveira  - Cool
    avatar

    andré estou sem palavras para descrever seu trabalho.

    chega estou triste.XD

  • Vivian  - Demais
    avatar

    André muito boa a bilioteca! estrá bem mais simplificada que a priemira gamespacelib e olha que aquela era simplificada! No meu curso aprendemos a fazer jogo 2d com a ALLEGRO que cá entre nós é uma droga. só sugiro dizer aos iniciantes que é necessário colocar algumas dlls na pasta system do windows senão ele não roda. aguardo mais tutoriais, e se quer uma dica, faça um tuto de como utilizar a sua engine com objetos totalmente orientados a objetos. com métodos apenas para inicializar, calcular e desenhar, de um modo que o código fique limpo e fácil de entender.

  • Bruno Crivelari Sanches
    avatar

    Apenas um comentário meio off-topic: para o Allegro rodar (ou qualquer outra lib que use dlls) não é necessário colocar dlls no system, pasta deixar as dlls na mesma pasta do executável do seu jogo que já é o bastante.

    T+

  • Tácio Mendes (FoxT  - "Um pobreminha dá memo..."
    avatar

    Olá pessoas! :cheer: :cheer: :cheer:

    Depois de exatamente 13 emails trocados com o autor do post! e alguns ajustes que ele fez nos arquivos! Eis algumas dicas importantes:

    Depois de seguir os passos descritos no post e de dar unpack, você precisa pegar os arquivos que estão em: gs2d\vendors\CgSDK\bin

    E colocar ou na system32 ou na pasta do seu projeto.

    Se você não fizer isso, quando for rodar o projeto ele vai dizer que não consegue encontrar uma dll: cg.dll

    Se você colocar na system32, você nao vai precisar configurar nada, e as dlls estarão disponíveis para qualquer novo projeto que use os recursos da GS2D.

    HOWEVER, ON THE OTHER HAND

    É muito melhor você colocar na pasta do projeto que você tá usando, porque aí fica bem mais fácil na hora de empacotar tudo e distribuir ^_^

    Eu não sei exatamente onde eu colocaria se tivesse colocado na pasta do projeto, talvez na TestBase no caso desse exemplo, não tenho certeza.

    Por favor me corrija se eu estiver errado André! :)

  • Bruno Crivelari Sanches
    avatar

    Qualquer projeto que utilize dlls tem esse "problema".

    Colocar na System 32 é uma pessima prática por poluir o diretório do sistema e não é nada recomendável.

    Para o projeto funcionar basta lembrar as regras do Windows na hora de procurar uma dll, ele sempre vai olhar (não sei se a ordem esta correta):
    1 - Diretório de execução do programa
    2 - Diretório do executável
    3 - Diretórios do PATH
    4 - Diretórios do sistema

    Se não encontrar em nenhum desses pontos, dai tem o erro.

    Eu prefiro sempre deixar as dlls no seu local de origem ou no bin da lib mesmo e no projeto do visual, configuro a variável path, que pode ser feito:
    Com a solução aberta, clique com o botão direito do mouse no projeto, selecione propriedades e então: Debugging -> Environment

    Na caixa Environent, coloque:
    PATH=c:\MinhaLib\bin\

    Substitua o caminho pelo caminho de onde estão as dlls, pode-se usar múltiplos caminhos separados por ; e variáveis de ambiente.

    T+

  • André Santee
    avatar

    Como eu havia dito em algum dos e-mails, não é muito bom colocar na system32, é melhor copiar para o working dir. Caso contrário iIsso pode gerar uma bagunça no seu sistema e eu não quero isso para vocês :)

  • Tácio Mendes - (FoxT)  - Mas...
    avatar

    "Eu prefiro sempre deixar as dlls no seu local de origem ou no bin da lib mesmo e no projeto do visual, configuro a variável path, que pode ser feito:
    Com a solução aberta, clique com o botão direito do mouse no projeto, selecione propriedades e então: Debugging -> Environment"

    Mas... Isso não complica um pouco as coisas na hora de distribuir? quer dizer, tu vai ter que sair catando dlls pra fazer o executável não?

    Ou tu tem alguma ferramenta pra gerar o instalador que faz isso automáticamente?

    Vlws pelas dicas!!! :lol:

  • Bruno Crivelari Sanches
    avatar

    Não sei dizer se tem tool que gere isso, geralmente são poucas dlls e administro isso manualmente criando um script que copia todos os arquivos a distribuir. É facil testar se falta alguma dll numa segunda maquina, o duro mesmo na hora de distribuir é controlar os assets.

    T+

  • Anônimo  - Marecelo
    avatar

    Ótimo tutorial :side:.Mas eu estava fazendo um projeto com o GameSpaceLib e fiquei sabendo que ele seria melhorado, eu queria saber André tem uma perspectiva de quando sairá o GameSpaceLib 2?

    Obrigado =)

  • André Santee
    avatar

    Olá, a GSlib 2 é justamente esta abordada neste artigo, então ela já está disponível.

  • Hildebrando Segundo
    avatar

    A licença desta versão ainda é o LGPL ou MIT ? :woohoo:

  • Anônimo  - re:
    avatar

    Ah a possibilidade de integrar a engine de física Box2d, para dar maior realidade nos jogos 2d?

  • Anônimo
    avatar

    parabéns cara fico dahora :!:

  • Eduardo Campelo
    avatar

    muito bom este artigo, gostaria que postasse artigos futuros do GS2D como mencionado na conclusão e seria interessante mostrar um pouco a integração do GS2D com Box2D, deve ser muito maneiro a integração dessas duas engines :D

  • Marcius Oliveira  - Parabéns
    avatar

    Cara muito bom o seu artigo, vou dar uma estudada e fazer uns testes, vou acompanhar a evolução.

  • rnt
    avatar

    André, não tenho a versão do Visual Studio 2008, poderia fazer um guia de como compilá-la no VS 2010 ?

    Tive problemas na hora de abrir (e converter) o projeto audiere.

    E após conseguir compilar, ao criar um novo projeto tive conflitos de linker, eu sei que aos poucos dá pra corrigir, mas, seria legal um tutorial ou o *.vcxproj.

    Outra dica seria um template pra criação de projetos, ía facilitar bem (:

  • Renato
    avatar

    Olá André! É possivel utilizar a GS2d no Dev C++ ? Se sim, por favor me ajude pois estou tendo problemas para configura-lo :(

    Obrigado!

  • Vinícius Godoy de Mendonça
    avatar

    Olá Renato. Independente da GS2D, não recomendo o uso do DevCpp. Existem vários motivos para isso:
    a) O Dev vem com uma versão velha, muito velha, do compilador MinGW.
    b) O Dev tem o péssimo hábito de truncar parte das mensagens de erro, o que te impede de ler o erro completo. Isso pode fazer com que você gaste horas procurando um bug;
    c) O Dev quase não tem suporte a depuração.

    Se fizer questão de uma IDE com compilador MinGW, use o Code::Blocks:
    http://www.codeblocks.org

    Se não fizer questão, use o Visual C++ Express:
    http://www.microsoft.com/visualstudio/en-us/products/2010-editions/vis ual-cpp-express

  • Bruno Crivelari Sanches
    avatar

    Eu como adepto da filosofia "eat your own dog food" adiciono: O Dev é tão ruim, que nem os desenvolvedores dele usam, pois é feito em Delphi.

    IDE que é IDE, serve para fazer ela mesma :).

    T+

  • Bruno  - Lib muito foda!
    avatar

    Parabéns!

    Eu to apanhando pra configurar ela standalone no VC++ Express 2010

    Alguém aí tem uma dica ? =x

    Abraços!

  • Willams S. de Sousa  - O projeto Audiere não está carregando no Visual C+
    avatar

    Alguém aqui conseguiu compilar no Visual C++ 2010? O projeto Audiere não está carregando...

  • Willams S. de Sousa  - Compilei!
    avatar

    Para quem está tendo problemas com o audiere e a compilação do gs2d no Visual C++ 2010, segue o que é necessário fazer para compilar:

    1) Adicione a lib Platform_d.lib no projeto testbed dessa forma:

    #pragma comment(lib, "../../../lib/Platform_d.lib";)

    A Platform_d.lib tá na pasta lib no diretório indicado aí em cima.

    2) baixe a audiere no sourceforge http://sourceforge.net/projects/audiere e adicione a lib do audiere na pasta lib (junto do Platform_d.lib) e adicione a audiere.lib no projeto testbed assim:

    #pragma comment(lib, "../../../lib/audiere.lib";)

    3) Nesse momento o projeto compila, mas não roda, adicione as dlls que o windows reclama na pasta gs2d\projects\msvc9\Testbed.

    Isso compila e roda, porém tá faltando o png tileset.png, daí dá erro, mas isso é de menos...

  • Bruno Crivelari Sanches
    avatar

    Na verdade, tirando o uso do pragma, que não recomendo, ainda mais para se usar uma biblioteca portável, esse é o processo padrão de se configurar uma biblioteca para ser usada num projeto C++, que é explicado em detalhes neste artigo (mas sem usar o pragma): http://www.pontov.com.br/site/cpp/41-visual-c/292-configurando-o-uso-d e-bibliotecas-no-visual-2010

    T+

  • Calebe Bartolomasi
    avatar

    Cara, estou começando agora a estudar programação e estou começando por C/C++, estou interessado em criação de jogos, mas não manjo nada, baixei umas apostilas de lógica da programação, inclusive uma que um amigo me mando da faculdade que ele faz, de Ciência da Computação, se não me engano.

    Mas o que eu gostaria de saber, é se vale a pena fazer uma faculdade, se sim, qual? Eu achei interessante a Unisinos do Rio Grande do Sul, o curso de Jogos Digitais. Mas vi um cara falando que essas faculdades não são muito boas. O que você me recomendaria?

    Obrigado!
    Calebe

  • Bruno Crivelari Sanches
    avatar

    Bom, pelo jeito você se identifica com programação, se for mesmo o caso, provavelmente ciência da computação é o mais recomendado se seu grande interesse são os jogos.

    Depois que terminar a graduação, faça uma pós na área de jogos.

    Graduação em jogos eu não recomendo, não consigo imaginar um programador de jogos sem toda a bagagem da CC (ciência da computação) e todos os cursos que já vi por ai, tem no máximo a mesma duração de um curso de CC, então não consigo imaginar como um curso desses vai lhe passar toda a CC e ainda adicionar conteúdo de jogos, certamente vai ser deficiente.

  • Bruno Ferreira  - Problema...
    avatar

    Tenho um problema, quando faço f5 para abrir a janela preta, ela abre mas fecha logo.

    Não sei porque, eu fiz tudo o que ta no post e uso VB 2008 Express, será de ter o windows xp profissional 32bit?

    Alguem sabe como resolver o problema?

    debug:
    'Testbed.exe': Loaded 'C:\Documents and Settings\Bruno.TSUNAMI.000\Ambiente de trabalho\gs2d\Debug\Testbed.exe', Symbols loaded.
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\ntdll.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\kernel32.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\d3d9.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\d3d8thk.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\gdi32.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\user32.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\msvcrt.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\advapi32.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\rpcrt4.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\secur32.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\version.dll'
    'Testbed.exe': Loaded 'C:\WINDOWS\system32\winmm.dll'
    Debugger:: An unhandled non-continuable STATUS_DLL_NOT_FOUND exception was thrown during process load
    The program '[2860] Testbed.exe: Native' has exited with code -1073741515 (0xc0000135).

  • Michael  - Muito bom!!!
    avatar

    Meus parabéns André, a engine ficou bem legal, o código é limpo e tenho certeza que fará sucesso :)

    Ahh e tem uma biblioteca multimídia que é muito usada para games, é a SDL. Estou até fazendo um projeto com ela, os fontes estão aqui:

    https://mega.co.nz/#!khQRmB5B!-XYqc-epK1JJQLFcbwzYJpHvHfih40G6eCp8k NyWDYY

    em breve vou postar vídeos no meu canal do youtube de desenvolvimento de games e dou um toque na galera pra conhecerem o seu projeto :cheer:

    VLW!! :)

Escrever um comentário
Your Contact Details:
Gravatar enabled
Comentário:
[b] [i] [u] [url] [quote] [code] [img]   
:angry::0:confused::cheer:B):evil::silly::dry::lol::kiss::D:pinch::(:shock:
:X:side::):P:unsure::woohoo::huh::whistle:;):S:!::?::idea::arrow:
Security
Por favor coloque o código anti-spam que você lê na imagem.
LAST_UPDATED2  

Busca

Linguagens

Twitter