[Curso Gm 3D] Aula 6: Modelos animados (.md2)

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, Modelos animados (.md2).
PRÉVIA:Nesta aula, vamos falar sobre Modelos animados (.md2), que serão renderizados no GM por meio de uma extensão.
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.

INTRODUÇÃO

Bom, começo lhes informando que vamos ter que adotar recursos externos para realizar esta atividade, pois o GM por si só não consegue renderizar os modelos em .md2 , por isso vamos usar o GMSDK,que é uma extensão para o GM, feito pelo jiraya, Colaborador da GMBR.

Muito já se falou da limitação do GM no 3D, com arquivos animados por bones, essa limitação é ainda maior, fiz alguns testes com a velocidade de renderização, e de rotação maior de frames, e o GM não suportou! portanto nem abordarei aqui sobre velocidade de mudança dos frames, visto que o GM não suporta essa ação.
O que vamos fazer será uma engine simples, com um modelo externo .md2 animado.
Então antes de mais nada, baixe o GMSDK.
Aprenda a instalá-lo AQUI.

SEQUÊNCIA

O uso de modelos externos consiste nas etapas:

criação: Onde dizemos ao GM que queremos reservar um espaço na memória para utilizarmos com algo, este espaço será representado por um índice, que usaremos em todas as funções relacionadas a este modelo.
No caso da GMSDK, essa função já vai criar e carregar o modelo para a memória de uma só vez, evitando que usemos duas funções para isso. Por causa dessa função de carregamento ser um tanto quanto pesada e demorada, devemos executá-la apenas uma vez! E é bom que isso seja feito na primeira room do jogo, para depois passarmos às próximas e não voltarmos mais nela.
Iremos usar a função: global.ÍNDICE=d3d_md2_load("nome_do_modelo.md2")
*O modelo deve estar na mesma pasta que o jogo.
*ÍNDICE é a variável que está guardando o id do modelo.

renderização: Nesta parte, o modelo será renderizado na tela!
Por isso devemos usá-la no draw do objeto.
Função: d3d_md2_draw(global.ÍNDICE,x,y,z,background_get_texture(background))
*A background é a textura que o modelo terá.
*ÍNDICE é a var que contém o id do modelo.

PRÁTICA

Abra a nossa primeira engine!
Se nao tem , baixe-a AQUI.
Após abri-la, não se esqueça de ativar a GMSDK para o projeto atual, clicando na "cruzinha verde" do menu, selecionando GMSDK, e dando OK.

««Let´s go»»

*Crie uma nova room, coloque o nome dela de load, e ponha ela como a 1ª do jogo.
no creation code dela, coloque:
//inicia a GMSDK no modo 3d
d3d_init()
//carregamos o modelo animado externo (.md2), e guardamos seu índice de criação na var model_char.
global.char=d3d_load_md2("char.md2")
//mudamos de room
room_goto_next()


*Baixe essa textura: 

http://dl.dropbox.com/u/43446077/tutoriais/bchar.png
Crie uma background, e coloque ela,ponha o nome de: bchar

*Crie um objeto, e coloque o nome dele de: ochar.
No create dele,coloque:
//definimos a var z=0 para o objeto:
z=25

No draw:
//desenhamos o modelo na posição do objetos na room, com a textura indicada:
d3d_md2_draw(global.char,x,y,z,background_get_texture(bchar))

No Key_Press_Space:
//exibimos uma mensagem, mostrando qual frame está sendo renderizado no momento / quantos frames ele tem,
show_message("
FRAMES: "+string(d3d_md2_frame_index(global.char))+" / "+string(d3d_md2_frames(global.char)))

*Coloque o objeto ochar na 2ª room, que é onde está a câmera, e teste o jogo.

Caminhe até o objeto, e veja que o modelo renderiza a animação perfeitamente!

Se você não conseguiu fazer a engine, aqui vai o link: DOWNLOAD

CRÉDITOS:
Modelo do char e textura: Engine de exemplo da md2.dll .


Até + !

[Curso Gm 3D] Aula 5: TRANSFORMAÇÕES

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, Transformações.
PRÉVIA:Nesta aula, vamos falar sobre transformações, que são ações aplicadas sobre os nossos shapes e modelos,afim de move-los,escala-los ou rotaciona-los .
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.


                                          INTRODUÇÃO

As transformações no Game Maker são um ponto forte dos jogos 3D.
As ações usadas são: Escala,Rotação e Posição, elas nos permitem alterar um modelo mesmo após definido sua forma e atributos básicos.
Elas devem ser usadas no evento draw do objeto, englobando o código de modelagem do mesmo.
Para entender como elas funcionam,vamos relembrar o conceito de eixos,explicados ao longo das nossas aulas anteriores:
A terceira dimensão trabalha com 3eixos: x,y e z , estes eixos são a base para se aplicar uma transformação de forma adequada.
Por padrão, os eixos são a orgem da room(0,0,0), mas podemos mudá-lo,de acordo com a nossa nescessidade.
Para isso usaremos o método de transformações.

A estrutura de uma transformação é a seguinte:

1º- d3d_transform_set_identity()
iniciamos o modo de transformação.

2º- d3d_transform_add_...
aplicamos a transformação.

3º- d3d_transform_set_translation(xt,yt,zt)
definimos os eixos a se desenhar o modelo.

4º- d3d_draw_...
desenhamos o modelo.

5º- d3d_transform_set_identity()
terminamos o modo de transformação.

Seguindo este método, nós conseguiremos Transformar o modelo desejado.


                                             OS EIXOS

Os eixos vão determinar a posição na room, onde tudo vai acontecer.
Se vc quer que o modelo tenha as transformações aplicados em torno de si mesmo, vc deve definir a posição dele como eixo: (x,y,z).
Mas se deseja aplicar as transformações num local exato na room, você pode definir este local, como eixo. Por exemplo:(20,20,0)
Note que quando você define um eixo,com a posição exata, você não poderá mover seu modelo,pois não tem uma variável de referência para isso!
O mesmo vai ocorrer com as transformações, caso use um valor exato, não conseguirá alterá-lo em runtime, pois vc não definiu uma variável para isso.

Portanto, a regra para se obter o resultado esperado é a seguinte:
-Se o seu modelo, nunca vai sair do lugar,ou se vc está usando um objeto para desenhar modelos em vários locais na room, que vc sabe extamente onde é.
Exemplo:(Uma casa.)
Use um eixo fixo,com o valor que você deseja.

-Se o seu modelo vai se mover,ou se você tem um objeto específicamente pra ele.
Exemplo:(Um carro que se move.)
Use um eixo com variáveis(de preferência: x,y,z), assim vc pode movê-lo alterando o valor delas.

-Se seu modelo terá uma transformação definida,e não pretende mudá-la.
Exemplo:(uma casa,girada 90graus em torno de si.)
Use um valor exato para transformar.

-Se seu modelo terá transformações que mudam ao longo do jogo.
Exemplo:(Um carro que se move.)
Use varáveis para as transformações,assim vc pode transformá-la alterando o valor delas.


                                             ESCALA

O modo escalar é usado quando se deseja alterar o tamanho do modelo,sem ter que mecher nas suas coordenadas.
A função que o representa é a seguinte:
d3d_transform_add_scaling(xs,ys,zs)

Onde xs,ys e zs, são os valores de escala do objeto.
Tenha o valor 1 como padrão, tudo que for acima dele, vai aumentar o objeto, e o que for abaixo irá diminuir.



                                             ROTAÇÃO

A rotação é usada para fazer com que um modelo gire em torno de um eixo.
Pode ser feita pelas seguintes funções:
d3d_transform_add_rotation_x(Ângulo)
d3d_transform_add_rotation_y(Ângulo)
d3d_transform_add_rotation_z(Ângulo)
d3d_transform_add_rotation_axis(xa,ya,za,Ângulo)

Onde Ângulo é o valor que se deseja girar o modelo.
xa,ya e za seriam os eixos a serem transformados.


                                               POSIÇÃO

A posição do modelo é definida pelo eixo configurado para transformação,e portanto não se define uma função para alterá-la.
Isso deve ser feito manualmente por vc, criando variáveis para representar os eixos, e alterando elas, para mover o modelo.



                                               PRÁTICA

Como de costume, vamos praticar o que aprendemos aqui, para reforçar nossas idéias.

*Abra a engine construída na segunda aula,se não tem , baixe-a AQUI.

*Crie uma background no tamanho: 128x128, e coloque o nome de bplayer.

*Crie um objeto, e ponha o nome dele de: oplayer.

-No create dele,coloque o seguinte código:
//criamos a var z,para guardar a altura
z=10
//criamos as vars que vão guardar a quantia de rotação em cada eixo:
rx=0
ry=0
rz=0
//criamos as vars que vão guardar a quantia de escala em cada eixo:
xs=1
ys=1
zs=1

-Agora, ponha no Step:
//controles de rotação
if keyboard_check(ord("X"))
{
if keyboard_check(vk_add) rx+=2
if keyboard_check(vk_subtract) rx-=2
}

if keyboard_check(ord("Y"))
{
if keyboard_check(vk_add) ry+=2
if keyboard_check(vk_subtract) ry-=2
}

if keyboard_check(ord("Z"))
{
if keyboard_check(vk_add) rz+=2
if keyboard_check(vk_subtract) rz-=2
}

//controles de escala
if keyboard_check(ord("S"))
{
if keyboard_check(ord("X"))
{
if keyboard_check(vk_add) xs+=1
if keyboard_check(vk_subtract) xs-=1
}

if keyboard_check(ord("Y"))
{
if keyboard_check(vk_add) ys+=1
if keyboard_check(vk_subtract) ys-=1
}

if keyboard_check(ord("Z"))
{
if keyboard_check(vk_add) zs+=1
if keyboard_check(vk_subtract) zs-=1
}
}

-E por fim, coloque no Draw:
//inicia o modo de transformações:
d3d_transform_set_identity();
//aplica escala ao modelo:
d3d_transform_add_scaling(xs,ys,zs)
//aplica rotação ao eixo x:
d3d_transform_add_rotation_x(rx);
//aplica rotação ao eixo y:
d3d_transform_add_rotation_y(ry);
//aplica rotação ao eixo z:
d3d_transform_add_rotation_z(rz);
//Define os eixos para modelagem:
d3d_transform_add_translation(x,y,z);
//desenha o modelo na tela:
d3d_draw_ellipsoid(-8,-8,-8,8,8,8,background_get_texture(bplayer),1,1,16)
//Finalzia o modo de transformações:
d3d_transform_set_identity();

*Só pra esclarecer,ponha no Game Information:
Controles:
x+ :rotaciona no eixo x.
y+ :rotaciona no eixo y.
z+ :rotaciona no eixo z.
sx+: escala no eixo x.
xy+: escala no eixo y.
sz+: escala no eixo z.
Use setas para se movimentar.


*Coloque o objeto na room, e teste.

*Use os controles para girar e escalar ele.


                                                       CONCLUSÃO

As Transformações são de grande utilidade, e se você quer fazer algo que preste no GM3D, é bom que aprenda a usá-las.
Pode ser complicado entender no início, ou apenas com a explicação dada aqui.
Portanto vou deixar como exercício, que você baixe o meu programa: BRUM SHAPES
E brinque um pouco com ele!
Mas não se esqueça de testar as transformações que ele oferece: Posição,Escala e Rotação.
Troque os eixos que está transformando, Escale, Gire, Mova, Observe!!
E veja com frequência tb, o código gml gerado, ele é de grande ajuda para o entendimento das transformações.

Vou disponibilizar aqui, o download da engine, pra quem não conseguiu montar:  DOWNLOAD

Nas próximas aulas, vamos falar sobre texturas,colisão por simulação 2D,controles...

Até lá!

[Curso Gm 3D] Aula 4: MODELOS

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, Modelagem.
PRÉVIA:  Aprenderemos agora uma outra maneira de modelagem: Por modelos,que iremos usar no GM,o que nos permite importar modelos externos,ou criar nossos próprios, sem o uso de scripts complexos, nem dlls e extensões.
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.

INTRODUÇÃO

O Game Maker possui um método de modelagem mais profissional que o de Shapes.
É o método de Modelos!
Eles são mais velozes,mais fáceis de se usar,e geralmente apresentam melhores resultados.
Os modelos podem ser criados através de Shapes ou carregados de um arquivo externo,e ainda podem ser modelos através de vértices(que não irei abordar aqui).

FUNÇÕES BÁSICAS

INDICE=d3d_model_create () 
Cria um novo modelo e retorna seu índice. Esse índice é usado em todas as outras funções que lidam com modelos. Use esta função somente em eventos não repetitivos, ela deve ser usada apenas uma vez, para não ficar pesando o seu jogo.Por isso é recomendável que a use numa primeira room que não será recarregada,ou no create de um objeto que não seje criado novamente! Dependendo do seu jogo,ela pode ser usada também no evento game_start.
A variável INDICE que eu exemplifiquei, é a variável que irá guardar o id do modelo,recomendo que use var global,e de nome bem fácil de se lembrar.

d3d_model_destroy (ind)
Destrói o modelo com o índice determinado, liberando sua memória. Lembre-se de usá-la sempre que destruir algum modelo definitivamente, para liberar a memória.Geralmente é usada no evento destroy de um objeto.
ind: Variável com Índice do modelo que deseja apagar.

d3d_model_clear (ind)
Limpa o modelo com o índice determinado,removendo todos os seus shapes e primitivos.
Se vc vai redesenhar shapes num modelo durante o jogo, é recomendável que use esta função para limpar o modelo antes de adicionar os novos.
ind: Variável com Índice do modelo que deseja limpar.

d3d_model_save (ind, fname)
Salva o modelo para o nome do arquivo indicado.
Com isso você pode exportar seu modelo,no formato que desejar.
Para usá-lo novamente em outro jogo.

ind: Variável com Índice usado na criação do modelo, que contém o modelo.
fname: Nome do arquivo modelo que deseja salvar,(não se esqueça de botar a extensão.),o arquivo será salvo na mesma pasta do projeto.

d3d_model_load (ind, fname)
Carrega o modelo do nome do arquivo indicado.
Esta é a função que permite a você importar modelos externos para o seu jogo.
Geralmente são modelos .d3d(nativos do directx), ou .mod(semelhantes ao d3d),mas se você salvou algum modelo com a função anterior a esta, mesmo que com uma extensão inventada, você pode carregá-lo com esta função, visto que a estrutura dele é compatível.
ind: Variável com Índice usado na criação do modelo, para onde você irá adicionar este que está carregando.
fname: Nome do arquivo modelo que deseja carregar,(não se esqueça de botar a extensão.),o arquivo deve estar na mesma pasta do projeto.Se não estiver,especifique o caminho dele no nome.

d3d_model_draw (ind, x, y, z, texid)
Desenha o modelo guardado na variável ind ,na posição (x, y, z),texid é a textura a ser usada.
Use este evento no draw do objeto que vai renderizar o modelo.

CRIAÇÃO DE MODELOS POR SHAPES

A modelagem por shapes, tem as seguintes funções:

d3d_model_block (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat)
Adiciona uma forma de bloco para o modelo.

d3d_model_cylinder (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, closed, steps )
Adiciona uma forma cilíndo para o modelo.

d3d_model_cone (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, closed , steps )
Adiciona uma forma cone para o modelo.

d3d_model_ellipsoid (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat, steps)
Adiciona uma forma esfera para o modelo.

d3d_model_wall (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat)
Adiciona uma forma de parede para o modelo.

d3d_model_floor (ind, x1, y1, z1, x2, y2, z2, hrepeat, vrepeat)
Adiciona uma forma solo para o modelo.

Note que as funções são bem parecidas com as de d3d_draw, aprendidas na AULA PASSADA,
a única diferença é que não temos o parâmetro textura.
Isso foi feito de propósito pelo Tio Mark, pois sua intenção foi permitir que você possa modelar um modelo base, e desenhá-lo várias vezes,com texturas diferentes.Por isso as texturas serão aplicadas no evento draw, na função d3d_model_draw, que renderiza o modelo na tela.
Outra diferença das funções de draw, é que o eixo base para a modelagem aqui,será imaginário.
Ou seja, vc vai se basear num eixo para modelar os shapes, mas o modelo pronto não terá eixos.
Porque os eixos também serão definidos na hora da renderização.
Isso vai te possibilitar criar um modelo,e renderizá-lo em lugares diferentes.

PRATICANDO

Vamos criar uma engine,com algumas das funções vistas neste tuto.
Para isso,abra a nossa ENGINE BASE , que foi construída na SEGUNDA AULA .
Ela já tem a câmera, o solo, e os controles básicos para darmos seguimento às aulas.

Vamos iniciar,modelando os shapes básicos, que será renderizado na room em vários objetos.
E vamos importar um modelo externo,e renderizá-lo também.


INSTRUÇÕES

*Baixe ESTE MODELO , e extraia-o para a mesma pasta onde está sua engine.
Este é um modelo de um tank, em formato .mod, que será importado e renderizado na nossa engine.

*Crie uma room, e coloque o nome dela de: Load.
-No creation code dela, ponha o seguinte código:

//criamos os modelos:
global.cubo=d3d_model_create()
global.esfera=d3d_model_create()
global.cone=d3d_model_create()
global.cilindro=d3d_model_create()
global.solo=d3d_model_create()
global.parede=d3d_model_create()
global.modelo=d3d_model_create()

//adicionamos shapes para os respectivos modelos:
d3d_model_block(global.cubo,-8,-8,8,8,8,24,1,1)
d3d_model_ellipsoid(global.esfera,1-8,-8,0,8,8,16,1,1,24)
d3d_model_cone(global.cone,-8,-8,0,8,8,32,1,1,1,24)
d3d_model_cylinder(global.cilindro,-8,-8,0,8,8,64,1,1,1,24)
d3d_model_floor(global.solo,-128,-128,0.3,128,128,0.3,1,1)
d3d_model_wall(global.parede,-8,0,0,8,0,16,1,1)
d3d_model_load(global.modelo,"modelo.mod")

//mudar de room
room_goto_next()

*Agora crie uma Background,no tamanho de 128x128, com a imagem que preferir,e ponha o nome dela de: btextura.

*Crie objetos com  os seguintes nomes ,e ponha os respectivos códigos no draw,deles:
ocubo
d3d_model_draw(global.cubo,x,y,z,background_get_texture(btextura))
oesfera
d3d_model_draw(global.esfera,x,y,z,background_get_texture(btextura))
oparede
d3d_model_draw(global.parede,x,y,z,background_get_texture(btextura))
osolo
d3d_model_draw(global.solo,x,y,z,background_get_texture(btextura))
ocone
d3d_model_draw(global.cone,x,y,z,background_get_texture(btextura))
ocilindro
d3d_model_draw(global.cilindro,x,y,z,background_get_texture(btextura))
omodelo
d3d_model_draw(global.modelo,x,y,z,background_get_texture(btextura))

*no create de todos estes objetos, coloque o seguinte código:
//definimos a variável z no objeto.
z=0

*Espalhe todos os objetos pela segunda room, que já estava na engine,após a room Load.

Teste o jogo!




Conclusão

Você poderá notar que o uso de modelos é semelhante ao de Shapes,e poderá até pensar que é perca de tempo!, mas observe que estes modelos são carregados de forma rápida, e adiantam seus projetos, porque você vai modela-los apenas uma vez,e com o índice gerado, poderá usá-lo várias vezes! Inclusive em objetos diferentes, sem precisar fazer o código de modelagem de novo.
 O modelo externo se comportou de maneira correta! Isso foi possível porque ele é leve,e está num formato bem aceito pelo GM, que é o .mod! Com o aprendizado dessa aula, você poderá importar vários modelos semelhantes no seu jogo, mas lembre-se de deixá-los sempre bem leves,e use sempre .mod ou .d3d.

Se você tem modelo leves em formato .obj, e deseja convertê-los para .mod, você pode usar o:
BRUM SHAPES 1.1 ,e usar o modelo gerado em .mod no seu jogo, como foi explicado aqui.

Se você não conseguiu fazer a engine, você pode baixá-la aqui: DOWNLOAD

Até a próxima aula!

[Curso Gm 3D] Aula 3: MODELAGEM DE SHAPES

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, Modelagem.
PRÉVIA: Vamos aprender o básico da modelagem no Game Maker,falarei sobre a criação de shapes básicos,que temos no GM.
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.

INTRODUÇÃO

A modelagem por gml pode parecer complicada, mas com experiência pode tornar-se fácil!
Os eixos devem ser observados antes de se modelar algo,lembre-se que a referência do ponto,é a origem da room,ou seja, se você fornece a coordenada 320 como x1,a origem no eixo x do objeto será a posição x: 320 da room.Mas se você define x1 como x-16,a origem do modelo no eixo x, será:  16pixels antes do seu modelo no eixo x.

ATRIBUTOS

A modelagem de um shape é definida por uso de funções pré-definidas, com atributos a serem configurados.
Os atributos vão definir a posição,escala e texturização de um shape.
Abaixo eu detalho cada um:

Observem um exemplo de cubo,com as coordenadas destacadas:

Como podem ver, cada coordenada define o limite de renderização do objeto.São elas:
x1= é a origem do modelo no eixo x.
x2= é o fim do modelo no eixo x.
y1= é a origem do modelo no eixo y.
y2= é o fim do modelo no eixo y.
z1= é a origem do modelo no eixo z.
z2= é o fim do modelo no eixo z.

Além das coordenadas, os shapes podem ter os seguintes parâmetros:
texid= aplica uma textura ao shape,podendo ser uma cor,background ou sprite:
   cor= -1 ; vai deixar o shape com a cor definida no draw_set_color().
   background= background_get_texture(NOME_DA_BACKGROUND)
   sprite= sprite_get_texture(NOME_DA_SPRITE,SUB_IMAGEM)
hrepeat= quantidade de vezes que a textura se repetirá na horizontal, no shape.
vrepeat= quantidade de vezes que a textura se repetirá na vertical, no shape.
closed= indica se o shape será:    fechado(1) ou aberto(0) . (cilindro e cone)
steps= arredondamento do shape,tenha 24 como padrão,aumente pra ficar mais "redondo" ou diminua pra deixar mais "quadrado". (elipsoid,cilindro e cone)

SHAPES

 Os shapes do GM são modelados por códigos gml,cada shape tem sua função pré-determinada,com atributos a serem configurados.
São eles:

Floor(solo)
Os Floors,são os shapes mais simples de se modelar,são uma malha plana e fina,que se desenha da origem(x1,y1), até o fim(x2,y2),tendo a as coordenadas de altura(z1,z2) como inclinação.
Eles são usados na intenção de simular uma plataforma,por isso suas coordenadas z1 e z2 devem ser iguais(ou próximas),para que ele não fique desequilibrado.
Textura: se repete em ambos os lados.
Code:  d3d_draw_floor(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat)



Wall(parede)
A wall é bem parecida com o floor,porém é usada para simular paredes.
Ela deixa a critério do maker a escolha se será vertical ou horizontal.
Por exemplo,se vc quer a parede no eixo y, vc terá que definir valores não-nulos para x1,x2,z1,z2, deixando o eixo y(y1,y2) =0, verás que a parede fica reta, e de pé! Caso queira incliná-la lateralmente,altere o eixo y(y1,y2).
Textura: se repete em ambos os lados.
Code:  d3d_draw_wall(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat)


Block(cubo)
Os blocks são bastante usados no GM3D,ele aprsenta uma forma que deve ocupar espaço nas 3dimensões e são bem simples de se modelar.
Você não precisa anular nenhum eixo.
Textura: se repete em ambos os lados.
Code:  d3d_draw_block(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat)



Elipsoid(esfera)
A elisoid é uma das formas mais interessantes do GM, com ela podemos dar um toque melhor ao jogo, e através de um atributo chamado steps , você pode definir o arredondamento do shape.
Textura: Envolve toda a forma,se originando do centro superior do shape até o centro inferior.
Code: d3d_draw_ellipsoid(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,steps)

Cyllinder(cilindro)
Os cyllinders são desenhados de forma vertical(em pé).O atributo closed dele vai indicar se suas superfícies serão fechadas.Já o step vai indicar o arredondamento da forma.
Textura: Envolve toda a forma,lateralmente. As superfícies terão a cor base da textura, mas não serão propriamente texturizadas.
Code: d3d_draw_cylinder(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,closed,steps)

Cone(pirâmide)
Os cones são algo como uma pirâmide, e também são desenhados na vertical(em pé).
Iniciam com uma ponta bem fina,e vai se largueando,até a base.Seu atributo closed indica o fechamento da malha, e steps , o arredondamento.
Textura:  Envolve toda a forma,lateralmente. A superfície inferior(larga) terá a cor base da textura, mas não serão propriamente texturizada.
Code:  d3d_draw_cone(x1,y1,z1,x2,y2,z2,texid,hrepeat,vrepeat,closed,steps)

PRATICANDO

Vamos criar uma engine com todos os shapes que aprendemos aqui.
Abriremos a engine da aula passada,para aproveitar a câmera e o solo,e introduziremos as outros shapes.

1º-> Abra a engine da aula anterior , ou se não a fez, baixe ela AQUI.

2º-> Crie um objeto, e chame-o de ofloor.
Coloque no draw:
/*modelamos um shape floor(solo), na altura(z1,z2) 0,que vai da origem(0,0) da room, até o final da room. Com a textura do solo,se repetindo 32x.*/
d3d_draw_floor(0,0,0,room_width,room_height,z,bsolo,32,32)

3º-> Crie uma background de 128x128,com a textura que desejar,coloque o nome dela de besfera.
Crie um objeto,e chame-o de oelipsoid.
Coloque no draw:

//definimos a transparência de desenho para 0.7
draw_set_alpha(0.7)

/*modelamos uma esfera,na posição onde colocamos ela na room,com uma textura de repetição única.E um arredondamento de 24.*/
d3d_draw_ellipsoid(x-8,y-8,0,x+8,y+8,16,background_get_texture(besfera),1,1,24)

//voltamos o a transparência de desenho para 1.
draw_set_alpha(1)

4º-> Crie um objeto,e chame-o de oblock.
Coloque no create:
//declaramos a var z=5.
z=15
Coloque no draw:
/*criamos um bloco,e desenhamos ele na posição do objeto na room,e na altura definida em z, este bloco não terá textura, e será renderizado com a cor usada para desenhar.(que neste caso,é branco!)*/
d3d_draw_block(x-10,y-10,z-10,x+10,y+10,z+10,-1,1,1)


5º-> Crie uma background de 128x128 e coloque o nome de bmuro.
Crie um objeto,e chame-o de owall.

Coloque no Create:
z=0
Coloque no draw:
/*modelamos uma parede em pé,no eixo x,anulamos o eixo y,para que ela fique reta,será desenhada no local onde está o objeto,com a textura do muro,se repetindo 10x hor e 1x ver.*/
d3d_draw_wall(x-100,y,z,x+100,y,z+10,background_get_texture(bmuro),10,1)


6º-> Crie uma objeto e coloque o nome de ocone.
Coloque no Create:
z=20
Coloque no draw:
//definimos a cor de desenho para amarelo.
draw_set_color(c_yellow)
/*modelamos um cone,no local do objeto,na altura de z,sem textura,usaremos a cor de desenho,definindo ele como fechado, e com um arredondamento de 8.*/
d3d_draw_cone(x-10,y-10,z-10,x+10,y+10,z+10,-1,1,1,1,8)
//voltamos a cor de desenho para branco novamente,para que o resto do jogo não fique amarelo.
draw_set_color(c_white) 

7º-> Crie uma background e coloque o nome de bcilindro.
Crie um objeto,e coloque o nome de ocilindro.
Coloque no create dele:
z=0
Coloque no draw:
//modelamos um cilindro fechado,no local onde está o objeto,na altura de z,com 24 de arredondamento.
d3d_draw_cylinder(x-10,y-10,z,x+10,y+10,z+30,background_get_texture(bcilindro),1,1,1,24)

8º-> Crie uma nova room, coloque o nome dela de: Shapes.
Coloque a câmera nela.
Coloque os objetos espalhados por ela.
Teste o jogo.
Mova-se pelo cenário, e olhe atentamente cada forma.
Perceba , como cada uma tem características individuais, note também os efeitos que aplicamos a cada uma:
-O solo,que tem o eixo na origem da room.
-A esfera com transparência.
-O bloco que está sem textura, usando a cor de desenho que é branco.
-O muro, com textura que se repete apenas na horizontal.
-O cone que fica no alto e é desenhado com a cor amarela sem afetar os outros shapes.
-O cilindro com altura e textura não repetida.


Existem outras formas de modelagem no GM, porém, essa é a mais fácil, e a mais provável.
Fique atento para suas texturas, que devem ter medidas proporcionais aos modelos.
As texturas de 128x128, 256x256 e derivadas, quase sempre dão certo no seu shape, mas às vezes é preciso alterá-las.
Nas próximas aulas eu vou abordar outras formas de modelagem e falarei mais sobre as texturas.
Edit: Aqui está o link,pra quem não conseguiu criar a engine:

DOWNLOAD

[Curso Gm 3D] Aula 2: VISUALIZANDO O MUNDO

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, Visualizando o mundo.
PRÉVIA: Vamos iniciar os trabalhos com o game maker no modo 3D, iniciando com os códigos, e criando nossa primeira engine,faremos uma engine simples, com: câmera em primeira pessoa,solo e movimentos básicos.
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.

INTRODUÇÃO

Como eu já havia dito no tutorial anterior:" a câmera é o principal objeto de um jogo 3D.", ela é quem definirá o estilo de visualização do jogo. Algumas vezes vocês me verão chamá-la de projeção, para que você não se confunda, na hora de mudar a vista do seu jogo.

SCRIPT

Abra o seu Game Maker, inicie um novo projeto,crie um objeto, e coloque o nome dele de ocam.
No depth dele coloque 10000,isso é nescessário para que a câmera seje o último objeto a ser renderizado na room, permitindo assim que vc veja todos os outros à sua frente.
->No create do objeto,nós vamos colocar o seguinte código:

//iniciaremos o modo 3D

d3d_start()
//Setamos a cor de desenho para branco(neutro).
draw_set_color(c_white)

//criamos a variável z,e atribuimos um valor a ela:

z=10

O que fizemos foi "avisar" ao GM,que estamos no modo 3D, e isso vai mudar completamente a forma com que ele tratará o nosso jogo.
*as mudanças foram citadas no 1º tuto da série.

->Baixe uma textura de solo(pode ser de grama),e certifique-se de que ela tem a medida de 128x128,
Se quiser pode usar essa:

->Crie uma background,e carregue a textura do solo para ela.e coloque o nome de: bsolo.

->Vá ao evento Draw,e ponha o seguinte código:

/*Criamos a projeção da câmera,com uma geometria simples,que permitirá enchergar em 180º,à 
frente dela, como na visão humana.*/
d3d_set_projection(x,y,z,x+cos(direction*pi/180),y-sin(direction*pi/180),z,0,0,1);
//Modelamos um solo.
d3d_draw_floor(0,0,0,room_width,room_height,0,background_get_texture(bsolo),32,32)



Ao criar a projeção,nós definimos uma visão de 180º à nossa frente, como na visão humana,como nossa câmera será dinâmica, nós definimos a direction, como a variável que vai mudar o nosso ângulo de visão.
Depois, modelamos um solo simples,que vai da origem até o final da room,com a textura de solo,que se repitirá 32vezes na horizontal e 32vezes na vertical. Você pode ajustar esses valores para obter um melhor resultado.Quanto mais repetições, mais real será o resultado.
Vou abordar melhor sobre as texturas numa futura aula,sobre modelagem.

Agora vamos configurar o movimento da nossa câmera:
->Vá no evento Step,e coloque o código:

//setamos a fricção da câmera.

friction=.5

//Configuramos os movimentos da câmera pelas setas do teclado:

if keyboard_check(vk_right) direction-=5
if keyboard_check(vk_left) direction+=5
if keyboard_check(vk_up) speed=5
if keyboard_check(vk_down) speed=-5

Setamos uma fricção na câmera, fazendo com que ela  desacelere quando estiver se movendo.
E depois criamos moveimentos na câmera, através do teclado.
As setas laterais vão mudar a direction da câmera, o que fará com que ela gire,e as setas verticais,vão setar a velocidade, fazendo ela se mover para frente e para trás.

CONCLUSÃO

Bom, depois de tudo isso temos a nossa engine com câmera,solo e movimentos básicos.
A partir dela vamos continuar o curso nas próximas aulas, implementando: gravidade,modelos,texturas,mais controles e outras coisas.
Se você não conseguiu montar a engine, seguindo o tutorial, aqui vai o download:

DOWNLOAD

[Curso Gm 3D] Aula1: INICIANDO NO MODO 3D

ENGINE: Game Maker
NÍVEL: intermediário
TEMA: Game Maker, modo 3D .
PRÉVIA: Neste artigo eu pretendo abordar o tema , mas sem usar códigos, por enquanto, quero apenas passar os conceitos iniciais, para que nos próximos artigos da série ,vocês já tenham uma noção de como funciona o 3D no Game Maker..
DIREITOS: Este tutorial não pode ser copiado nem exibido em outros locais na internet sem a devida autorização do autor.Caso tenha interesse em usá-lo ,contate-me.

INTRODUÇÃO

  Se você nunca teve experiência com 3D no Game Maker, poderá parecer um pouco complicado pra você,criar um jogo 3D nele.Mas depois de estudos e treinos , tudo se tornará bem claro,e intuitivo, e te tornará possível,fazer seu jogo sem complicações.
   O Game Maker foi criado para fazer jogos, mas tendo total foco no 2D. A parte 3D é como que um bônus inserido de última hora pelo tio Overmars. Por isso muita gente diz que não dá pra se fazer bons jogos 3D nele, eu desminto,e digo que com um pouco de esforço você consegue sim fazer bons jogos nele.

A TERCEIRA DIMENSÃO

   A terceira dimensão é indicada em muitos locais como o eixo Y,porém no Game Maker o eixo é representado por  Z:

   As coordenadas 2D do GM são representadas pelas variáveis x e y por padrão, porém quando iniciamos a programação 3D nele, a variável z não é criada automaticamente, temos que criá-la manualmente.E este é
um dos primeiros erros de muitos makers que iniciam o 3D no GM. Portanto é de essencial importância,que você esteje sempre atento para essa variável, assim como está para x e y nos seus jogos 2D.
   Outro ponto importante a se considerar é que a coordenada y ficará invertida neste novo modo.
Em seus jogos 2D você poderá perceber que a origem do y(0,0) fica no canto esquerdo superior da sua tela,mas ao iniciar o modo 3D, esta origem vai passar para o canto esquerdo inferior, porém é uma coisa que às vezes passa batido por nós, já que a coordenada y,é que nos parece a nova coordenada.

A CÂMERA

   A parte essencial dos jogo 3D com certeza é a câmera,no GM a câmera é chamada de projeção,e é através dessa projeção que será renderizado o seu jogo,caberá ao Maker configurá-la e adaptá-la ao seu jogo. Uma regra que ele não pode esquecer jamais, é que todos os objetos do jogo deverão ter depths menores que o da câmera. Isso é nescessário para que sejam vistos corretamente.Isso ocorre porque o depth irá definir a camada de desenho na tela, e quando mais de um objeto estiver alinhado na tela, somente o de menor depth será visto, portanto se seu objeto tiver um depth menor que o da câmera, isso garante que ele será visualizado corretamente.

POTENCIAL

   Quando estamos em busca do aprendizado, uma coisa que nos estimula muito é ver o potencial que teremos ao fim dos estudos,portanto vou apresentar uma lista com as funções que o GM3D pode fazer:
Modelar formas básicas: ( Blocos,Elipsoids,Cones,Cilindros,Paredes,Solos.)
Modelar polígonos: (através de faces triangulares.)
Aplicar transformações: (rotação,posição,escala.)
Texturizar: (usa as backgrounds e até sprites para texturizar os modelos.)
Criar Neblina: (é um efeito visual que o GM usa para embaçar a visão mais distante.)
Criar iluminação: (criar efeitos de iluminação no jogo.)
Usar modelos: (criar,carregar e salvar modelos.)
Visão ortográfica: (é uma porjeção 2D que pode ser usada para desenhar sprites ou texto na tela.)

REFERÊNCIAS

   Então pra deixar você com água na boca,e ancioso pelos próximos artigos,aqui vai algumas screens,de jogos 3D feitos no Game Maker: